一般原子的語法如下：

字元類別的語法如下：

下列建構都是字元規格

為了示範使用字元類別，這個範例會剖析以 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 存取群組（透過 arguments[1] 存取群組 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
}