正则表达式系列（模板替换，预查，不捕获)

一. 模板替换(repalce)

1. 代码示例

const str = 'my name is {{name}},my age is {{age}}';

const rg = /{{(.*?)}}/g;

const res = str.replace(rg, (node, $1) => ({
  name: 'jack',
  age: 18
}[$1]));

console.log(res); // my name is jack,my age is 18

2. 匹配指定内容

const str = 'my name is (name), my age is (age)';

const rg = /\((\w+)\)/g;

const res = str.match(rg);

console.log(res, 'res'); // ["(name)", "(age)"]

const data = str.replace(rg, (match, key) => {
  console.log(key, 'key'); // name age
});

match 方法在带有 g 标志时不会返回捕获组的详细信息，它只返回完整的匹配项数组（不包括子匹配或捕获组）。因此，res 数组中的元素是完整的括号及其内的内容，比如 “(name)” 和 “(age)”;

当你使用 str.replace(rg, (match, key) => {…}) 时，情况就不同了。replace 方法的第二个参数可以是一个函数，该函数在每次匹配时都会被调用，并且它接收几个参数：match 是完整的匹配项（包括括号），而随后的参数（在这个例子中是 key）对应于正则表达式中的捕获组（如果有的话）。在你的正则表达式 /((\w+))/g中，(\w+) 是一个捕获组，它匹配并捕获括号内的内容（不包括括号本身）。

因此，在 replace 方法的回调函数中：
match 参数的值是完整的匹配项，比如 “(name)” 或 “(age)”。
key 参数（在这个上下文中我通常称之为 capture 或 group 而不是 key，因为它更准确地描述了它的内容）的值是捕获组的内容，即括号内的文本，比如 “name” 或 “age”，但不包括括号。

3. 多个捕获组匹配

const str = 'my {{date}} name is (name), my age is (age)';

const rg = /\((\w+)\)|{{(\w+)}}/g;

const res = str.match(rg); // 注意：这将只包含完整的匹配项，不包括捕获组的内容
console.log(res, 'res'); // 输出: ["(name)", "(age)", "{{date}}"]

const data = str.replace(rg, (match, key1, key2) => {
  if (key1) {
    // 匹配了 (\w+)
    console.log(key1, 'inside parentheses');
    return `{${key1}}`; // 或者其他你想要的替换
  } else if (key2) {
    // 匹配了 {{(\w+)}}
    console.log(key2, 'inside curly braces');
    return `{{${key2}}}`; // 或者保持不变，或者进行其他处理
  }
  // 注意：理论上这里不需要 else 分支，因为 key1 和 key2 是互斥的
  return match; // 如果没有匹配到任何捕获组（实际上不会发生），就返回原字符串（但这里不会执行）
});

console.log(data); // 输出: my {{date}} name is {name}, my age is {age}

二. 非获取捕获（(?:pattern)）

const str = 'my {{ffname3}} is {{title}},my age is {{name}}';

const rg = /{{(?:na)(me)}}/g;

const res = str.replace(rg, (node, $1, $2) => {
  console.log(node, $1, $2); // {{name}} me 38
});

加了？：相当于去除子表达式(),所以na无法在$中获取，主要针对于有些正则表达式确实比较复杂，需要用子表达式，却又想不被捕获的情况。

三. 预查

(?=pattern)
正向肯定预查（look ahead positive assert），在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，“Windows(?=95|98|NT|2000)“能匹配"Windows2000"中的"Windows”，但不能匹配"Windows3.1"中的"Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。

(?!pattern)
正向否定预查(negative assert)，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如"Windows(?!95|98|NT|2000)“能匹配"Windows3.1"中的"Windows”，但不能匹配"Windows2000"中的"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。

(?<=pattern)
反向(look behind)肯定预查，与正向肯定预查类似，只是方向相反。例如，“(?<=95|98|NT|2000)Windows"能匹配"2000Windows"中的"Windows”，但不能匹配"3.1Windows"中的"Windows"。

(?<!pattern)
反向否定预查，与正向否定预查类似，只是方向相反。例如"(?<!95|98|NT|2000)Windows"能匹配"3.1Windows"中的"Windows"，但不能匹配"2000Windows"中的"Windows"。