• 
  Konstruktor wyrażenia regularnego - constructor

  Gdzie jest zapisany konstruktor obiektu wyrażenia regularnego?

• 
  Dopasowanie wzorca - exec

  Jak pobrać wszystkie dopasowania wzorca (wyrażenia regularnego) do podanego tekstu?

• 
  Sprawdzanie dopasowania - test

  Jak sprawdzić, czy tekst pasuje do wzorca (wyrażenia regularnego)

• 
  Konwersja na tekst - toString

  Jak przekształcić wyrażenie regularne na prosty tekst?

RegExp.prototype.constructor

Wartość:

Function - konstruktor obiektu

Zawiera konstruktor wbudowanego obiektu wyrażenia regularnego RegExp.

Przykład RegExp.prototype.constructor

RegExp.prototype.constructor === RegExp; // true
new RegExp().constructor === RegExp;     // true
RegExp.prototype.constructor === Object; // false

RegExp.prototype.exec(string)

Parametry:

String string - dopasowywany tekst

Wartość:

Array - tablica dopasowań z dodatkowymi właściwościami:

• Number index - pozycja w tekście (licząc od zera), gdzie został dopasowany wzorzec
• String input - wartość argumentu string

Null - tekst nie został dopasowany do wyrażenia regularnego

Próbuje dopasować tekst do podanego wzorca - wyrażenia regularnego. Jeżeli się to uda, zwraca pierwszy dopasowany fragment tekstu oraz każdą jego część, która w wyrażeniu była zapisana w nawiasie. W przypadku dopasowania globalnego - kiedy wyrażenie regularne posiada flagę g - dodatkowo do własności lastIndex przypisywana jest pozycja w tekście (licząc od zera) po ostatnim znaku dopasowanego fragmentu. To zachowanie można wykorzystać do wyszukiwania w pętli wszystkich dopasowań wzorca, które znajdują się w podanym tekście.

Jeżeli chcesz tylko sprawdzić, czy określony tekst pasuje do wzorca, użyj funkcji RegExp.prototype.test.

Przykład RegExp.prototype.exec

var y = /abc/.exec("ABCd efg abc");         // ["abc"]
y.index;                                    // 9
y.input;                                    // "ABCd efg abc"
y = /(ab)c/.exec("ABCd efg abc");           // ["abc", "ab"]
y.index;                                    // 9
 
y = /abc/i.exec("ABCd efg abc");            // ["ABC"]
y.index;                                    // 0
y = /(ab)c/i.exec("ABCd efg abc");          // ["ABC", "AB"]
y.index;                                    // 0
 
var x = /abc/g;
y = x.exec("abcd efg abc");                 // ["abc"]
x.lastIndex;                                // 3
y.index;                                    // 0
x = /(ab)c/g;
y = x.exec("abcd efg abc");                 // ["abc", "ab"]
x.lastIndex;                                // 3
y.index;                                    // 0
 
x = /abc/ig;
y = x.exec("ABCd efg abc");                 // ["ABC"]
x.lastIndex;                                // 3
y.index;                                    // 0
x = /(ab)c/ig;
y = x.exec("ABCd efg abc");                 // ["ABC", "AB"]
x.lastIndex;                                // 3
y.index;                                    // 0
 
// Wyszukanie wszystkich dopasowań:
x = /(ab)c/ig;
while (y = x.exec("ABCd efg abc")) y.index; // 0, 9
 
/hij/.exec("abcd efg abc");                 // null
/ABC/.exec("abcd efg abc");                 // null
/(AB)C/.exec("abcd efg abc");               // null
/hij/g.exec("abcd efg abc");                // null
/ABC/g.exec("abcd efg abc");                // null
/(AB)C/g.exec("abcd efg abc");              // null

RegExp.prototype.test(string)

Parametry:

String string - dopasowywany tekst

Wartość:

Boolean - czy tekst pasuje do wzorca

Przeszukuje tekst pod kątem występowania w nim podanego wzorca. W przypadku dopasowania globalnego - kiedy wyrażenie regularne posiada flagę g - dodatkowo do własności lastIndex przypisywana jest pozycja w tekście (licząc od zera) po ostatnim znaku dopasowanego fragmentu. To zachowanie można wykorzystać do wyszukiwania w pętli wszystkich dopasowań wzorca, które znajdują się w podanym tekście.

Przykład RegExp.prototype.test

/a[a-z]/.test("abc def abc");               // true
/abc?/.test("abc def abc");                 // true
/ABC?/i.test("abc def abc");                // true
 
// Wyszukanie wszystkich dopasowań:
var x = /(ab)c/ig, y;
while (y = x.exec("ABCd efg abc")) y.index; // 0, 9
 
/ghi?/.test("abc def abc");                 // false
/ABC?/.test("abc def abc");                 // false

RegExp.prototype.toString()

Wartość:

String - reprezentacja tekstowa wyrażenia regularnego

Zwraca literał wyrażenia regularnego zapisany w postaci prostego tekstu. Jest to połączenie tekstu "/", wartości właściwości source, ponownie tekstu "/" oraz flag wyrażenia w kolejności: "gim".

Przykład RegExp.prototype.toString

/(ab)c/ig.toString();                      // "/(ab)c/gi"
new RegExp("a/b\\(c\\)d\\\\e").toString(); // "/a\/b\(c\)d\\e/"