path: root/files/uk/web/javascript/guide/regular_expressions/index.html

---
title: Регулярні Вирази
slug: Web/JavaScript/Guide/Regular_Expressions
translation_of: Web/JavaScript/Guide/Regular_Expressions
---
<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Text_formatting", "Web/JavaScript/Guide/Indexed_collections")}}</div>

<p class="summary"><strong>Регулярні вирази</strong> це шаблони, що використовуються для пошуку збігу,співпадіння в тексті чи строках. В JavaScript регулярні вирази також є обʼєктами. Ці шаблони використовуются для пошуку збігу у тексті. Пропоную розібратись з  регулярними виразами JavaScript детальніше.</p>

<h2 id="Створення_регулярних_виразів">Створення регулярних виразів</h2>

<p>Ви можете створювати регулярні вирази двома способами:</p>

<p>Використовуючи літерал регулярного виразу, який складається з шаблону між символами "/" слеш:</p>

<pre class="brush: js notranslate">var re = /ab+c/;
</pre>

<p>Цей спосіб підійде для статичних, простих виразів, використовуйте його для покращення продуктивності.</p>

<p>Або через створення обʼєкта {{jsxref("RegExp")}}:</p>

<pre class="brush: js notranslate">var re = new RegExp("ab+c");
</pre>

<p>В такому випадку створюєтся об'єкт з методами {{jsxref("RegExp.exec", "exec")}} та {{jsxref("RegExp.test", "test")}} класу {{jsxref("RegExp")}}, та методами з {{jsxref("String")}} классу, а саме {{jsxref("String.match", "match")}}, {{jsxref("String.replace", "replace")}}, {{jsxref("String.search", "search")}}, та {{jsxref("String.split", "split")}}. </p>

<p>Використовуйте цей спосіб у випадках, коли вам відомо, що шаблон регулярного виразу буде змінюватись. Наприклад для очікування дій користувача з подальшим виконанням якоїсь функції тощо, або для побудови URL маршутів.</p>

<h2 id="Створення_шаблону_регулярного_виразу">Створення шаблону регулярного виразу</h2>

<p>Шаблон регулярного виразу складається зі звичайних символів, наприклад <code>/abc/</code>, або комбінації звичайних та спеціальних символів – <code>/ab*c/</code> або <code>/Chapter (\d+)\.\d*/</code>. Останій приклад містить дужки, які використовуються як запамʼятовуючий пристрiй. Збіг з цією частиною шаблону запамʼятовується для подальшого використання, більш докладно про це в розділі {{ web.link("#Using_parenthesized_substring_matches", "Використання збігів підрядків у дужках") }}.</p>

<h3 id="Використання_простих_шаблонів">Використання простих шаблонів</h3>

<p>Прості шаблони складаються з символів, для яких потрібно знайти прямий збіг. Наприклад, шаблон <code>/abc/</code> збігається з комбінацією символів в рядку тільки у випадку, коли символи 'abc' опиняються поруч саме в такому порядку. Збіг буде успішним у рядках типу "Hi, do you know your abc's?" та "The latest airplane designs evolved from sl<strong>abc</strong>raft." В обох випадках шаблон збігається з підрядком 'abc'. В рядку 'Grab crab' збігу не буде, так як він містить підрядок 'abc', що не збігається точно з послідовністю 'abc'.</p>

<h3 id="Використання_спеціальних_символів">Використання спеціальних символів</h3>

<p>Коли пошук збігу вимагає чогось більшого ніж прямий збіг, наприклад пошук одного чи більше символу 'b', або пошуку пробілів, шаблон включає спеціальні символи. Так, шаблон <code>/ab*c/</code> збігається з будь-якою символьною комбінацією, де за символом 'a' може бути багато повторів символу 'b' (<code>*</code> значить 0 чи більше випадків) за яким відразу йде символ 'c'. В рядку "cbb<strong>abbbbc</strong>debc," шаблон збігається з підрядком '<strong>abbbbc</strong>'.</p>

<p>Наступна таблиця містить повний перелік та опис спеціальних символів, які використовуються в регулярних виразах.</p>

<table class="standard-table">
 <caption>Спеціальні символи, що використовуються в регулярних виразах.</caption>
 <thead>
  <tr>
   <th scope="col">Символ</th>
   <th scope="col">Значення</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><a href="#special-backslash" id="special-backslash" name="special-backslash"><code>\</code></a></td>
   <td>
    <p>Відповідає одному з наступних правил:<br>
     <br>
     Зворотній слеш означає що наступний символ є спеціальним та не сприймається буквально. Наприклад, '<strong><code>b</code></strong>' без передуючого '\' збігається з літерою '<strong>b</strong>' у нижньому регістрі. Але вираз '<strong><code>\b</code></strong>' не відповідає жодному збігу; він утворює спеціальний символ, що збігається з <a href="#special-word-boundary" title="#special-word-boundary">межею слова</a>.<br>
     <br>
     Так, шаблон <strong><code>/a*/</code></strong> покладається на спецсимвол '<strong><code>*</code></strong>', щоб знайти збіг з 0 чи більше символів '<strong>a</strong>'. На відміну від цього, щаблон <strong><code>/a\*/</code></strong> усуває сприйняття '<strong><code>*</code></strong>', як спецсимвол, та дозволяє отримати збіг '<strong>a*</strong>'.<br>
     <br>
     Не забувайте екранувати символ '<strong>\</strong>' подвійним ' '\\' використовуючи його в нотації RegExp("pattern"), так як '<strong>\</strong>' є екрануючим символом в рядках.</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-caret" id="special-caret" name="special-caret"><code>^</code></a></td>
   <td>Шукати збіг окрім перед символом переносу рядка чи кінця строки.<br>
    <br>
    Наприклад, <strong><code>/^A/</code></strong> не має збігу з "an A", але має збіг в рядку "<strong>A</strong>n E".<br>
    <br>
    Символ '<strong><code>^</code></strong>' має також і інші значення, коли він вказуєтся на початку шаблону регулярного виразу. Ознайомтесь з розділом <a href="#special-negated-character-set" title="#special-negated-character-set">доповнений набір символів</a> для отримання деталей та прикладів.</td>
  </tr>
  <tr>
   <td><a href="#special-dollar" id="special-dollar" name="special-dollar"><code>$</code></a></td>
   <td>
    <p>Вказує що на забігу має завершитись строка. </p>

    <p>Наприклад, <strong><code>/t$/</code></strong> не збігається з '<strong>t</strong>' в "eater", але має збіг в "ea<strong>t</strong>".</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-asterisk" id="special-asterisk" name="special-asterisk"><code>*</code></a></td>
   <td>
    <p>Збіг повторюється 0 чи більше разів. Еквівалент <code>{0,}</code>.</p>

    <p>Наприклад, <strong><code>/bo*/</code></strong> збігається з '<strong>boooo</strong>' в "A ghost <strong>boooo</strong>ed" та з '<strong>b</strong>' in "A <strong>b</strong>ird warbled", але не має збігу в "A goat grunted".</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-plus" id="special-plus" name="special-plus"><code>+</code></a></td>
   <td>
    <p>Відповідає попередньому символу, що повторюється щонайменше 1 чи більше разів. Еквівалент <code>{1,}</code>.</p>

    <p>Наприклад, <strong><code>/a+/</code></strong> збігається з '<strong>a</strong>' в "c<strong>a</strong>ndy" та з усіма '<strong>a</strong>' в "c<strong>aaaaaaa</strong>ndy", але не має збігів у "cndy".</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-questionmark" id="special-questionmark" name="special-questionmark"><code>?</code></a></td>
   <td>Пошук збігу 0 чи 1 раз. Еквівалент <code>{0,1}</code>.<br>
    <br>
    Наприклад, <code>/e?le?/</code> відповідає '<strong>el</strong>' в "ang<strong>el</strong>" та '<strong>le</strong>' в "ang<strong>le</strong>", а також '<strong>l</strong>' в "os<strong>l</strong>o".<br>
    <br>
    Якщо вказуєтся одразу після специмволів *, +, ?, або {}, робить їх більш суворими (збіг з найменш можливою кількістю символів), на відміну від типових результатів, на відміну від несуворих пошуків (збіг з максимально можливою кількістю символів). Наприклад, застосування <strong><code>/\d+/</code></strong> (пошук повторення десятичної цифри багато разів) до "<strong>123</strong>abc" знайде "<strong>123</strong>". Але застосування <strong><code>/\d+?/</code></strong> зробить його суворим і результом збігу буде перша цифра "<strong>1</strong>".<br>
     </td>
  </tr>
  <tr>
   <td><a href="#special-dot" id="special-dot" name="special-dot"><code>.</code></a></td>
   <td>
    <p>(дрібна крапка) вказує пошук будь-якого одного символу, окрім початку строки.</p>

    <p>Наприклад, <strong><code>/.n/</code></strong> відповідає '<strong>an</strong>' та '<strong>on</strong>' в рядку "nay, <strong>an</strong> apple is <strong>on</strong> the tree", але не знайде збігів у  'nay'.</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-capturing-parentheses" id="special-capturing-parentheses" name="special-capturing-parentheses"><code>(x)</code></a></td>
   <td>
    <p>Пошук 'x' і запам'ятати збіг. Ці дужки також називають <em>захоплюючи дужки</em>.<br>
     <br>
     '<strong><code>(foo)</code></strong>' та '<strong><code>(bar)</code></strong>' в шаблоні <strong><code>/(foo) (bar) \1 \2/</code></strong> збігаються з першими двома словами в рядку "<strong>foo bar</strong> foo bar" та запамʼятовують їх.  А <code><strong>\1</strong></code> та <strong><code>\2</code></strong> в шаблоні відповідають двом останім словам. Зауважте, що <code><strong>\1</strong>, <strong>\2</strong>, <strong>\n</strong></code> використовуються в порівняльній частині регулярного виразу. В зміній частині регулярного виразу потрібно використовувати синтакс <code><strong>$1</strong>, <strong>$2</strong>, <strong>$n</strong></code>: <code>'bar foo'.replace( /(...) (...)/, '$2 $1' )</code>.</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-non-capturing-parentheses" id="special-non-capturing-parentheses" name="special-non-capturing-parentheses"><code>(?:x)</code></a></td>
   <td>Відповідає 'x', але не запамʼятовує збіг. Такий випадок називається <em>незахоплючими дужками</em>, і дозволяє вам визначати під-вирази для роботи з операторами ругулярних виразів. Розглянемо приклад <strong><code>/(?:foo){1,2}/</code></strong>. Якщо б шаблон був <strong><code>/foo{1,2}/</code></strong>, символи <code>{1,2}</code> застосовувались би тільки до останього символу '<strong>o</strong>' в 'fo<strong>o</strong>'. В незахоплюючих дужках <code>{1,2}</code> застосовується до всього слова 'foo'.</td>
  </tr>
  <tr>
   <td><a href="#special-lookahead" id="special-lookahead" name="special-lookahead"><code>x(?=y)</code></a></td>
   <td>
    <p>Відповідає 'x' тільки якщо за 'x' йде 'y'. Це називається випередження.</p>

    <p>Наприклад, <code>/Jack(?=Sprat)/</code> збігатиметься з 'Jack' тількя якщо за ним йде 'Sprat'. <code>/Jack(?=Sprat|Frost)/</code> збігається з 'Jack' тільки якщо за ним йде 'Sprat' або 'Frost'. Проте, а ні 'Sprat', а ні 'Frost' не є частиною результату збігу.</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-negated-look-ahead" id="special-negated-look-ahead" name="special-negated-look-ahead"><code>x(?!y)</code></a></td>
   <td>
    <p>Відповідає 'x' тільки якщо за 'x' не йде 'y'. Це називається відʼємним випередженням.</p>

    <p>Наприклад, <strong><code>/\d+(?!\.)/</code></strong> матиме збіг з числом тільки якщо за ним відсутня десяткова точка. Регулярний вираз <code><strong>/\d+(?!\.)/</strong>.exec("3.<strong>141</strong>")</code> матиме збіг з '<strong>141</strong>', але не з '3.141'.</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-or" id="special-or" name="special-or"><code>x|y</code></a></td>
   <td>
    <p>Відповідає 'x' або 'y'.</p>

    <p>Наприклад, <strong><code>/green|red/</code></strong> збігається з '<strong>green</strong>' в "<strong>green</strong> apple" та з '<strong>red</strong>' в "<strong>red</strong> apple."</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-quantifier" id="special-quantifier" name="special-quantifier"><code>{n}</code></a></td>
   <td>Відповідає точній кількості n повторень попереднього виразу. N повино бути додатним цілим числом.<br>
    <br>
    Наприклад, <code>/a{2}/</code> не матиме збігів для 'a' в "candy," але збігатиметься з усіма <strong>a</strong> в "c<strong>aa</strong>ndy," та двом першим <strong>a</strong> в "c<strong>aa</strong>andy."</td>
  </tr>
  <tr>
   <td><a href="#special-quantifier-range" id="special-quantifier-range" name="special-quantifier-range"><code>{n,m}</code></a></td>
   <td>
    <p>Де <code>n</code> та <code>m</code> – додатні цілі числа та <code>n &lt;= m</code>. Відповідає що найменше <code>n</code> та до <code>m</code> включно повторень передуючого виразу. Якщо <code>m</code> немає, вважається що <code>m = ∞</code>.</p>

    <p>Наприклад, <code>/a{1,3}/</code> не збігається з рядком "cndy", відповідає '<strong>a</strong>' в "c<strong>a</strong>ndy," та першим двом <strong>a</strong> в "c<strong>aa</strong>ndy," а також першим трьом <strong>a</strong> в "c<strong>aaa</strong>aaaandy". Зауважте що під час порівняння "c<strong>aaa</strong>aaaandy", відповідає лише "<strong>aaa</strong>", навіть якщо оригінальний рядок містить довший рядок з <strong>a</strong>.</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-character-set" id="special-character-set" name="special-character-set"><code>[xyz]</code></a></td>
   <td>Набір символів. Відповідає збігу з будь-яким із символів шаблону, включаючи <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Values,_variables,_and_literals#Unicode_escape_sequences" title="https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Values,_variables,_and_literals#Unicode_escape_sequences">керуючі послідовності</a>. Спеціальні символи такі як точка (<code>.</code>) та зірочка (<code>*</code>) не є спецсимволами в середині набору символів та не потребують екранування. Ви можете задавати послідовності використовуючи дефіс, як в наступному прикладі.<br>
    <br>
    Шаблон<code> [a-d]</code>, що представляє теж саме що й <code>[abcd]</code>, збігається з '<strong>b</strong>' в "<strong>b</strong>risket" та з '<strong>c</strong>' в "<strong>c</strong>ity". Шаблони <code><strong>/[a-z.]+/</strong> та</code> <strong><code>/[\w.]+/</code></strong> збігаються зі всім рядком "test.i.ng".</td>
  </tr>
  <tr>
   <td><a href="#special-negated-character-set" id="special-negated-character-set" name="special-negated-character-set"><code>[^xyz]</code></a></td>
   <td>
    <p>Відʼємний або компліментарний набір змін. Цей вираз відповідає збігу з будь-чим що не міститься в квадратних дужках. Ви можете зазначити діапазон використовуючи дефіс. Все що працює зі звичайним набором символів спрацює і в цьому випадку.</p>

    <p>Наприклад, <code>[^abc]</code> теж саме що й <code>[^a-c]</code>. Вони відповідають збігу 'r' в "brisket" та 'h' в "chop."</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-backspace" id="special-backspace" name="special-backspace"><code>[\b]</code></a></td>
   <td>Відповідає символу backspace (U+0008). Потрібно використовувати квадратні дужки, якщо ви бажаєте отримати збіг з літералом backspace. (Не треба плутати з <code>\b</code>.)</td>
  </tr>
  <tr>
   <td><a href="#special-word-boundary" id="special-word-boundary" name="special-word-boundary"><code>\b</code></a></td>
   <td>
    <p>Відповідає межі слова. Межа слова відповідає позиції де літерному символу не передує або слідує за ним інший літерний символ. Зауважте, що межа слова не включається до збігу. Іншими словами його довжина дорівнює нулю. (Не треба плутати з <code>[\b]</code>.)</p>

    <p>Приклади:<br>
     <code>/\bm/</code> відповідає '<strong>m</strong>' в "<strong>m</strong>oon" ;<br>
     <code>/oo\b/</code> не збігається з '<strong>oo</strong>' в "m<strong>oo</strong>n", тому що за '<strong>oo</strong>' йде символ '<strong>n</strong>', який є літерним символом;<br>
     <code>/oon\b/</code> збігається з '<strong>oon</strong>' в "m<strong>oon</strong>", тому що '<strong>oon</strong>' є кінцем рядка, тож за ним не йде літерний символ;<br>
     <code>/\w\b\w/</code> ніколи не буде мати збігу, тому що за літерним символом ніколи не буде йти не-літерний символ разом з літерним символом.</p>

    <div class="note">
    <p><strong>Примітка:</strong> Рушій регулярних виразів JavaScript визначає <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-15.10.2.6">особливий набір символів</a> що є літерними символами. Будь-який символ не з цього переліка вважається розділовим знаком - межею слова. Цей набір символів є доволі обмеженим: він складається тільки з символів латинської абетки в верхньому та нижньому регістрах, цифр та символу підкресленя. Акцентовані літери, такі як "é" або "ü", несподівано, вважаються розділовими знаками.</p>
    </div>
   </td>
  </tr>
  <tr>
   <td><a href="#special-non-word-boundary" id="special-non-word-boundary" name="special-non-word-boundary"><code>\B</code></a></td>
   <td>
    <p>Відповідає межі не-слова. Цей літерал відповідає позиції де попередній та наступний символи є символами одного типу: Тож обидва символи повині бути літерними, або не-літерними символами. Початок та кінець рядка вважаються не-літерними символами.</p>

    <p>Наприклад, <code>/\B../</code> відповідає '<strong>oo</strong>' в "n<strong>oo</strong>nday", та <code>/y\B./</code> збігається з 'ye' в "possibly <strong>ye</strong>sterday."</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-control" id="special-control" name="special-control"><code>\c<em>X</em></code></a></td>
   <td>
    <p>Де <em>X</em> є символом в діапазоні від A до Z. Відповідає керуючим символам в рядку.</p>

    <p>Наприклад, <code>/\cM/</code> відповідає control-M (U+000D) в рядку.</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-digit" id="special-digit" name="special-digit"><code>\d</code></a></td>
   <td>
    <p>Відповідає цифровому символу. Еквівалент <code>[0-9]</code>.</p>

    <p>Наприклад, <code>/\d/</code> або <code>/[0-9]/</code> збігатиметься з '<strong>2</strong>' в "B<strong>2</strong> is the suite number."</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-non-digit" id="special-non-digit" name="special-non-digit"><code>\D</code></a></td>
   <td>
    <p>Відповідає не-цифровому символу. Еквівалент <code>[^0-9]</code>.</p>

    <p>Наприклад, <code>/\D/</code> або <code>/[^0-9]/</code> збігатиметься з '<strong>B</strong>' в "<strong>B</strong>2 is the suite number."</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-form-feed" id="special-form-feed" name="special-form-feed"><code>\f</code></a></td>
   <td>Відповідає символу прогону сторінки (U+000C).</td>
  </tr>
  <tr>
   <td><a href="#special-line-feed" id="special-line-feed" name="special-line-feed"><code>\n</code></a></td>
   <td>Відповідає символу переводу рядка (U+000A).</td>
  </tr>
  <tr>
   <td><a href="#special-carriage-return" id="special-carriage-return" name="special-carriage-return"><code>\r</code></a></td>
   <td>Відповідає символу повернення каретки (U+000D).</td>
  </tr>
  <tr>
   <td><a href="#special-white-space" id="special-white-space" name="special-white-space"><code>\s</code></a></td>
   <td>
    <p>Відповідає одиничному пробільному символу, включаючи пробіл, табуляцію, прогін сторінки, перевод рядка. Еквівалент <code>[ \f\n\r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]</code>.</p>

    <p>Наприклад, <code>/\s\w*/</code> збігається з ' <strong>bar</strong>' в "foo <strong>bar</strong>."</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-non-white-space" id="special-non-white-space" name="special-non-white-space"><code>\S</code></a></td>
   <td>
    <p>Відповідає одиничному непробільному символу. Еквівалент <code>[^ \f\n\r\t\v\u00a0\u1680\u180e\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]</code>.</p>

    <p>Наприклад, <code>/\S\w*/</code> відповідає '<strong>foo</strong>' в "<strong>foo</strong> bar."</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-tab" id="special-tab" name="special-tab"><code>\t</code></a></td>
   <td>Відповідає табуляції (U+0009).</td>
  </tr>
  <tr>
   <td><a href="#special-vertical-tab" id="special-vertical-tab" name="special-vertical-tab"><code>\v</code></a></td>
   <td>Відповідає вертикальній табуляції (U+000B).</td>
  </tr>
  <tr>
   <td><a href="#special-word" id="special-word" name="special-word"><code>\w</code></a></td>
   <td>
    <p>Відповідає будь-якому літерно-цифровому символу включаючи символ підкреслювання. Еквівалент <code>[A-Za-z0-9_]</code>.</p>

    <p>Наприклад, <code>/\w/</code> відповідає '<strong>a</strong>' в "<strong>a</strong>pple," '<strong>5</strong>' в "$<strong>5</strong>.28," та '<strong>3</strong>' в "<strong>3</strong>D."</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-non-word" id="special-non-word" name="special-non-word"><code>\W</code></a></td>
   <td>
    <p>Відповідає будь-якому не-літерному символу. Еквівалент <code>[^A-Za-z0-9_]</code>.</p>

    <p>Наприклад, <code>/\W/</code> або <code>/[^A-Za-z0-9_]/</code> відповідає '<strong>%</strong>' в "50<strong>%</strong>."</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-backreference" id="special-backreference" name="special-backreference"><code>\<em>n</em></code></a></td>
   <td>
    <p>Де <em>n</em> є додатним цілим числом, зворотнє посилання на останій збіг підрядка з <em>n</em>-х відповідних круглих дужок шаблона регулярного виразу (рахуючи від лівої дужки).</p>

    <p>Наприклад, <code>/apple(,)\sorange\1/</code> відповідає '<strong>apple, orange,</strong>' в "<strong>apple, orange,</strong> cherry, peach."</p>
   </td>
  </tr>
  <tr>
   <td><a href="#special-null" id="special-null" name="special-null"><code>\0</code></a></td>
   <td>Відповідає символу NULL (U+0000). Не використовуйте цей символ разом з іншими цифрами, тому що <code>\0&lt;digits&gt;</code> є вісімковою <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Values,_variables,_and_literals#Unicode_escape_sequences" title="https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Values,_variables,_and_literals#Unicode_escape_sequences">керуючою послідовністю</a>.</td>
  </tr>
  <tr>
   <td><a href="#special-hex-escape" id="special-hex-escape" name="special-hex-escape"><code>\xhh</code></a></td>
   <td>Відповідає символу з кодом hh (два шістнадцяткові знаки)</td>
  </tr>
  <tr>
   <td><a href="#special-unicode-escape" id="special-unicode-escape" name="special-unicode-escape"><code>\uhhhh</code></a></td>
   <td>Відповідає символу з кодом hhhh (чотири шістнадцяткові знаки).</td>
  </tr>
  <tr>
   <td><a href="#special-unicode-escape-es6" id="special-unicode-escape-es6" name="special-unicode-escape-es6"><code>\u{hhhh}</code></a></td>
   <td>(тільки разом з прапором <strong>u</strong>) Відповідає символу Юнікод з коом hhhh (шістнадцяткові знаки).</td>
  </tr>
 </tbody>
</table>

<p>Екранований ввід користувача буде вважатись літерною послідовністю після застосування регулярного виразу для простої заміни:</p>

<pre class="brush: js notranslate">function escapeRegExp(string){
  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&amp;"); // $&amp; - підстановка результату
}</pre>

<h3 id="Використання_дужок">Використання дужок</h3>

<p>Дужки навколо будь-якої частини регулярного виразу означають, що ця частина порівнюванного рядка буде збережена. Після цього, ця частина рядка може бути вкликана для повторного використання, більш докладно у {{ web.link("#Using_parenthesized_substring_matches", "Використання збігів підрядків у дужках") }}.</p>

<p>Наприклад, шаблон <code>/Chapter (\d+)\.\d*/</code> показує додатково екрановані та спеціальні символи частини шаблону, яку потрібно запамʼятати. Він відповідає точному збігу слова 'Chapter ' за яким йде один чи більше цифрових символів (<strong><code>\d</code></strong> означає будь-який цифровий символ, а <strong><code>+</code></strong> означає 1 чи більше разів), за якими йде десяткова точка (яка сама по собі є спеціальним символом; додавання слеша <strong>\</strong> перед точкою дозволяє зробити її звичайним символом '<strong>.</strong>'), за якою йде будь-яке число, що повторюється від 0 та більше разів (<strong><code>\d</code></strong> означає числовий символ, <strong><code>*</code></strong><code> </code>означає 0 та більше разів). На додачу, дужки використовуються для того, щоб запамʼятати першу послідовність числових символів.</p>

<p>Цей шаблон в рядку "Open Chapter 4.3, paragraph 6" знайде числовий символ '4' та запамʼятає його. Шаблон не знайде збігів в "Chapter 3 and 4", тому що рядок не містить точку після '3'.</p>

<p>Для пошуку відповідності підрядка в дужках без його запамʼятовування. додавайте на початку шаблона в дужках комбінацію <strong><code>?:</code></strong>. Наприклад, <code>(?:\d+)</code> відповідає одному чи білше числовому символу але без їх запамʼятовування.</p>

<h2 id="Робота_з_регулярними_виразами">Робота з регулярними виразами</h2>

<p>Регулярні вирази використовуються разом з методами RegExp: test та exec, а також з методами String: mathc, replace, search та split. Ці методи детально описані в  <a href="/en-US/docs/Web/JavaScript/Reference" title="en-US/docs/JavaScript/Reference">JavaScript reference</a>.</p>

<table class="standard-table">
 <caption>Методи, які використовують регулярні вирази</caption>
 <thead>
  <tr>
   <th scope="col">Метод</th>
   <th scope="col">Опис</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td>{{jsxref("RegExp.exec", "exec")}}</td>
   <td>Метод <code>RegExp, який виконує пошук віповідностей у рядку. Він повертає список знайдених відповідностей.</code></td>
  </tr>
  <tr>
   <td>{{jsxref("RegExp.test", "test")}}</td>
   <td>Метод <code>RegExp, який перевіряє, чи рядок містить відповідність регулярному виразу. Повертає</code> true або false.</td>
  </tr>
  <tr>
   <td>{{jsxref("String.match", "match")}}</td>
   <td>Метод <code>String</code> який виконує пошук відповідностей у рядку. Повертає список знайдених відповідностей, або null за невдачі.</td>
  </tr>
  <tr>
   <td>{{jsxref("String.search", "search")}}</td>
   <td>Метод <code>String</code> який перевіряє , чи рядок містить відповідність регулярному виразу. Повертає індекс відповідності або -1 в разі невдачі.</td>
  </tr>
  <tr>
   <td>{{jsxref("String.replace", "replace")}}</td>
   <td>Метод <code>String</code> який виконує пошук відповідності у рядку і заміну знайдених підрядків на заданий рядок заміни.</td>
  </tr>
  <tr>
   <td>{{jsxref("String.split", "split")}}</td>
   <td>Метод <code>String</code> який застосовує регулярний вираз чи рядок-розділювач для розбиття рядку на список підрядків..</td>
  </tr>
 </tbody>
</table>

<p>Коли Вам потрібно дізнатися чи міститься шаблон у рядку, використовуйте методи <code>test</code> або <code>search</code>, для детальнішої інформації використовуйте методи <code>exec</code> чи <code>match</code> (виконуються повільніше). Якщо методи <code>exec</code> або <code>match</code> знаходять відповідність вони повертають список і оновлюють властивості пов'язаного об'єкта регулярного виразу, а також передвизначеного об'єкта регулярного виразу, <code>RegExp</code>. В протилежному випадку, метод <code>exec</code> повертає <code>null</code> (який приводиться до <code>false</code>).</p>

<p>В наступному прикладі, скрипт використовує метод <code>exec</code> для знаходження віповідності у рядку.</p>

<pre class="brush: js notranslate">var myRe = /d(b+)d/g;
var myArray = myRe.exec("cdbbdbsbz");
</pre>

<p>Якщо у Вас немє потреби мати доступ до властивостей регулярного виразу, альтернативний шлях створення <code>myArray</code> - у такому скрипті:</p>

<pre class="brush: js notranslate">var myArray = /d(b+)d/g.exec("cdbbdbsbz");
</pre>

<p>Ще один варіант цього скрипта, на випадок, якщо Вам потрібно сконструювати регулярний вираз з рядка:</p>

<pre class="brush: js notranslate">var myRe = new RegExp("d(b+)d", "g");
var myArray = myRe.exec("cdbbdbsbz");
</pre>

<p>Скрипти в цих прикладах знаходять відповідність, повертають список з результатами пошуку а також оновлюють властивості, показані в наступній таблиці.</p>

<table class="standard-table">
 <caption>Результати виконання регулярного виразу</caption>
 <thead>
  <tr>
   <th scope="col">Об'єкт</th>
   <th scope="col">Властивість чи індекс</th>
   <th scope="col">Опис</th>
   <th scope="col">У цьому прикладі</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td rowspan="4"><code>myArray</code></td>
   <td></td>
   <td>Відповідний рядок та всі запам'ятовані підрядки.</td>
   <td><code>["dbbd", "bb"]</code></td>
  </tr>
  <tr>
   <td><code>index</code></td>
   <td>Індекс відповідності на основі 0 у вхідному рядку.</td>
   <td><code>1</code></td>
  </tr>
  <tr>
   <td><code>input</code></td>
   <td>Початковий рядок.</td>
   <td><code>"cdbbdbsbz"</code></td>
  </tr>
  <tr>
   <td><code>[0]</code></td>
   <td>Останні відповідні символи.</td>
   <td><code>"dbbd"</code></td>
  </tr>
  <tr>
   <td rowspan="2"><code>myRe</code></td>
   <td><code>lastIndex</code></td>
   <td>Індекс з якого починати наступне порівняння. (Ця властивість встановлюється лише якщо регулярний вираз використовує g опцію, описану в {{ web.link("#Advanced_searching_with_flags", "Advanced Searching With Flags") }}.)</td>
   <td><code>5</code></td>
  </tr>
  <tr>
   <td><code>source</code></td>
   <td>Текст шаблону. Оновлений під час створення регулярного виразу, а не викионання.</td>
   <td><code>"d(b+)d"</code></td>
  </tr>
 </tbody>
</table>

<p>Як показано у другій формі цього прикладу, ви можете використовувати регулярні вирази створені через ініціалізатор об'єкта без привласнення їх до змінної. Однак якщо ви робите це, то кожен випадок це регулярний вирах. По цій причині, якщо ви використовуєте цю фору без привласнення до змінної, то у ви не зможете використовувати властивості регулярних виразів. Для прикладу, представте, що у вас є наступний скрипт:</p>

<pre class="brush: js notranslate">var myRe = /d(b+)d/g;
var myArray = myRe.exec("cdbbdbsbz");
console.log("The value of lastIndex is " + myRe.lastIndex);

// "Значення lastIndex є 5"
</pre>

<p>Однак, якщо ви маєте цей скрипт:</p>

<pre class="brush: js notranslate">var myArray = /d(b+)d/g.exec("cdbbdbsbz");
console.log("The value of lastIndex is " + /d(b+)d/g.lastIndex);

// "Значення lastIndex є 0"
</pre>

<p>Випадки <code>/d(b+)d/g</code>  у цих двох виразах є різними об'єктами регулярних виразів, отже мають різні значення для їх <code>lastIndex</code> властивості. Якщо вам треба мати доступ до властивостей регулярного виразу, який був створений через ініціалізатор об'єкту, то спочатку вам треба привласнити його до змінної.</p>

<h3 id="Використання_збігів_підрядків_у_дужках"><a id="Using_parenthesized_substring_matches" name="Using_parenthesized_substring_matches">Використання збігів підрядків у дужках</a></h3>

<p>Including parentheses in a regular expression pattern causes the corresponding submatch to be remembered. For example, <code>/a(b)c/</code> matches the characters 'abc' and remembers 'b'. To recall these parenthesized substring matches, use the <code>Array</code> elements <code>[1]</code>, ..., <code>[n]</code>.</p>

<p>The number of possible parenthesized substrings is unlimited. The returned array holds all that were found. The following examples illustrate how to use parenthesized substring matches.</p>

<p>The following script uses the {{jsxref("String.replace", "replace()")}} method to switch the words in the string. For the replacement text, the script uses the <code>$1</code> and <code>$2</code> in the replacement to denote the first and second parenthesized substring matches.</p>

<pre class="brush: js notranslate">var re = /(\w+)\s(\w+)/;
var str = "John Smith";
var newstr = str.replace(re, "$2, $1");
console.log(newstr);
</pre>

<p>This prints "Smith, John".</p>

<h3 id="Advanced_searching_with_flags">Advanced searching with flags</h3>

<p>Regular expressions have four optional flags that allow for global and case insensitive searching. These flags can be used separately or together in any order, and are included as part of the regular expression.</p>

<table class="standard-table">
 <caption>Regular expression flags</caption>
 <thead>
  <tr>
   <th scope="col">Flag</th>
   <th scope="col">Description</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><code>g</code></td>
   <td>Global search.</td>
  </tr>
  <tr>
   <td>i</td>
   <td>Case-insensitive search.</td>
  </tr>
  <tr>
   <td>m</td>
   <td>Multi-line search.</td>
  </tr>
  <tr>
   <td>y</td>
   <td>Perform a "sticky" search that matches starting at the current position in the target string. See {{jsxref("RegExp.sticky", "sticky")}}</td>
  </tr>
 </tbody>
</table>

<p>To include a flag with the regular expression, use this syntax:</p>

<pre class="brush: js notranslate">var re = /pattern/flags;
</pre>

<p>or</p>

<pre class="brush: js notranslate">var re = new RegExp("pattern", "flags");
</pre>

<p>Note that the flags are an integral part of a regular expression. They cannot be added or removed later.</p>

<p>For example, <code>re = /\w+\s/g</code> creates a regular expression that looks for one or more characters followed by a space, and it looks for this combination throughout the string.</p>

<pre class="brush: js notranslate">var re = /\w+\s/g;
var str = "fee fi fo fum";
var myArray = str.match(re);
console.log(myArray);
</pre>

<p>This displays ["fee ", "fi ", "fo "]. In this example, you could replace the line:</p>

<pre class="brush: js notranslate">var re = /\w+\s/g;
</pre>

<p>with:</p>

<pre class="brush: js notranslate">var re = new RegExp("\\w+\\s", "g");
</pre>

<p>and get the same result.</p>

<p>The <code>m</code> flag is used to specify that a multiline input string should be treated as multiple lines. If the <code>m</code> flag is used, <code>^</code> and <code>$</code> match at the start or end of any line within the input string instead of the start or end of the entire string.</p>

<h2 id="Examples">Examples</h2>

<p>The following examples show some uses of regular expressions.</p>

<h3 id="Changing_the_order_in_an_input_string">Changing the order in an input string</h3>

<p>The following example illustrates the formation of regular expressions and the use of <code>string.split()</code> and <code>string.replace()</code>. It cleans a roughly formatted input string containing names (first name first) separated by blanks, tabs and exactly one semicolon. Finally, it reverses the name order (last name first) and sorts the list.</p>

<pre class="brush: js notranslate">// The name string contains multiple spaces and tabs,
// and may have multiple spaces between first and last names.
var names = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ; Chris Hand ";

var output = ["---------- Original String\n", names + "\n"];

// Prepare two regular expression patterns and array storage.
// Split the string into array elements.

// pattern: possible white space then semicolon then possible white space
var pattern = /\s*;\s*/;

// Break the string into pieces separated by the pattern above and
// store the pieces in an array called nameList
var nameList = names.split(pattern);

// new pattern: one or more characters then spaces then characters.
// Use parentheses to "memorize" portions of the pattern.
// The memorized portions are referred to later.
pattern = /(\w+)\s+(\w+)/;

// New array for holding names being processed.
var bySurnameList = [];

// Display the name array and populate the new array
// with comma-separated names, last first.
//
// The replace method removes anything matching the pattern
// and replaces it with the memorized string—second memorized portion
// followed by comma space followed by first memorized portion.
//
// The variables $1 and $2 refer to the portions
// memorized while matching the pattern.

output.push("---------- After Split by Regular Expression");

var i, len;
for (i = 0, len = nameList.length; i &lt; len; i++){
  output.push(nameList[i]);
  bySurnameList[i] = nameList[i].replace(pattern, "$2, $1");
}

// Display the new array.
output.push("---------- Names Reversed");
for (i = 0, len = bySurnameList.length; i &lt; len; i++){
  output.push(bySurnameList[i]);
}

// Sort by last name, then display the sorted array.
bySurnameList.sort();
output.push("---------- Sorted");
for (i = 0, len = bySurnameList.length; i &lt; len; i++){
  output.push(bySurnameList[i]);
}

output.push("---------- End");

console.log(output.join("\n"));
</pre>

<h3 id="Using_special_characters_to_verify_input">Using special characters to verify input</h3>

<p>In the following example, the user is expected to enter a phone number. When the user presses the "Check" button, the script checks the validity of the number. If the number is valid (matches the character sequence specified by the regular expression), the script shows a message thanking the user and confirming the number. If the number is invalid, the script informs the user that the phone number is not valid.</p>

<p>Within non-capturing parentheses <code>(?:</code> , the regular expression looks for three numeric characters <code>\d{3}</code> OR <code>|</code> a left parenthesis <code>\(</code> followed by three digits<code> \d{3}</code>, followed by a close parenthesis <code>\)</code>, (end non-capturing parenthesis <code>)</code>), followed by one dash, forward slash, or decimal point and when found, remember the character <code>([-\/\.])</code>, followed by three digits <code>\d{3}</code>, followed by the remembered match of a dash, forward slash, or decimal point <code>\1</code>, followed by four digits <code>\d{4}</code>.</p>

<p>The <code>Change</code> event activated when the user presses Enter sets the value of <code>RegExp.input</code>.</p>

<pre class="brush: html notranslate">&lt;!DOCTYPE html&gt;
&lt;html&gt;
  &lt;head&gt;
    &lt;meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"&gt;
    &lt;meta http-equiv="Content-Script-Type" content="text/javascript"&gt;
    &lt;script type="text/javascript"&gt;
      var re = /(?:\d{3}|\(\d{3}\))([-\/\.])\d{3}\1\d{4}/;
      function testInfo(phoneInput){
        var OK = re.exec(phoneInput.value);
        if (!OK)
          window.alert(phoneInput.value + " isn't a phone number with area code!");
        else
          window.alert("Thanks, your phone number is " + OK[0]);
      }
    &lt;/script&gt;
  &lt;/head&gt;
  &lt;body&gt;
    &lt;p&gt;Enter your phone number (with area code) and then click "Check".
        &lt;br&gt;The expected format is like ###-###-####.&lt;/p&gt;
    &lt;form action="#"&gt;
      &lt;input id="phone"&gt;&lt;button onclick="testInfo(document.getElementById('phone'));"&gt;Check&lt;/button&gt;
    &lt;/form&gt;
  &lt;/body&gt;
&lt;/html&gt;
</pre>

<div>{{PreviousNext("Web/JavaScript/Guide/Text_formatting", "Web/JavaScript/Guide/Indexed_collections")}}</div>