这个捕获组在 Javascript 的替换函数文档中的这个正则表达式中做了什么？

Question

Here is the code:

I think the following example will set newString to:

'abc - 12345 - #$*%':

function replacer(match, p1, p2, p3, offset, string) {
  // p1 is nondigits, p2 digits, and p3 non-alphanumerics
  return [p1, p2, p3].join(' - ');
}

var newString = 'abc12345#$*%'.replace(/([^\d]*)(\d*)([^\w]*)/, replacer);

I am unsure what the 3 capture groups are doing in the regex expression? Does the first parathesis:

([^/d]*)

capture everything that is not a digit?

Does the second group capture everything that is a digit?

Does the third group capture everything that is not an alphanumeric character (letter or number)?

What gets passed into the replacer function? What would be p1 p2 and p3 if the replacer function in the replace function doesn't receive any arguments?

Answer 1

I often use https://regex101.com/ and https://www.debuggex.com/ for explaining regular expressions.

This is how Regex101 explains expression in question

And this is how Debuggex explains expression in question

Debuggex

Also if you debug this in Chrome console this is what you should get

I hope this helps you understand this better

Answer 2

The pattern ([^\\d]*)(\\d*)([^\\w]*) is being used to match three segments of your input string abc12345#$*% .

1. ([^\\d]*) - matches any non-digit zero or more times using negation [^] , in this case abc .
2. (\\d*) - matches zero or more digits [0-9] following the previous capture group, in this case 12345 .
3. ([^\\w]*) - matches any character not in the set [A-Za-z0-9_] following the previous capture group, so pretty much special characters. In this case #$*% .

Your replacer function is not actually replacing those capture groups, but preserving them and putting dashes - between them.

Because there are three capture groups (as explained above), the three params p1 - p3 represent those.

The function params are dynamically populated based on the number of capture groups in your pattern (part of the laid-back nature of JavaScript). So if you had 4 capture groups, there would be four capture group params:

function replacer(match, p1, p2, p3, p4, offset, string) { ... }

And the param names obviously aren't significant, just whatever you want to call them in your function.

The replacer function takes the three capture group params and returns the following: [p1, p2, p3].join(' - ') . This just puts - (with spaces on either side) between the capture groups and returns abc - 12345 - #$*% .

Further reading on the join function: Array.prototype.join() .

Answer 3

1. ([^\\d]*) matches 0 or more non . It could be written as ([\\D]*)
2. (\\d*) matches 0 or more digits
3. ([^\\w]*) matches 0 or more non characters. It could be written as ([\\W]*)
4. The parameters passed to the replacer function are: the matched substring, every captured group (if nothing is captured an empty string is passed), the offset that has to be examinated of the string (last parameter)

For a better explaination see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace