为什么这个正则表达式只适用于字符串结束符号？

Question

Given these strings:

'module1'

'{ module2 }'

'{ module3 as module4 }'

and needing a regular expression to capture the (sub)strings 'module1', 'module2' & module4', this works:

/({ )?(.*as )?(.+?)( })?$/

Which breaks down to:

({ )?       // Optional opening parens
(.*as )?    // Optional 'blah as '
(.+?)       // The important bit
( })?$      // Optional closing parens, EOS

Why does it fail to match if the end of string character $ is omitted?

(Also, I'm aware that the unneeded capture groups can be made into matching groups, but keeping it easier to read...)

Answer 1

The problem

Lets play the two regex patterns out:

Pattern 1

Regex                        : String
/({ )?(.*as )?(.+?)( })?$/   : module1

1. Checks for "{ "    >> but it's optional and doesn't exist so pass.
2. Checks for ".*as " >> but it's optional and doesn't exist so pass.
3. Checks for ".+?"   >> matches any character 1 or more times until the next item it HSA to match (in a non-greedy manor)
4. Checks for " }"    >> but it's optional and doesn't exist so pass.
5.Checks for "$"      >> #3 has to match to this point otherwise there won't be a match!

Regex 2

Regex                        : String
/({ )?(.*as )?(.+?)( })?/    : module1

1. Checks for "{ "    >> but it's optional and doesn't exist so pass.
2. Checks for ".*as " >> but it's optional and doesn't exist so pass.
3. Checks for ".+?"   >> matches any character 1 or more times until the next item it HAS to match (in a non-greedy manor)
4. Checks for " }"    >> but it's optional and doesn't exist so pass.

The problem is that ".+?" is non-greedy and therefore (as the other terms are all ignored, because they don't exist) it stops matching at the next possible match. i.e. each and every character is a match.

A solution

This is tricky without knowing what the values for "module" may be (ie letters, spaces, numbers)...

However something like...

(\w+)(?:\s})?$
(                : Start of capturing group
 \w+             : Matches [a-zA-Z0-9_] one or more times
    )            : End of capturing group
     (?:         : Start of non-capturing group
        \s*}     : Matches 0 or more white space characters followed by a "}"
            )?   : End of non-capturing group and make it optional
              $  : Matches the end of the string

...will extract the modules without capturing the surrounding spaces and braces etc.

NB

This only works if the module is:

• The last word in the string
• One word only
• Only made up of letters, numbers, and underscores

Example

$strings = [
    'module1',
    '{ module2 }',
    '{ module3 as module4 }'
];

foreach($strings as $string){
    preg_match('/(\w+)(?:\s*})?$/', $string, $match);
    var_dump($match[1]);
}

/*
Output

string(7) "module1"
string(7) "module2"
string(7) "module4"

*/

Second example

Because I realised this question was asked for JS not PHP!!!!

var strings = [
    'module1',
    '{ module2 }',
    '{ module3 as module4 }'
];
var pattern = /(\w+)(?:\s*})?$/
for(i = 0; i < strings.length; i++){
    console.log(strings[i].match(pattern)[1]);
}

/*
Output

module1
module2
module4

*/

Answer 2

Without using the $ to assert the end of the string, the minimum match is 1 char due to the.+? and the rest is optional.

There will be no rule that states that the pattern has to fulfil the match until the end of the string, so it can have more matches until all the characters are processed.

When there is a $ present, the .+? can give up matches until it reaches the end of the string, or matches a } if it is present due to it being non greedy.

Note that using ({ )? will also match a curly without the closing curly, or the other way around.

---

What you might do is optionally match until you encounter as between parenthesis and then capture the rest in group 1. Or you capture the whole string in group 2.

\{(?:[^{}]* as )? *([^{}]*) }|(.+)

• \{ Match {
• (?:[^{}]* as )? * (?:[^{}]* as )? * Optionally match the part inside the curly braces until as
• ([^{}]*) Capture group 1, match 0+ times any char except { and }
• } Match }
• | Or
• (.+) Capture group 2, match the whole line (as least a single character)

Regex demo

 const regex = /\{(?:[^{}]* as )? *([^{}]*) }|(.+)/g; [ 'module1', '{ module2 }', '{ module 3 as module4 }' ].forEach(s => console.log( Array.from(s.matchAll(regex), m => m[1]?== undefined: m[1]; m[2])));