学会JavaScript正则表达式（一）

const str = 'abc abbc abbbbbc';
const result = str.match(regex);
console.log(result); // 输出: [ 'abc', index: 0, input: 'abc abbc abbbbbc', groups: undefined ]

const pattern = 'ab+c';
const flags = 'i'; // 不区分大小写
const regex = new RegExp(pattern, flags);

const str = 'aBc AbBc aBBBBc';
const result = str.match(regex);
console.log(result); // 输出: [ 'aBc', index: 0, input: 'aBc AbBc aBBBBc', groups: undefined ]

const regex = new RegExp(`\\d`); // 实际上不需要双重转义，但这里为了演示
// 或者更简洁地
const regex = /\d/; // 直接使用字面量语法，通常更可取

const regexNonGlobal = /foo/; // 非全局模式
const regexGlobal = /foo/g; // 全局模式

const str = 'foo and foo';

const matchesNonGlobal = str.match(regexNonGlobal);
const matchesGlobal = str.match(regexGlobal);

console.log(matchesNonGlobal); // 输出: [ 'foo', index: 0, input: 'foo and foo', groups: undefined ]
console.log(matchesGlobal); // 输出: [ 'foo', 'foo' ]

const regexCaseSensitive = /FOO/; // 区分大小写
const regexCaseInsensitive = /FOO/i; // 不区分大小写

const str = 'FOO and foo';

const matchesCaseSensitive = str.match(regexCaseSensitive);
const matchesCaseInsensitive = str.match(regexCaseInsensitive);

console.log(matchesCaseSensitive); // 输出: [ 'FOO', index: 0, input: 'FOO and foo', groups: undefined ]
console.log(matchesCaseInsensitive); // 输出: [ 'FOO', 'foo' ]

const regexSingleLine = /^foo/; // 单行模式
const regexMultiLine = /^foo/m; // 多行模式

const str = 'foo\nfoo';

const matchesSingleLine = str.match(regexSingleLine);
const matchesMultiLine = str.match(regexMultiLine);

console.log(matchesSingleLine); // 输出: [ 'foo', index: 0, input: 'foo\nfoo', groups: undefined ]
console.log(matchesMultiLine); // 在某些环境中可能不会按预期工作，因为match()方法不完全支持多行模式

// 使用exec()方法在多行字符串中查找所有匹配项
let regexMultiLineExec = /^foo/m;
let result;
while ((result = regexMultiLineExec.exec(str)) !== null) {
  console.log(result[0]); // 输出每行匹配的'foo'
}
// 输出:
// foo
// foo

// \d 示例：匹配数字
const regexDigits = /\d+/;
const strDigits = '123abc456';
const matchDigits = strDigits.match(regexDigits);
console.log(matchDigits[0]); // 输出: "123" (只会匹配到第一个连续的数字序列)

// \w 示例：匹配字母、数字或下划线
const regexWordChars = /\w+/;
const strWordChars = 'hello_world123';
const matchWordChars = strWordChars.match(regexWordChars);
console.log(matchWordChars[0]); // 输出: "hello_world123"

// . 示例：匹配任意字符（换行符除外）
const regexAnyChar = /a.b/;
const strAnyChar = 'axb\nayb';
const matchAnyChar = strAnyChar.match(regexAnyChar);
console.log(matchAnyChar[0]); // 输出: "axb" (不会匹配换行后的"ayb")

// * 示例：匹配前面的字符零次或多次
const regexStar = /ab*c/;
const strStar = 'acabcabbc';
const matchStar = strStar.match(regexStar);
console.log(matchStar[0]); // 输出: "abbc" (匹配尽可能多的"b")

// + 示例：匹配前面的字符一次或多次
const regexPlus = /ab+c/;
const strPlus = 'acabcabbc';
const matchPlus = strPlus.match(regexPlus);
console.log(matchPlus[0]); // 输出: "abbc" (至少匹配一次"b")

// ? 示例：匹配前面的字符零次或一次
const regexQuestion = /ab?c/;
const strQuestion = 'acbabc';
const matchQuestion = strQuestion.match(regexQuestion);
console.log(matchQuestion[0]); // 输出: "ac" (可以没有"b")

// {n} 示例：匹配前面的字符恰好 n 次
const regexExact = /ab{2}c/;
const strExact = 'abbcabcab';
const matchExact = strExact.match(regexExact);
console.log(matchExact[0]); // 输出: "abbc" (恰好匹配两次"b")

// {n,} 示例：匹配前面的字符至少 n 次
const regexAtLeast = /ab{2,}c/;
const strAtLeast = 'abbcabbbbc';
const matchAtLeast = strAtLeast.match(regexAtLeast);
console.log(matchAtLeast[0]); // 输出: "abbbbc" (至少匹配两次"b"，尽可能多地匹配)

// {n,m} 示例：匹配前面的字符至少 n 次，但不超过 m 次
const regexRange = /ab{2,4}c/;
const strRange = 'abbcabbbbcabbbbbc';
const matchRange = strRange.match(regexRange);
console.log(matchRange[0]); // 输出: "abbbbc" (匹配两到四次"b"，尽可能多地匹配)