一般原子的语法如下：

字符类的语法如下：

以下结构都是字符规范

为了演示如何使用字符类，本例解析了以 ISO 8601 标准格式化的日期

function parseIsoDate(str) {
    var match = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(str);

    // Other ways of writing the regular expression:
    // /^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$/
    // /^(\d\d\d\d)-(\d\d)-(\d\d)$/

    if (!match) {
        throw new Error('Not an ISO date: '+str);
    }
    console.log('Year: '  + match[1]);
    console.log('Month: ' + match[2]);
    console.log('Day: '   + match[3]);
}

以下是交互

> parseIsoDate('2001-12-24')
Year: 2001
Month: 12
Day: 24

组的语法如下：

\1、\2 等被称为反向引用；它们指的是先前匹配的组。反斜杠后的数字可以是任何大于或等于 1 的整数，但第一个数字不能是 0。

在本例中，反向引用保证了破折号前后相同数量的 a

> /^(a+)-\1$/.test('a-a')
true
> /^(a+)-\1$/.test('aaa-aaa')
true
> /^(a+)-\1$/.test('aa-a')
false

本例使用反向引用来匹配 HTML 标记（显然，您通常应该使用适当的解析器来处理 HTML）

> var tagName = /<([^>]+)>[^<]*<\/\1>/;
> tagName.exec('<b>bold</b>')[1]
'b'
> tagName.exec('<strong>text</strong>')[1]
'strong'
> tagName.exec('<strong>text</stron>')
null

任何原子（包括字符类和组）后面都可以跟一个量词：

默认情况下，量词是贪婪的；也就是说，它们会尽可能多地匹配。您可以通过在任何前面的量词（包括花括号中的范围）后面加上一个问号 (?) 来获得惰性匹配（尽可能少地匹配）。例如：

> '<a> <strong>'.match(/^<(.*)>/)[1]  // greedy
'a> <strong'
> '<a> <strong>'.match(/^<(.*?)>/)[1]  // reluctant
'a'

因此，.*? 是一个有用的模式，用于匹配所有内容，直到下一个原子出现为止。例如，以下是刚才显示的 HTML 标记正则表达式的更紧凑版本（它使用 [^<]* 而不是 .*?）

/<(.+?)>.*?<\/\1>/

断言（如下表所示）是对输入中当前位置的检查：

本例通过 \b 匹配单词边界

> /\bell\b/.test('hello')
false
> /\bell\b/.test('ello')
false
> /\bell\b/.test('ell')
true

本例通过 \B 匹配单词内部

> /\Bell\B/.test('ell')
false
> /\Bell\B/.test('hell')
false
> /\Bell\B/.test('hello')
true

析取运算符 (|) 分隔两个备选项；两个备选项中的任何一个都必须匹配，析取才能匹配。备选项是原子（可以选择包含量词）。

该运算符的绑定非常弱，因此您必须小心，不要让备选项扩展得太远。例如，以下正则表达式匹配以 aa 开头或以 bb 结尾的所有字符串

> /^aa|bb$/.test('aaxx')
true
> /^aa|bb$/.test('xxbb')
true

换句话说，析取的绑定比 ^ 和 $ 还要弱，两个备选项是 ^aa 和 bb$。如果要匹配两个字符串 'aa' 和 'bb'，则需要使用括号

/^(aa|bb)$/

同样，如果要匹配字符串 'aab' 和 'abb'

/^a(a|b)b$/

创建正则表达式有两种方法：可以使用字面量或构造函数 RegExp：

字面量和构造函数在编译时间上有所不同

因此，您通常应该使用字面量，但如果要动态组装正则表达式，则需要使用构造函数。

标志是正则表达式字面量的后缀和正则表达式构造函数的参数；它们修改正则表达式的匹配行为。存在以下标志：

简称用于字面量前缀和构造函数参数（请参阅下一节中的示例）。全称用于正则表达式的属性，这些属性指示在创建过程中设置了哪些标志。

正则表达式具有以下实例属性：

以下是访问标志实例属性的示例

> var regex = /abc/i;
> regex.ignoreCase
true
> regex.multiline
false

在本例中，我们首先使用字面量创建相同的正则表达式，然后使用构造函数创建，并使用 test() 方法确定它是否与字符串匹配：

> /abc/.test('ABC')
false
> new RegExp('abc').test('ABC')
false

在本例中，我们创建一个忽略大小写的正则表达式（标志 /i）

> /abc/i.test('ABC')
true
> new RegExp('abc', 'i').test('ABC')
true

如果未设置标志 /g，则仅返回第一个匹配项

> var regex = /a(b+)/;
> regex.exec('_abbb_ab_')
[ 'abbb',
  'bbb',
  index: 1,
  input: '_abbb_ab_' ]
> regex.lastIndex
0

如果设置了标志 /g，则重复调用 exec() 会返回所有匹配项。返回值 null 表示没有更多匹配项。属性 lastIndex 指示下次匹配将从哪里继续

> var regex = /a(b+)/g;
> var str = '_abbb_ab_';

> regex.exec(str)
[ 'abbb',
  'bbb',
  index: 1,
  input: '_abbb_ab_' ]
> regex.lastIndex
6

> regex.exec(str)
[ 'ab',
  'b',
  index: 7,
  input: '_abbb_ab_' ]
> regex.lastIndex
10

> regex.exec(str)
null

这里我们循环遍历匹配项

var regex = /a(b+)/g;
var str = '_abbb_ab_';
var match;
while (match = regex.exec(str)) {
    console.log(match[1]);
}

我们得到以下输出

bbb
b

如果 replacement 是字符串，则其内容将按字面用于替换匹配项。唯一的例外是特殊字符美元符号 ($)，它启动了所谓的 替换指令：

此示例引用匹配的子字符串及其前缀和后缀

> 'axb cxd'.replace(/x/g, "[$`,$&,$']")
'a[a,x,b cxd]b c[axb c,x,d]d'

此示例引用一个组

> '"foo" and "bar"'.replace(/"(.*?)"/g, '#$1#')
'#foo# and #bar#'

如果 replacement 是函数，则它计算要替换匹配项的字符串。此函数具有 以下签名：

function (completeMatch, group_1, ..., group_n, offset, inputStr)

completeMatch 与之前的 $& 相同，offset 指示找到匹配项的位置，inputStr 是要匹配的内容。因此，您可以使用特殊变量 arguments 来访问组（组 1 通过 arguments[1] 访问，依此类推）。例如

> function replaceFunc(match) { return 2 * match }
> '3 apples and 5 oranges'.replace(/[0-9]+/g, replaceFunc)
'6 apples and 10 oranges'

有时，当您 手动组合正则表达式时，您希望按字面使用给定的字符串。 这意味着所有特殊字符（例如，*、[）都不应被解释为特殊字符，所有字符都需要转义。JavaScript 没有用于这种引用的内置方法，但您可以编写自己的函数 quoteText，该函数的工作方式如下：：

> console.log(quoteText('*All* (most?) aspects.'))
\*All\* \(most\?\) aspects\.

如果您需要对多个匹配项进行搜索和替换，则此类函数特别方便。然后，要搜索的值必须是设置了 global 标志的正则表达式。使用 quoteText()，您可以使用任意字符串。该函数如下所示

function quoteText(text) {
    return text.replace(/[\\^$.*+?()[\]{}|=!<>:-]/g, '\\$&');
}

所有特殊字符都会被转义，因为您可能希望在括号或方括号内引用多个字符。

如果您不使用 断言（例如 ^ 和 $），则大多数正则表达式方法都会在任何地方找到模式。例如：

> /aa/.test('xaay')
true
> /^aa$/.test('xaay')
false

这是一种罕见的用例，但有时您需要一个匹配所有内容或不匹配任何内容的正则表达式。例如，一个函数可能有一个带有用于过滤的正则表达式的参数。如果缺少该参数，则为其指定一个默认值，即匹配所有内容的正则表达式。

> new RegExp('').test('dfadsfdsa')
true
> new RegExp('').test('')
true

> new RegExp('')
/(?:)/

> var never = /.^/;
> never.test('abc')
false
> never.test('')
false

后向断言是一种 断言。 与前向断言类似，模式用于检查输入中当前位置的某些内容，但在其他情况下会被忽略。与前向断言相反，模式的匹配必须在当前位置 结束（而不是从当前位置开始）。

以下函数将字符串 'NAME' 的每次出现替换为参数 name 的值，但前提是该出现前面没有引号。我们通过“手动”检查当前匹配项之前的字符来处理引号

function insertName(str, name) {
    return str.replace(
        /NAME/g,
        function (completeMatch, offset) {
            if (offset === 0 ||
                (offset > 0 && str[offset-1] !== '"')) {
                return name;
            } else {
                return completeMatch;
            }
        }
    );
}

> insertName('NAME "NAME"', 'Jane')
'Jane "NAME"'
> insertName('"NAME" NAME', 'Jane')
'"NAME" Jane'

另一种方法是在正则表达式中包含可能转义的字符。然后，您必须临时将前缀添加到要搜索的字符串中；否则，您将错过该字符串开头的匹配项

function insertName(str, name) {
    var tmpPrefix = ' ';
    str = tmpPrefix + str;
    str = str.replace(
        /([^"])NAME/g,
        function (completeMatch, prefix) {
            return prefix + name;
        }
    );
    return str.slice(tmpPrefix.length); // remove tmpPrefix
}