---
title: RegExp
slug: Web/JavaScript/Reference/Global_Objects/RegExp
tags:
  - Constructor
  - JavaScript
  - RegExp
  - Regular Expressions
translation_of: Web/JavaScript/Reference/Global_Objects/RegExp
original_slug: Web/JavaScript/Referencje/Obiekty/RegExp
---
<p>{{JSRef}}</p>

<h2 id="Podsumowanie" name="Podsumowanie">Podsumowanie</h2>

<p>Obiekt wyrażeń regularnych (ang. <em>regular expression</em>) zawiera wzór regularnego wyrażenia. Posiada ono właściwości i metody, które umożliwiają znalezienie lub zmianę ciągu znaków w innym ciągu znaków.</p>

<p>W dodatku do właściwości pojedynczego obiektu wyrażenia regularnego, które tworzysz używając funkcji konstruktora <code>RegExp</code>, predefiniowany obiekt <code>RegExp</code> posiada własności statyczne, które są ustawione, kiedy jakiekolwiek wyrażenie regularne jest użyte.</p>

<h2 id="Tworzony_przez" name="Tworzony_przez">Tworzony przez</h2>

<p>Odpowiednik tekstowy lub funkcja-konstruktor <code>RegExp</code>.</p>

<p>Odpowiednik tekstowy jest używany jak poniżej:</p>

<pre class="brush: js"><em>/wzór/flagi</em>
</pre>

<p>Konstruktor jest używany jak poniżej:</p>

<pre class="brush: js">new RegExp("<em>wzór</em>"[, "<em>flagi</em>"])
</pre>

<h3 id="Parametry" name="Parametry">Parametry</h3>

<dl>
 <dt><code>wzór</code></dt>
 <dd>Tekst wyrażenia regularnego.</dd>
 <dt><code>flagi</code></dt>
 <dd>Jeśli podane, flagi mogą mieć jakąkolwiek kombinację poniższych wartości: <code>g</code> - wyszukiwanie globalne, <code>i</code> - ignoruje wielkość liter, <code>m</code> - wyszukiwanie w wielu liniach.</dd>
</dl>

<p>Zauważ, że parametry w formacie tekstowym nie używają cudzysłowu do oznaczenia ciągów znaków, kiedy parametry funkcji konstruktora używają cudzysłów. Tak, więc poniższe wyrażenia tworzą to samo wyrażenie regularne:</p>

<pre class="brush: js">/ab+c/i;
new RegExp("ab+c", "i");
</pre>

<h2 id="Opis" name="Opis">Opis</h2>

<p>Podczas użycia funkcji konstruktora, standardowe znaki ucieczki (<em>string escape rule</em>, poprzedzanie znaków specjalnych <em>backslash'’ "\" kiedy użyte w ciągu znaków) są wymagane. Na przykład poniższe dwa przykłady są identyczne:</em></p>

<pre class="brush: js">re = new RegExp("\\w+");
re = /\w+/;
</pre>

<h3 id="Znaki_specjalne_w_wyra.C5.BCeniach_regularnych" name="Znaki_specjalne_w_wyra.C5.BCeniach_regularnych">Znaki specjalne w wyrażeniach regularnych</h3>

<table class="fullwidth-table">
 <tbody>
  <tr>
   <td class="header">Znak</td>
   <td class="header">Znaczenie</td>
  </tr>
  <tr>
   <td><code>\</code></td>
   <td>
    <p>Dla znaków które zwykle są traktowane dosłownie, oznacza że następny znak jest specjalny i nie ma być interpretowany standardowo.</p>

    <p>Na przykład, <code>/b/</code> szuka znaku "b". Wstawiając backslash (<code>\</code>) przed b, to jest używając <code>/\b/</code>, znak staje się specjalny "znajdź granicę wyrazu".</p>

    <p>-lub-</p>

    <p>Dla znaków, które zwykle są traktowane jako specjalne oznacza, że następny znak jest zwykły powinien być interpretowany dosłownie.</p>

    <p>Na przykład, <code>*</code> jest znakiem specjalnym oznaczającym 0 lub więcej wystąpień poprzedzającego znaku powinno być znalezionych; na przykład, <code>/a*/</code> oznacza "znajdź 0 lub więcej znaków <code>a</code>". Aby znaleźć dosłownie <code>*</code>, poprzedź ten znak backslashem (<code>\</code>), na przykład <code>/a\*/</code> znajduje "a*".</p>
   </td>
  </tr>
  <tr>
   <td><code>^</code></td>
   <td>
    <p>Znajduje początek wejścia. Jeśli flaga wielu linii (ang. <em>multiline</em>) jest ustawiona na <em>prawda</em> (<code>true</code>), znajduje również od razu po znaku nowej linii.</p>

    <p>Na przykład, <code>/^B/</code> nie znajdzie "B" w "Andrzej B" ale znajdzie "B" w "Bogusław A".</p>
   </td>
  </tr>
  <tr>
   <td><code>$</code></td>
   <td>
    <p>Oznacza koniec wejścia. Jeśli flaga wielu linii (ang. <em>multiline</em>) jest ustawiona na <em>prawda</em> (<code>true</code>), znajduje również bezpośrednio przed znakiem końca linii.</p>

    <p>Na przykład, <code>/a$/</code> nie znajdzie "a" w "mrówkojad" ale znajdzie "a" w "mrówka".</p>
   </td>
  </tr>
  <tr>
   <td><code>*</code></td>
   <td>
    <p>Znajduje poprzedzającą pozycję 0 lub więcej razy.</p>

    <p>Na przykład, <code>/bu*/</code> znajdzie "buuuu" w "Duch krzyknął buuuu" i "b" w "Głośnik zabrzmiał basowo" ale nic w "Ptak zaśpiewał".</p>
   </td>
  </tr>
  <tr>
   <td><code>+</code></td>
   <td>
    <p>Znajduje poprzedzającą pozycję 1 lub więcej razy. Równoważne do <code>{1,}</code>.</p>

    <p>Na przykład, <code>/r+/</code> dopasuje się do "r" w "cukierek" i do wszystkich "r" w "cukierrrrrrrek".</p>
   </td>
  </tr>
  <tr>
   <td><code>?</code></td>
   <td>
    <p>Znajduje poprzedzającą pozycję 0 razy lub 1 raz.</p>

    <p>Na przykład <code>/o?ąt?/</code> znajdzie "oł" w "anioł" i "ąt" w "kąt".</p>

    <p>Jeśli zostanie użyte zaraz po którymś ze znaków *, +, ?, lub {}, to wymusza przejście do trybu niezachłannego (domyślne jest dopasowanie zachłanne), czyli dopasowanie następuje do najmniejszego ciągu spełniającego wyrażenie, a nie do największego.</p>

    <p>Pytajnik używany jest także w <em>lookahead assertions</em>, opisanych pod <code>(?=)</code>, <code>(?!)</code> i <code>(?:)</code> w tej tabeli.</p>
   </td>
  </tr>
  <tr>
   <td><code>.</code></td>
   <td>
    <p>(Kropka) znajduje jakikolwiek pojedynczy znak poza znakiem nowej linii.</p>

    <p>Na przykład, <code>/.a/</code> znajdzie "ja" i "na" w "jabłko rośnie na drzewie ale arbuz nie", ale nie znajdzie "al" i "ar".</p>
   </td>
  </tr>
  <tr>
   <td><code>(x)</code></td>
   <td>
    <p>Znajduje "x" i zapamiętuje to dopasowanie. Nazywa się to "nawiasy wychwytujące" (ang. <em>capturing parentheses</em>).</p>

    <p>Na przykład, <code>/(foo)/</code> znajduje i zapamiętuje "foo" w "foo bar". Znaleziony pod-ciąg (<em>substring</em>) może być ponownie wywołany elementów tablicy wynikowej <code>1, ..., n</code> jak również z predefiniowanych własności obiektu <code>RegExp</code>, <code>$1, ..., $9</code>.</p>
   </td>
  </tr>
  <tr>
   <td><code>(?:x)</code></td>
   <td>
    <p>Znajduje "x", ale nie pamięta dopasowania. Nazywa się to "nawiasy niewychwytujące" (ang. <em>non-capturing parentheses</em>). Znaleziony podciąg (<em>substring</em>) nie może być wywołany ponownie z elementów wynikowych tablicy <code>1, ..., n</code> ani za pomocą właściwości obiektu <code>RegExp</code>, <code>$1, ..., $9</code>.</p>
   </td>
  </tr>
  <tr>
   <td><code>x(?=y)</code></td>
   <td>
    <p>Znajduje "x", tylko wtedy, gdy zaraz po "x" jest "y". Na przykład, <code>/Jacek(?=Szprotka)/</code> znajdzie "Jacek" tylko, jeśli zaraz po tym jest wyraz "Szprotka". <code>/Jacek(?=Szprotka|Mróz)/</code> znajdzie "Jacek" tylko, jeśli po tym jest zaraz wyraz "Szprotka" lub "Mróz"). Jednakże, ani "Szprotka" ani "Mróz" nie jest częścią wyników.</p>
   </td>
  </tr>
  <tr>
   <td><code>x(?!y)</code></td>
   <td>
    <p>Znajduje "x", tylko, jeśli po "x" nie ma "y". Na przykład, <code>/\d+(?!\,)/</code> zostanie dopasowane do liczby całkowitej, tylko jeśli nie ma po niej przecinka.</p>

    <p><code>/\d+(?!\,)/.exec("3,141")</code> zostanie dopasowane tylko do 141, nie zostanie dopasowane do 3, bo wystąpił po niej przecinek.</p>
   </td>
  </tr>
  <tr>
   <td><code>x|y</code></td>
   <td>
    <p>Znajduje "x" lub "y".</p>

    <p>Na przykład, <code>/zielone|czerwone/</code> znajdzie "zielone" w "zielone jabłko" i "czerwone" w "czerwone jabłko".</p>
   </td>
  </tr>
  <tr>
   <td><code>{n}</code></td>
   <td>
    <p>Gdzie <code>n</code> jest dodatnią liczbą całkowitą. Znajduje dokładnie <code>n</code> wystąpień poprzedzającej pozycji.</p>

    <p>Na przykład, <code>/u{2}/</code> nie znajdzie "u" w "cukierek", ale znajdzie wszystkie "u" w "cuukierek" i pierwsze dwa "u" w "cuuukierek".</p>
   </td>
  </tr>
  <tr>
   <td><code>{n,}</code></td>
   <td>
    <p>Gdzie <code>n</code> jest dodatnią liczbą całkowitą. Znajduje, co najmniej <code>n</code> wystąpień poprzedzającej pozycji.</p>

    <p>Na przykład, <code>/u{2,}/</code> nie znajdzie "u" w "cukierek", ale znajdzie wszystkie "u" w "cuukierek" i w "cuuukierek".</p>
   </td>
  </tr>
  <tr>
   <td><code>{n,m}</code></td>
   <td>
    <p>Gdzie <code>n</code> i <code>m</code> są pozytywnymi liczbami całkowitymi. Wyszukuje, co najmniej <code>n</code> i co najwyżej <code>m</code> wystąpień poprzedzającego wyrażenia.</p>

    <p>Na przykład, <code>/u{1,3}/</code> nie znajdzie niczego w "ckierek", znajdzie "u" w "cukierek", znajdzie dwa "u" w "cuukierek" i pierwsze trzy "u" w "cuuuuukierek". Zauważ, że podczas wyszukiwania w "cuuuuukierek", wynik wyszukiwania to "uuu" mimo iż ciąg oryginalny zawiera więcej liter "u".</p>
   </td>
  </tr>
  <tr>
   <td><code>xyz</code></td>
   <td>
    <p>Zestaw znaków. Wyszukuje jakikolwiek z podanych znaków. Możesz podać przedział znaków używając myślnika.</p>

    <p>Na przykład, <code>abcd</code> oznacza tyle samo, co <code>a-d</code>. Wyrażenia te znajdą "b" w "buziak" i "d" w "kasza".</p>
   </td>
  </tr>
  <tr>
   <td><code>^xyz</code></td>
   <td>
    <p>Przeciwny zestaw znaków. Wyszukuje cokolwiek, co nie jest wewnątrz nawiasów. Podobnie jak powyżej można podać zakres znaków używając myślnika.</p>

    <p>Na przykład, <code>^abc</code> oznacza tyle samo, co <code>^a-c</code>. Wyrażenia te znajdą "u" w "buziak" i "k" w "kasza".</p>
   </td>
  </tr>
  <tr>
   <td><code>\\b</code></td>
   <td>
    <p>Wyszukuje znak backspace (nie mylić z <code>\b</code>).</p>
   </td>
  </tr>
  <tr>
   <td><code>\b</code></td>
   <td>
    <p>Wyszukuje granicę wyrazów (ang. <em>word boundary</em>), jak na przykład spację (nie mylić z <code>\\b</code>).</p>

    <p>Na przykład, <code>/\bn\w/</code> zaznaczy "no" w "noonday"; <code>/\wy\b/</code> zaznaczy "ly" w "possibly yesterday".</p>
   </td>
  </tr>
  <tr>
   <td><code>\B</code></td>
   <td>
    <p>Znajduje brak granicy niewyrazu (ang. <em>non-word boundary</em>).</p>

    <p>Na przykład, <code>/\w\Bn/</code> zaznaczy "on" w "noonday", a <code>/y\B\w/</code> zaznaczy "ye" w "possibly yesterday".</p>
   </td>
  </tr>
  <tr>
   <td><code>\cX</code></td>
   <td>
    <p>Gdzie <code>X</code> jest literą od A do Z. Zaznacza znak kontrolny w ciągu.</p>

    <p>Na przykład, <code>/\cM/</code> zaznaczy <code>control-M</code> w <em>string</em>u.</p>
   </td>
  </tr>
  <tr>
   <td><code>\d</code></td>
   <td>
    <p>Znajduje cyfrę. Odpowiednik <code>0-9</code>.</p>

    <p>Na przykład, <code>/\d/</code> lub <code>/0-9/&lt;code&gt; zaznaczy "2" w "B2 jest numerem pokoju". &lt;/td&gt; &lt;/tr&gt; </code></p>
   </td>
  </tr>
  <tr>
   <td>\D</td>
   <td>
    <p>Wyszukuje jakikolwiek znak nieliczbowy. Odpowiednik <code>^0-9') }}</code>.</p>

    <p>Na przykład, <code>/\D/</code> lub <code>/^0-9/</code> zaznaczy "B" w "B2 jest numerem pokoju".</p>
   </td>
  </tr>
  <tr>
   <td><code>\f</code></td>
   <td>
    <p>Znajduje znak wysuwu wiersza (<em>form feed</em>).</p>
   </td>
  </tr>
  <tr>
   <td><code>\n</code></td>
   <td>
    <p>Znajduje znak następnego wiersza (<em>line feed</em>).</p>
   </td>
  </tr>
  <tr>
   <td><code>\r</code></td>
   <td>
    <p>Znajduje znak powrotu karetki (<em>carriage return</em>).</p>
   </td>
  </tr>
  <tr>
   <td><code>\s</code></td>
   <td>
    <p>Znajduje pojedynczy biały znak (ang. <em>white space character</em>), wliczając w to spację, tabulator, znak wysuwu wiersza, znak następnego wiersza. Odpowiednik <code>\\f\\n\\r\\t\\u00A0\\u2028\\u2029</code>.</p>

    <p>Na przykład, <code>/\s\w*/</code> zaznaczy " bar" w "foo bar".</p>
   </td>
  </tr>
  <tr>
   <td><code>\S</code></td>
   <td>
    <p>Zaznacza jakikolwiek znak inny niż biały (ang. <em>white space</em>). Odpowiednik <code>^ \\f\\n\\r\\t\\u00A0\\u2028\\u2029</code>.</p>

    <p>Na przykład, <code>/\S/\w*</code> zaznaczy "foo" w "foo bar".</p>
   </td>
  </tr>
  <tr>
   <td><code>\t</code></td>
   <td>
    <p>Znajduje tabulator.</p>
   </td>
  </tr>
  <tr>
   <td><code>\v</code></td>
   <td>
    <p>Znajduje pionowy tabulator (ang. <em>vertical tab</em>).</p>
   </td>
  </tr>
  <tr>
   <td><code>\w</code></td>
   <td>
    <p>Znajduje jakikolwiek znak alfanumeryczny i znak podkreślenia <code>_</code>. Odpowiednik <code>A-Za-z0-9_</code>.</p>

    <p>Na przykład, <code>/\w/</code> zaznaczy "j" w "jabłko", "5" w "??5.28", i "3" w "3D".</p>
   </td>
  </tr>
  <tr>
   <td><code>\W</code></td>
   <td>
    <p>Zaznaczy jakikolwiek znak niewyrazowy. Odpowiednik <code>^A-Za-z0-9_</code>.</p>

    <p>Na przykład, <code>/\W/</code> lub <code>/^$A-Za-z0-9_/</code> znajdzie "%" w "50%".</p>
   </td>
  </tr>
  <tr>
   <td><code>\n</code></td>
   <td>
    <p>Gdzie <code>n</code> jest pozytywną liczbą całkowitą. Odwołanie wsteczne (ang. <em>back reference</em>) do ostatniego podciągu (<em>substring</em>) pasującego do n wyrażenia umieszczonego w nawiasie (licząc od nawiasu otwierającego "(").</p>

    <p>Na przykład, <code>/jabłko(,)\spomarańcz\1/</code> pasuje do "jabłko, pomarańcz," w "jabłko, pomarańcz, wiśnia, brzoskwinia". Dokładniejszy przykład znajduje się po tabeli.</p>
   </td>
  </tr>
  <tr>
   <td><code>\0</code></td>
   <td>
    <p>Wyszukuje znak NUL. Bezpośrednio po <code>\0</code> nie powinna znajdować się żadna liczba.</p>
   </td>
  </tr>
  <tr>
   <td><code>\xhh</code></td>
   <td>
    <p>Znajduje znak o kodzie hh (dwie cyfry szesnastkowe)</p>
   </td>
  </tr>
  <tr>
   <td><code>\uhhhh</code></td>
   <td>
    <p>Znajduje znak o kodzie hhhh (cztery cyfry szesnastkowe).</p>
   </td>
  </tr>
 </tbody>
</table>

<p>Notacja tekstowa zostaje skompilowana, kiedy wyrażenie regularne jest wykonane. Używaj notacji tekstowej wtedy, kiedy wyrażenie regularne pozostanie niezmienione. Na przykład, jeśli użyjesz notacji tekstowej do konstrukcji wyrażenia regularnego w pętli, wyrażenie to nie zostanie przekompilowane podczas każdej iteracji.</p>

<p>Konstruktor obiektu wyrażenia regularnego, na przykład <code>new RegExp("ab+c")</code>, pozwala na kompilację podczas czasu wykonywania (ang. <em>runtime compilation</em>) wyrażenia. Używaj funkcji konstruktora, kiedy wiesz, że wzór wyrażenia regularnego będzie się zmieniać lub gdy nie znasz tego wzoru i pobierasz go z innego źródła, jak na przykład wejście użytkownika.</p>

<p>Oddzielny predefiniowany obiekt <code>RegExp</code> jest dostępny dla każdego okna, to jest każdy oddzielny wątek uruchomienia JavaScriptu dostaje jego własny obiekt <code>RegExp</code>. Jako że każdy skrypt uruchamiany jest cały w oddzielnym wątku, zapewnia to, iż oddzielne skrypty nie nadpisują wartości obiektu <code>RegExp</code>.</p>

<h2 id="W.C5.82asno.C5.9Bci" name="W.C5.82asno.C5.9Bci">Własności</h2>

<dl>
 <dt>{{jsxref("RegExp.prototype")}}</dt>
 <dd>Pozwala na dodanie własności wszystkim obiektom.</dd>
 <dt><code>RegExp.length</code></dt>
 <dd>Wartość parametru <code>RegExp.length</code> wynosi 2.</dd>
 <dt>{{jsxref("RegExp.lastIndex")}}</dt>
 <dd>Indeks, od którego rozpoczynać następne szukanie.</dd>
</dl>

<h2 id="Metody" name="Metody">Metody</h2>

<p>Globalny objekt <code>RegExp</code> nie posiada własnych metod, jednam może dziedziczyć metody z innych obiektów.</p>

<h2 id="Przyk.C5.82ady" name="Przyk.C5.82ady">Przykłady</h2>

<h3 id="Przyk.C5.82ad:_Zastosowanie_metody_replace" name="Przyk.C5.82ad:_Zastosowanie_metody_replace">Przykład: Zastosowanie metody <code>replace</code></h3>

<p>Poniższy przykład używa metodę <code>replace</code> do zamiany wyrazów w ciągu (<em>stringu</em>). Podczas zamiany tekstu, skrypt używa "<code>$1</code>" i "<code>$2</code>" do oznaczenia wyników odpowiadających im nawiasów we wzorze wyrażenia regularnego.</p>

<pre class="brush: js">var re = /(\w+)\s(\w+)/;
var str = "Jan Kowalski";
var newstr = str.replace(re, "$2, $1");
document.write(newstr);
</pre>

<p>Wyświetli "Kowalski, Jan".</p>

<h2 id="Zobacz_tak.C5.BCe" name="Zobacz_tak.C5.BCe">Zobacz także</h2>

<ul>
 <li>Rozdział w <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide">JavaScript Guide</a> o <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Regular Expressions</a></li>
 <li>{{jsxref("String.prototype.match()")}}</li>
</ul>