22

i am new to regex. I am trying to parse all contents inside curly brackets in a string. I looked up this post as a reference and did exactly as one of the answers suggest, however the result is unexpected.

Here is what i did

var abc = "test/abcd{string1}test{string2}test" //any string
var regex = /{(.+?)}/
regex.exec(abc) // i got ["{string1}", "string1"]
             //where i am expecting ["string1", "string2"]

i think i am missing something, what am i doing wrong?

update

i was able to get it with /g for a global search

var regex = /{(.*?)}/g
abc.match(regex) //gives ["{string1}", "{string2}"]

how can i get the string w/o brackets?

6 Answers 6

33
"test/abcd{string1}test{string2}test".match(/[^{}]+(?=\})/g)

produces

["string1", "string2"]

It assumes that every } has a corresponding { before it and {...} sections do not nest. It will also not capture the content of empty {} sections.

Sign up to request clarification or add additional context in comments.

5 Comments

This is good. But you do not need to escape the closing brace. /[^{}]+(?=})/g
How do the same with this braces? [ ]
@AuthorProxy, to include [ or ] in a character set, escape them. [\[\]] is a character set with only the square brackets.
@MikeSamuel it doesn't work, check at any online regexp
@AuthorProxy I did. /[\[\]]+/.exec('a[[]]b')[0] === '[[]]' is true in JS.
4
var abc = "test/abcd{string1}test{string2}test" //any string
var regex = /{(.+?)}/g
var matches;

while(matches = regex.exec(abc))
    console.log(matches);

Comments

3

Try this:

var abc = "test/abcd{string1}test{string2}test" //any string
var regex = /{(.+?)}/g //g flag so the regex is global
abc.match(regex) //find every match

a good place to read about Regex in javascript is here, and a nice place to test is here

good luck!

2 Comments

I don't think g would make a difference here. It is not getting the second match (string2) because it is calling exec only once.
@Kash you're right, but I called match, and without the g, it will return ["{string1}", "string1"]
1

Nothing wrong. But you'll need to look at your capturing groups (the second element in the array) to get the content you wanted (you can ignore the first). To get all occurences, it's not enough to run exec once, you'll need to loop over the results using match.

Edit: nevermind that, afaik you can't access capturing groups with match. A simpler solution would be using a positive lookahead, as Mike Samuel suggested.

Comments

1

This result:

["{string1}", "string1"]

is showing you that for the first match, the entire regex matched "{string1}" and the first capturing parentheses matched "string1".

If you want to get all matches and see all capturing parens of each match, you can use the "g" flag and loop through, calling exec() multiple times like this:

var abc = "test/abcd{string1}test{string2}test"; //any string
var regex = /{(.+?)}/g;
var match, results = [];
while (match = regex.exec(abc)) {
    results.push(match[1]);   // save first captured parens sub-match into results array
}

// results == ["string1", "string2"]

You can see it work here: http://jsfiddle.net/jfriend00/sapfm/

3 Comments

assignment in a condition... not my cup of tea.
It's an efficient way to do this type of loop and somewhat common for this exact purpose. I would generally avoid it too, except in this type of case. You can take a couple more lines of code to accomplish the same thing without it if you want.
thanks for the explanation, i was wondering why the same string appeared twice. thank you!
1

try this for file

const fs = require('fs');

fs.readFile('logs.txt', function(err, data) {
if(err) throw err;
const paragraph = "'" + data + "'";
const regex = /\d+\<;>\S+\<;>(\d+)\<;/g;
const found = paragraph.match(regex);

console.log(found);
})

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.