---
title: String
slug: Web/JavaScript/Reference/Global_Objects/String
tags:
  - ECMAScript 2015
  - JavaScript
  - String
  - Довідка
  - рядок
translation_of: Web/JavaScript/Reference/Global_Objects/String
---
<div>{{JSRef}}</div>

<p>Глобальний об'єкт <strong><code>String</code></strong> є конструктором для рядків, або послідовностей символів.</p>

<h2 id="Опис">Опис</h2>

<p>Рядки корисні для утримання данних, які можуть бути представлені в текстовій формі. Деякі з найбільш виконуваних операцій над рядками: перевірка їхньої {{jsxref("String.length", "довжини")}}, побудова та об'єднання рядків за допомогою <a href="/en-US/docs/Web/JavaScript/Reference/Operators/String_Operators">рядкових операторів + та +=</a>, перевірка наявності чи розташування підрядків методом {{jsxref("String.prototype.indexOf()", "indexOf()")}} чи копіювання підрядків методом {{jsxref("String.prototype.substring()", "substring()")}}.</p>

<h3 id="Створення_рядків">Створення рядків</h3>

<p>Рядки можна створювати як примітиви, з рядкових літералів, або як об'єкти, використовуючи конструктор {{jsxref("String/String")}}:</p>

<pre class="brush: js notranslate">const string1 = "Рядковий примітив";
const string2 = 'Теж рядковий примітив';
const string3 = `І ще один рядковий примітив`;

const string4 = new String("Об'єкт String");</pre>

<p>Рядкові примітиви та рядкові об'єкти можна взаємно замінювати у більшості ситуацій. Дивіться нижче "<a href="https://wiki.developer.mozilla.org/uk/docs/Web/JavaScript/Reference/Global_Objects/String$edit#String_primitives_and_String_objects">Рядкові примітиви та рядкові об'єкти</a>".</p>

<p>Рядкові літерали можуть створюватись з використанням одинарних чи подвійних лапок, які працюють ідентично, або за допомогою зворотніх лапок <kbd>`</kbd>. Ця остання форма створює <a href="/uk/docs/Web/JavaScript/Reference/Template_literals">шаблонний літерал</a>: ця форма дозволяє інтерполювати вирази.</p>

<h3 id="Доступ_до_символів">Доступ до символів</h3>

<p>Існують два способи доступу до окремих символів рядка. Перший - це метод {{jsxref("String.prototype.charAt()", "charAt()")}}:</p>

<pre class="brush: js notranslate">return 'кіт'.charAt(1); // вертає "і"
</pre>

<p>Другий спосіб (запроваджений у ECMAScript 5) працює з рядком як з подібним до масиву об'єктом, де окремі символи відповідають числовому індексу:</p>

<pre class="brush: js notranslate">return 'кіт'[1]; // вертає "і"
</pre>

<p>Під час звернення до символу за допомогою дужкової нотації спроби видалити ці властивості чи присвоїти їм значення не матимуть успіху. Ці властивості не є доступними ані для запису, ані для налаштування. (Дивіться більше інформації у {{jsxref("Object.defineProperty()")}}.)</p>

<h3 id="Порівняння_рядків">Порівняння рядків</h3>

<p>У мові C для порівняння рядків використовується функція <code>strcmp()</code>. У JavaScript ви просто використовуєте оператори <a href="/uk/docs/Web/JavaScript/Reference/Operators/Оператори_порівняння">менше ніж та більше ніж</a>:</p>

<pre class="brush: js notranslate">var a = 'а';
var b = 'б';
if (a &lt; b) { // true
  console.log(a + ' менше ніж ' + b);
} else if (a &gt; b) {
  console.log(a + ' більше ніж ' + b);
} else {
  console.log(a + ' та ' + b + ' є рівними.');
}
</pre>

<p>Схожий результат можна отримати за допомогою методу {{jsxref("String.prototype.localeCompare()", "localeCompare()")}}, що успадковується екземплярами <code>String</code>.</p>

<p>Зауважте, що <code>a == b</code> перевіряє рядки у <code><var>a</var></code> та <code><var>b</var></code> на рівність у звичайний чутливий до регістру спосіб. Якщо вам потрібно порівняння літер без врахування регістру, використовуйте функцію, схожу на цю:</p>

<pre class="brush: js notranslate">function isEqual(str1, str2)
{
    return str1.toUpperCase() === str2.toUpperCase()
} // isEqual</pre>

<p>Верхній регістр використовується замість нижнього в цій функції через деякі проблеми з перетвореннями символів у UTF-8.</p>

<h3 id="Рядкові_примітиви_та_рядкові_обєкти">Рядкові примітиви та рядкові об'єкти</h3>

<p>Зауважте, що JavaScript розрізняє об'єкти <code>String</code> та примітивні рядкові значення. (Те саме стосується типу {{jsxref("Boolean")}} та {{jsxref("Global_Objects/Число", "чисел")}}.)</p>

<p>Рядкові літерали (позначаються подвійними чи одинарними лапками) та рядки, повернені викликами <code>String</code> не в контексті конструктора (тобто, без використання ключового слова {{jsxref("Operators/new", "new")}}) є примітивними рядками. JavaScript автоматично перетворює примітиви на об'єкти <code>String</code>, тому методи об'єкта <code>String</code> можливо використовувати на примітивних рядках. Там, де на примітивному рядку має бути викликаний метод або зустрічається звернення до властивості, JavaScript автоматично загорне рядковий примітив та викличе метод чи виконає звернення до властивості.</p>

<pre class="brush: js notranslate">var s_prim = 'няв';
var s_obj = new String(s_prim);

console.log(typeof s_prim); // Виведе "string"
console.log(typeof s_obj);  // Виведе "object"
</pre>

<p>Рядкові примітиви та об'єкти <code>String</code> також дають різні результати при використанні {{jsxref("Global_Objects/eval", "eval()")}}. Примітиви, передані у <code>eval</code>, сприймаються як першокод; об'єкти <code>String</code> поводяться як усі об'єкти, повертаючи об'єкт. Наприклад:</p>

<pre class="brush: js notranslate">var s1 = '2 + 2';             // створює рядковий примітив
var s2 = new String('2 + 2'); // створює об'єкт String
console.log(eval(s1));        // повертає число 4
console.log(eval(s2));        // повертає рядок "2 + 2"
</pre>

<p>Через це може статись помилка, якщо код зустрічає об'єкт <code>String</code> там, де очікує рядковий примітив, хоча, загалом, розробникам не потрібно хвилюватись щодо відмінностей.</p>

<p>Об'єкт <code>String</code> завжди можна перетворити на його примітивний аналог методом {{jsxref("String.prototype.valueOf()", "valueOf()")}}.</p>

<pre class="brush: js notranslate">console.log(eval(s2.valueOf())); // вертає число 4
</pre>

<h3 id="Екранування">Екранування</h3>

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

<table class="standard-table">
 <thead>
  <tr>
   <th scope="col">Код</th>
   <th scope="col">Результат</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><code>\<var>XXX</var></code><br>
    (де <code><var>XXX</var></code> - це 1–3 вісімкових цифр; діапазон <code>0</code>–<code>377</code>)</td>
   <td>Символ ISO-8859-1 / код символа Юнікоду між <code>U+0000</code> та <code>U+00FF</code></td>
  </tr>
  <tr>
   <td><code>\'</code></td>
   <td>одинарні лапки</td>
  </tr>
  <tr>
   <td><code>\"</code></td>
   <td>подвійні лапки</td>
  </tr>
  <tr>
   <td><code>\\</code></td>
   <td>зворотній слеш</td>
  </tr>
  <tr>
   <td><code>\n</code></td>
   <td>новий рядок</td>
  </tr>
  <tr>
   <td><code>\r</code></td>
   <td>повернення каретки</td>
  </tr>
  <tr>
   <td><code>\v</code></td>
   <td>вертикальна табуляція</td>
  </tr>
  <tr>
   <td><code>\t</code></td>
   <td>горизонтальна табуляція</td>
  </tr>
  <tr>
   <td><code>\b</code></td>
   <td>повернення на крок</td>
  </tr>
  <tr>
   <td><code>\f</code></td>
   <td>зміна сторінки</td>
  </tr>
  <tr>
   <td><code>\u<var>XXXX</var></code> (де <code><var>XXXX</var></code> - це 4 шістнадцяткових символа; діапазон <code>0x0000</code>–<code>0xFFFF</code>)</td>
   <td>Кодова одиниця UTF-16 / код символа Юнікоду між <code>U+0000</code> та <code>U+FFFF</code></td>
  </tr>
  <tr>
   <td><code>\u{<var>X</var>}</code> ... <code>\u{<var>XXXXXX</var>}</code><br>
    (де <code><var>X</var>…<var>XXXXXX</var></code> - це 1–6 шістнадцяткових символів; діапазон <code>0x0</code>–<code>0x10FFFF</code>)</td>
   <td>Кодова одиниця UTF-32 / код символа Юнікоду між <code>U+0000</code> та <code>U+10FFFF</code></td>
  </tr>
  <tr>
   <td><code>\x<var>XX</var></code><br>
    (де <code><var>XX</var></code> - це 2 шістнадцяткові символи; діапазон <code>0x00</code>–<code>0xFF</code>)</td>
   <td>символ ISO-8859-1 / код символа Юнікоду між <code>U+0000</code> та <code>U+00FF</code></td>
  </tr>
 </tbody>
</table>

<h3 id="Довгі_рядкові_літерали">Довгі рядкові літерали</h3>

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

<h4 id="Метод_1">Метод 1</h4>

<p>Ви можете скористатись оператором <a href="/uk/docs/Web/JavaScript/Reference/Operators/Addition">+</a> для поєднання багатьох рядків, ось так:</p>

<pre class="brush: js notranslate">let longString = "Це дуже довгий текст, його треба " +
                 "записати в декілька рядків," +
                 "інакше мій код буде важко читати."</pre>

<h4 id="Метод_2">Метод 2</h4>

<p>Ви можете скористатись символом зворотній слеш (<code>\</code>) в кінці кожного рядка, щоб позначити, що текст продовжується на наступному рядку. Переконайтесь, що після зворотнього слеша немає пробілу чи будь-якого іншого символу (окрім символу розриву рядка), або відступу; інакше, це не спрацює.</p>

<p>Ця форма виглядає ось так:</p>

<pre class="brush: js notranslate">let longString = "Це дуже довгий текст, його треба \
записати в декілька рядків, \
інакше мій код буде важко читати."</pre>

<p>Обидва наведені методи виводять ідентичні рядки.</p>

<h2 id="Конструктор">Конструктор</h2>

<dl>
 <dt>{{jsxref("String/String", "String()")}}</dt>
 <dd>Створює новий об'єкт <code>String</code>. Він виконує перетворення типів, коли викликається як функція, а не як конструктор, що, зазвичай, більш корисно.</dd>
</dl>

<h2 id="Статичні_методи">Статичні методи</h2>

<dl>
 <dt>{{jsxref("String.fromCharCode()", "String.fromCharCode(<var>num1</var> [, ...[, <var>numN</var>]])")}}</dt>
 <dd>Вертає рядок, створений за допомогою вказаної послідовності значень Юнікоду.</dd>
 <dt>{{jsxref("String.fromCodePoint()", "String.fromCodePoint(<var>num1</var> [, ...[, <var>numN</var>)")}}</dt>
 <dd>Вертає рядок, створений за допомогою вказаної послідовності кодів символів.</dd>
 <dt>{{jsxref("String.raw()")}}</dt>
 <dd>Вертає рядок, створений з сирого шаблонного рядка.</dd>
</dl>

<h2 id="Властивості_екземплярів">Властивості екземплярів</h2>

<dl>
 <dt>{{jsxref("String.prototype.length")}}</dt>
 <dd>Відображає довжину рядка. Доступна лише для читання.</dd>
</dl>

<h2 id="Методи_екземплярів">Методи екземплярів</h2>

<dl>
 <dt>{{jsxref("String.prototype.charAt()", "String.prototype.charAt(<var>index</var>)")}}</dt>
 <dd>Вертає символ (рівно одну кодову одиницю UTF-16), розташований за вказаним індексом <code><var>index</var></code>.</dd>
 <dt>{{jsxref("String.prototype.charCodeAt()", "String.prototype.charCodeAt(<var>index</var>)")}}</dt>
 <dd>Вертає число, яке є значенням кодової одиниці UTF-16, розташованої за вказаним індексом <code><var>index</var></code>.</dd>
 <dt>{{jsxref("String.prototype.codePointAt()", "String.prototype.codePointAt(<var>pos</var>)")}}</dt>
 <dd>Вертає невід'ємне ціле число, яке є значенням коду символу UTF-16, що починається на вказаній позиції <code><var>pos</var></code>.</dd>
 <dt>{{jsxref("String.prototype.concat()", "String.prototype.concat(<var>str </var>[, ...<var>strN </var>])")}}</dt>
 <dd>Об'єднує текст двох (або більше) рядків та повертає новий рядок.</dd>
 <dt>{{jsxref("String.prototype.includes()", "String.prototype.includes(<var>searchString</var> [, <var>position</var>])")}}</dt>
 <dd>Визначає, чи містить рядок, що викликав метод, рядок <code><var>searchString</var></code>.</dd>
 <dt>{{jsxref("String.prototype.endsWith()", "String.prototype.endsWith(<var>searchString</var> [, <var>length</var>])")}}</dt>
 <dd>Визначає, чи завершується рядок символами рядка <code><var>searchString</var></code>.</dd>
 <dt>{{jsxref("String.prototype.indexOf()", "String.prototype.indexOf(<var>searchValue</var> [, <var>fromIndex</var>])")}}</dt>
 <dd>Вертає індекс всередині об'єкта {{jsxref("String")}}, що викликав метод, першого знайденого значення <code><var>searchValue</var></code>, або <code>-1</code>, якщо воно не знайдене.</dd>
 <dt>{{jsxref("String.prototype.lastIndexOf()", "String.prototype.lastIndexOf(<var>searchValue</var> [, <var>fromIndex</var>])")}}</dt>
 <dd>Вертає індекс всередині об'єкта {{jsxref("String")}}, що викликав метод, останнього знайденого значення <code><var>searchValue</var></code>, або <code>-1</code>, якщо значення не знайдене.</dd>
 <dt>{{jsxref("String.prototype.localeCompare()", "String.prototype.localeCompare(<var>compareString</var> [, <var>locales</var> [, <var>options</var>]])")}}</dt>
 <dd>Вертає число, що вказує, чи розташований рядок <code><var>compareString</var></code> перед, після, чи однаково, відносно наданого рядка у відсованій послідовності.</dd>
 <dt>{{jsxref("String.prototype.match()", "String.prototype.match(<var>regexp</var>)")}}</dt>
 <dd>Використовується, щоб зіставити регулярний вираз <code><var>regexp</var></code> з рядком.</dd>
 <dt>{{jsxref("String.prototype.matchAll()", "String.prototype.matchAll(<var>regexp</var>)")}}</dt>
 <dd>Вертає ітератор усіх збігів з регулярним виразом.</dd>
 <dt>{{jsxref("String.prototype.normalize()", "String.prototype.normalize([<var>form</var>])")}}</dt>
 <dd>Вертає рядкове значення, на якому викликано метод, у формі нормалізації Юнікоду.</dd>
 <dt>{{jsxref("String.prototype.padEnd()", "String.prototype.padEnd(<var>targetLength</var> [, <var>padString</var>])")}}</dt>
 <dd>Доповнює поточний рядок наданим рядком з кінця та повертає новий рядок, що має довжину <code><var>targetLength</var></code>.</dd>
 <dt>{{jsxref("String.prototype.padStart()", "String.prototype.padStart(<var>targetLength</var> [, <var>padString</var>])")}}</dt>
 <dd>Доповнює поточний рядок наданим рядком з початку та повертає новий рядок, що має довжину <code><var>targetLength</var></code>.</dd>
 <dt>{{jsxref("String.prototype.repeat()", "String.prototype.repeat(<var>count</var>)")}}</dt>
 <dd>Повертає рядок, що складається з елементів об'єкта, повторених <code><var>count</var></code> разів.</dd>
 <dt>{{jsxref("String.prototype.replace()" , "String.prototype.replace(<var>searchFor</var>, <var>replaceWith</var>)")}}</dt>
 <dd>Використовується, щоб замінити <code><em>searchFor</em></code> заміною <em><code>replaceWith</code></em>. <em><code>searchFor</code></em> може бути рядком або регулярним виразом, а <code><var>replaceWith</var></code> може бути рядком чи функцією.</dd>
 <dt>{{jsxref("String.prototype.replaceAll()" , "String.prototype.replaceAll(<var>searchFor</var>, <var>replaceWith</var>)")}}</dt>
 <dd>Використовується, щоб замінити усі збіги з шаблоном <em><code>searchFor</code></em> заміною <code><var>replaceWith</var></code>. <code><var>searchFor</var></code> може бути рядком або регулярним виразом, а <code><var>replaceWith</var></code> може бути рядком або функцією.</dd>
 <dt>{{jsxref("String.prototype.search()", "String.prototype.search(<var>regexp</var>)")}}</dt>
 <dd>Шукає збіг між регулярним виразом <code><var>regexp</var></code> та рядком, що викликав метод.</dd>
 <dt>{{jsxref("String.prototype.slice()", "String.prototype.slice(<var>beginIndex</var>[, <var>endIndex</var>])")}}</dt>
 <dd>Вирізає частину рядка та повертає новий рядок.</dd>
 <dt>{{jsxref("String.prototype.split()", "String.prototype.split([<var>sep</var> [, <var>limit</var>] ])")}}</dt>
 <dd>Вертає масив рядків, заповнених розділенням початкового рядка підрядком <code><var>sep</var></code>.</dd>
 <dt>{{jsxref("String.prototype.startsWith()", "String.prototype.startsWith(<var>searchString</var> [, <var>length</var>])")}}</dt>
 <dd>Визначає, чи починається рядок з символів рядка <code><var>searchString</var></code>.</dd>
 <dt>{{jsxref("String.prototype.substr()")}}</dt>
 <dd>Повертає вказану кільксть символів на початку рядка з вказаної позиції.</dd>
 <dt>{{jsxref("String.prototype.substring()", "String.prototype.substring(<var>indexStart</var> [, <var>indexEnd</var>])")}}</dt>
 <dd>Повертає рядок, що містить символи рядка від вказаного індекса, або між вказаними індексами.</dd>
 <dt>{{jsxref("String.prototype.toLocaleLowerCase()", "String.prototype.toLocaleLowerCase( [<var>locale</var>, ...<var>locales</var>])")}}</dt>
 <dd>
 <p>Символи рядка переводяться до нижнього регістра відповідно до поточних регіональних налаштувань.</p>

 <p>Для більшості мов результат буде такий самий, як у {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}.</p>
 </dd>
 <dt>{{jsxref("String.prototype.toLocaleUpperCase()", "String.prototype.toLocaleUpperCase( [<var>locale</var>, ...<var>locales</var>])")}}</dt>
 <dd>
 <p>Символи рядка переводяться до верхнього регістра відповідно до поточних регіональних налаштувань.</p>

 <p>Для більшості мов результат буде такий самий, як у {{jsxref("String.prototype.toUpperCase()", "toUpperCase()")}}.</p>
 </dd>
 <dt>{{jsxref("String.prototype.toLowerCase()")}}</dt>
 <dd>Повертає значення рядка, переведене до нижнього регістра.</dd>
 <dt>{{jsxref("String.prototype.toString()")}}</dt>
 <dd>Повертає рядкове представлення вказаного об'єкта. Заміщує метод {{jsxref("Object.prototype.toString()")}}.</dd>
 <dt>{{jsxref("String.prototype.toUpperCase()")}}</dt>
 <dd>Повертає значення рядка, переведене до верхнього регістра.</dd>
 <dt>{{jsxref("String.prototype.trim()")}}</dt>
 <dd>Прибирає пробіли з початку та кінця рядка. Частина стандарту ECMAScript 5.</dd>
 <dt>{{jsxref("String.prototype.trimStart()")}}</dt>
 <dd>Видаляє пробіли з початку рядка.</dd>
 <dt>{{jsxref("String.prototype.trimEnd()")}}</dt>
 <dd>Видаляє пробіли з кінця рядка.</dd>
 <dt>{{jsxref("String.prototype.valueOf()")}}</dt>
 <dd>Повертає просту величину вказаного об'єкта. Заміщує метод {{jsxref("Object.prototype.valueOf()")}}.</dd>
 <dt>{{jsxref("String.prototype.@@iterator()")}}</dt>
 <dd>Повертає новий об'єкт <code>Iterator</code>, який перебирає коди символів рядка, повертаючи кожний код символа рядкового значення.</dd>
</dl>

<h2 id="Методи_HTML-обгортки">Методи HTML-обгортки</h2>

<p><strong>Застарілі. Уникайте цих методів.</strong></p>

<p>Вони обмежено використовуються, оскільки надають набір доступних тегів та атрибутів HTML.</p>

<dl>
 <dt>{{jsxref("String.prototype.anchor()")}}</dt>
 <dd>{{htmlattrxref("name", "a", "&lt;a name=\"name\"&gt;")}} (гіпертекстове посилання)</dd>
 <dt>{{jsxref("String.prototype.big()")}}</dt>
 <dd>{{HTMLElement("big")}}</dd>
 <dt>{{jsxref("String.prototype.blink()")}}</dt>
 <dd>{{HTMLElement("blink")}}</dd>
 <dt>{{jsxref("String.prototype.bold()")}}</dt>
 <dd>{{HTMLElement("b")}}</dd>
 <dt>{{jsxref("String.prototype.fixed()")}}</dt>
 <dd>{{HTMLElement("tt")}}</dd>
 <dt>{{jsxref("String.prototype.fontcolor()")}}</dt>
 <dd>{{htmlattrxref("color", "font", "&lt;font color=\"color\"&gt;")}}</dd>
 <dt>{{jsxref("String.prototype.fontsize()")}}</dt>
 <dd>{{htmlattrxref("size", "font", "&lt;font size=\"size\"&gt;")}}</dd>
 <dt>{{jsxref("String.prototype.italics()")}}</dt>
 <dd>{{HTMLElement("i")}}</dd>
 <dt>{{jsxref("String.prototype.link()")}}</dt>
 <dd>{{htmlattrxref("href", "a", "&lt;a href=\"url\"&gt;")}} (посилання на URL)</dd>
 <dt>{{jsxref("String.prototype.small()")}}</dt>
 <dd>{{HTMLElement("small")}}</dd>
 <dt>{{jsxref("String.prototype.strike()")}}</dt>
 <dd>{{HTMLElement("strike")}}</dd>
 <dt>{{jsxref("String.prototype.sub()")}}</dt>
 <dd>{{HTMLElement("sub")}}</dd>
 <dt>{{jsxref("String.prototype.sup()")}}</dt>
 <dd>{{HTMLElement("sup")}}</dd>
</dl>

<h2 id="Приклади">Приклади</h2>

<h3 id="Перетворення_рядка">Перетворення рядка</h3>

<p>Можливо використовувати <code>String</code> як більш надійну альтернативу {{jsxref("String.prototype.toString()", "toString()")}}, оскільки вона працює при використанні з {{jsxref("null")}}, {{jsxref("undefined")}} та {{jsxref("Symbol", "символами")}}. Наприклад:</p>

<pre class="brush: js notranslate">var outputStrings = [];
for (let i = 0, n = inputValues.length; i &lt; n; ++i) {
  outputStrings.push(String(inputValues[i]));
}
</pre>

<h2 id="Специфікації">Специфікації</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Специфікація</th>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-string-objects', 'String')}}</td>
  </tr>
 </tbody>
</table>

<h2 id="Сумісність_з_веб-переглядачами">Сумісність з веб-переглядачами</h2>

<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>

<p>{{Compat("javascript.builtins.String.String")}}</p>

<h2 id="Див._також">Див. також</h2>

<ul>
 <li><a href="/uk/docs/Web/JavaScript/Guide/Text_formatting">Форматування тексту у посібнику JavaScript Guide</a></li>
 <li>{{jsxref("RegExp")}}</li>
 <li>{{domxref("DOMString")}}</li>
 <li><a href="/uk/Add-ons/Code_snippets/StringView"><code>StringView</code> — C-подібне відображення рядків на основі типизованих масивів</a></li>
 <li><a href="/uk/docs/Web/API/DOMString/Binary">Двійкові рядки</a></li>
</ul>