python和JavaScript的正则表达式详细使用对比

import re

text = "The quick brown fox jumps over the lazy dog 123. Windows 2000 and XP Windows. test test."

# 匹配
match = re.search(r'\bfox\b', text)
if match:
    print("Match found:", match.group())  # 输出 'fox'

# 搜索（使用量词和表达式分组）
search_result = re.findall(r'(\b\w{4}\b)', text)
print("Search results:", search_result)  # 输出 ['quick', 'jumps', 'over', 'lazy']

# 分割
split_result = re.split(r'\s', text)
print("Split results:", split_result)

# 替换（使用子表达式引用）
replace_result = re.sub(r'(\w+) (\w+)', r'\2 \1', text)
print("Replace results:", replace_result)

# 正向和反向声明（Lookahead and Lookbehind）
lookahead = re.search(r'Windows(?= 2000)', text)
if lookahead:
    print("Lookahead found:", lookahead.group())  # 输出 'Windows'

lookbehind = re.search(r'(?<=XP )Windows', text)
if lookbehind:
    print("Lookbehind found:", lookbehind.group())  # 输出 'Windows'

# 子表达式引用
repeat_word = re.search(r'(\b\w+\b) \1', text)
if repeat_word:
    print("Repeat word found:", repeat_word.group())  # 输出 'test test'

# 表达式分组使用
grouped = re.search(r'(\b\w+\b) over the (\b\w+\b)', text)
if grouped:
    print("Words over:", grouped.groups())  # 输出 ('jumps', 'lazy')

let text = "The quick brown fox jumps over the lazy dog 123. Windows 2000 and XP Windows. test test.";

// 匹配
let match = text.match(/fox/);
if (match) {
    console.log("Match found:", match[0]);  // 输出 'fox'
}

// 搜索（使用量词和表达式分组）
let searchResult = text.match(/\b\w{4}\b/g);
console.log("Search results:", searchResult);  // 输出 ['quick', 'jumps', 'over', 'lazy']

// 分割
let splitResult = text.split(/\s/);
console.log("Split results:", splitResult);

// 替换（使用子表达式引用）
let replaceResult = text.replace(/(\w+) (\w+)/g, '$2 $1');
console.log("Replace results:", replaceResult);

// 正向和反向声明（Lookahead and Lookbehind）
let lookahead = text.match(/Windows(?= 2000)/);
if (lookahead) {
    console.log("Lookahead found:", lookahead[0]);  // 输出 'Windows'
}

let lookbehind = text.match(/(?<=XP )Windows/);
if (lookbehind) {
    console.log("Lookbehind found:", lookbehind[0]);  // 输出 'Windows'

// 子表达式引用
let repeatWord = text.match(/(\b\w+\b) \1/);
if (repeatWord) {
    console.log("Repeat word found:", repeatWord[0]);  // 输出 'test test'
}

// 表达式分组使用
let grouped = text.match(/(\b\w+\b) over the (\b\w+\b)/);
if (grouped) {
    console.log("Words over:", grouped[1], grouped[2]);  // 输出 'jumps', 'lazy'
}

const regex = /(\w+)\s/g;
const text = "hello world";
let match;

while ((match = regex.exec(text)) !== null) {
    console.log(`Found ${match[0]}, next starts at ${regex.lastIndex}.`);
    // 输出: Found hello , next starts at 6
    //       Found world, next starts at 11
}

const regex = /hello/;
const text = "hello world";
const result = regex.test(text);  // 返回 true
console.log(result);

// 定义一个正则表达式对象，包含多个修饰符
let regex = new RegExp('foo', 'gim');

// 实例属性
console.log("Source:", regex.source);         // 输出: foo
console.log("Flags:", regex.flags);           // 输出: gim
console.log("Global:", regex.global);         // 输出: true
console.log("Ignore Case:", regex.ignoreCase); // 输出: true
console.log("Multiline:", regex.multiline);   // 输出: true

// 使用正则表达式进行匹配
let text = "Foo bar foo";
let match;
while ((match = regex.exec(text)) !== null) {
    console.log(`Found '${match[0]}' at index ${match.index}`);
    console.log("LastIndex after match:", regex.lastIndex); // 显示匹配后的 lastIndex
}

let text = "Example text with 'term' and another 'term'.";
let regex = /'term'/g; // 全局搜索 'term'

// 进行匹配
regex.exec(text);
regex.exec(text);

// 静态属性
console.log("Last Match:", RegExp.lastMatch); // 输出: 'term'
console.log("Last Paren:", RegExp.lastParen); // 输出: '', 没有捕获组
console.log("Left Context:", RegExp.leftContext); // 输出: Example text with 'term' and another 
console.log("Right Context:", RegExp.rightContext); // 输出: '.

// 匹配多次后检查静态属性
console.log("Input:", RegExp.input); // 输出: Example text with 'term' and another 'term'.