String.prototype.localeCompare() - JavaScript

String.prototype.localeCompare()
================================

Метод **`localeCompare()`** `строковых значений` возвращает число, указывающее, где должна находиться эта строка при сортировке (до, после или в том же самом месте, что и строка, переданная в качестве параметра). В реализациях с поддержкой `Intl.Collator` API этот метод просто вызывает `Intl.Collator`.

При сравнении большого количества строк, например при сортировке больших массивов, лучше создать объект `Intl.Collator` и использовать предоставляемый им метод `compare()`.

Интерактивный пример
--------------------

Синтаксис
---------

```js
localeCompare(compareString)
localeCompare(compareString, locales)
localeCompare(compareString, locales, options)
```

### Параметры

Параметры `locales` и `options`Параметры `locales` и `options` изменяют поведение функции и позволяют приложениям определять язык, правила форматирования которого, следует использовать.

В реализациях, поддерживающих `Intl.Collator` API, эти параметры соответствуют параметрам конструктора `Intl.Collator()` (en-US). Реализации без поддержки `Intl.Collator` должны игнорировать оба параметра, возвращаемый результат сравнения полностью зависит от реализации.

`compareString`

Строка, с которой сравнивается `referenceStr`. Все значения приводятся к строкам, поэтому отсутствие значения или значение `undefined` приводит к тому, что `localeCompare()` будет сравнивать со строкой `"undefined"`, а это скорее всего не то, что вы ожидаете.

`locales` Необязательный

Строка с языковым тегом BCP 47 или массив таких строк. Соответствует параметру `locales` (en-US) конструктора `Intl.Collator()`.

В реализациях без поддержки `Intl.Collator` этот параметр игнорируется и обычно используется локаль устройства.

`options` Необязательный

Объект определяющий выходной формат. Соответствует параметру `options` (en-US) конструктора `Intl.Collator()`.

В реализациях без поддержки `Intl.Collator` этот параметр игнорируется.

Смотрите описание конструктора `Intl.Collator()` (en-US) для подробностей использования параметров `locales` и `options`.

### Возвращаемое значение

**Отрицательное** число если `referenceStr` встречается перед `compareString`; **положительное** если `referenceStr` встречается после `compareString`; `0` если они одинаковы.

В реализациях с поддержкой `Intl.Collator` результат эквивалентен результату вызова `new Intl.Collator(locales, options).compare(referenceStr, compareString)`.

Описание
--------

Возвращает число, указывающее, расположена ли `referenceStr` до, после или в том же самом месте, что и `compareString`.

* Отрицательное число, когда `referenceStr` встречается перед `compareString`,
* Положительное число, когда `referenceStr` встречается после `compareString`,
* Возвращает `0` если строки одинаковы.

**Предупреждение:** Не полагайтесь на точные значения `-1` и `1`!

Отрицательные и положительные ответы отличаются в зависимости от браузера (и версии браузера), потому что спецификация ECMAScript определяет только то, что числа должны быть положительными и отрицательными. Некоторые браузеры могут возвращать `-2` или `2` или другие значения.

Примеры
-------

### Использование `localeCompare()`

```js
// Буква "а" идёт перед "в", поэтому результат будет отрицательным
"а".localeCompare("в"); // -2 или -1 (или другое отрицательное число)

// В алфавитном порядке слово "первый" идёт после "второй", поэтому результат будет положительным
"первый".localeCompare("второй"); // 2 или 1 (или другое положительное число)

// "а" и "а" одинаковы, поэтому результат будет равен нулю
"а".localeCompare("а"); // 0
```

### Сортировка массива

`localeCompare()` даёт возможность регистронезависимой сортировки массивов.

```js
const items = ["réservé", "Premier", "Cliché", "communiqué", "café", "Adieu"];
items.sort((a, b) => a.localeCompare(b, "fr", { ignorePunctuation: true }));
// ['Adieu', 'café', 'Cliché', 'communiqué', 'Premier', 'réservé']
```

### Проверка поддержки параметров `locales` и `options`

Параметры `locales` и `options` поддерживаются ещё не всеми браузерами.

Чтобы проверить их поддержку реализацией, используйте аргумент `"i"` (требование, чтобы недопустимые языковые метки отклонялись) и исключение `RangeError`:

```js
function localeCompareSupportsLocales() {
  try {
    "foo".localeCompare("bar", "i");
  } catch (e) {
    return e.name === "RangeError";
  }
  return false;
}
```

### Использование параметра `locales`

Результаты, предоставляемые `localeCompare()`, отличаются в зависимости от языка. Для получения порядка сортировки языка, используемого в пользовательском интерфейсе вашего приложения, убедитесь, что вы указали этот язык (и, возможно, несколько запасных языков) используя параметр `locales`:

```js
console.log("ä".localeCompare("z", "de")); // отрицательное значение: в немецком буква ä идёт рядом с буквой a
console.log("ä".localeCompare("z", "sv")); // положительное значение: в шведском буква ä следует после буквы z
```

### Использование параметра `options`

Результат, предоставляемый `localeCompare()`, может быть настроен с помощью параметра `options`:

```js
// В немецком буква a является базовой для буквы ä
console.log("ä".localeCompare("a", "de", { sensitivity: "base" })); // 0

// В шведском буквы ä и a являются двумя разными базовыми буквами
console.log("ä".localeCompare("a", "sv", { sensitivity: "base" })); // положительное значение
```

### Сортировка чисел

```js
// По умолчанию, "2" > "10"
console.log("2".localeCompare("10")); // 1

// Сортировка чисел с использованием настроек:
console.log("2".localeCompare("10", undefined, { numeric: true })); // -1

// Сортировка чисел с использованием языковых меток:
console.log("2".localeCompare("10", "en-u-kn-true")); // -1
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.localecompare |
| ECMAScript Internationalization API Specification # sup-String.prototype.localeCompare |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Intl.Collator`


String.prototype.link() - JavaScript

String.prototype.link()
=======================

**Устарело:** Эта возможность была удалена из веб-стандартов. Хотя некоторые браузеры по-прежнему могут поддерживать её, она находится в процессе удаления. Не используйте её ни в старых, ни в новых проектах. Страницы или веб-приложения, использующие её, могут в любой момент сломаться.

Сводка
------

Метод **`link()`** создаёт HTML-элемент `<a>`, заставляющий строку отображаться в виде ссылки на другой URL.

Синтаксис
---------
```

str.link(url)
```

### Параметры

`url`

Любая строка, определяющая атрибут `href` тега `<a>`; она должна содержать допустимый URL (относительный или абсолютный), символы амперсанда `&` должны быть закодированы в ней как `&`, а символы кавычки `"` — как `"`.

Описание
--------

Метод `link()` используется для создания кусочка HTML со ссылкой в гипертексте. Возвращённая строка затем может быть добавлена в документ при помощи метода `document.write()` или свойства `element.innerHTML`

Ссылки, созданные методом `link()`, становятся элементами в массиве `document.links`.

Примеры
-------

### Пример: использование метода `link()`

В следующем примере слово «MDN» отображается в виде гипертекстовой ссылки, ведущей на сайт Сети разработчиков Mozilla.

```js
var hotText = "MDN";
var URL = "https://developer.mozilla.org/";

document.write("Нажмите для возврата на " + hotText.link(URL));
```

Этот пример генерирует такой же вывод, как и следующий HTML:

```html
Нажмите для возврата на <a href="https://developer.mozilla.org/">MDN</a>
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.link |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.anchor()`


String.prototype.toLocaleLowerCase() - JavaScript

String.prototype.toLocaleLowerCase()
====================================

Сводка
------

Метод **`toLocaleLowerCase()`** возвращает значение строки, на которой он был вызван, преобразованное в нижний регистр согласно правилам преобразования регистра локали.

Синтаксис
---------
```

str.toLocaleLowerCase()
```

Описание
--------

Метод `toLocaleLowerCase()` возвращает значение строки, преобразованное в нижний регистр согласно правилам преобразования регистра локали. Метод `toLocaleLowerCase()` не изменяет значение самой строки. В большинстве случаев он возвращает тот же результат, что и метод `toLowerCase()`, но для некоторых локалей, например, турецкой, в которой правила преобразования регистра отличаются от правил по умолчанию, принятых в Юникоде, он может вернуть другой результат.

Примеры
-------

### Пример: использование метода `toLocaleLowerCase()`

```js
console.log("АЛФАВИТ".toLocaleLowerCase()); // 'алфавит'
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.tolocalelowercase |
| ECMAScript Internationalization API Specification # sup-string.prototype.tolocalelowercase |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.toLocaleUpperCase()`
* `String.prototype.toLowerCase()`
* `String.prototype.toUpperCase()`


String.prototype.indexOf() - JavaScript

String.prototype.indexOf()
==========================

Сводка
------

Метод **`indexOf()`** возвращает индекс первого вхождения указанного значения в строковый объект `String`, на котором он был вызван, начиная с индекса `fromIndex`. Возвращает -1, если значение не найдено.

Синтаксис
---------
```

str.indexOf(searchValue, [fromIndex])
```

### Параметры

`searchValue`

Строка, представляющая искомое значение.

`fromIndex`

Необязательный параметр. Местоположение внутри строки, откуда начинать поиск. Может быть любым целым числом. Значение по умолчанию установлено в 0. Если `fromIndex < 0`, поиск ведётся по всей строке (так же, как если бы был передан 0). Если `fromIndex >= str.length`, метод вернёт -1, но только в том случае, если `searchValue` не равен пустой строке, в этом случае он вернёт `str.length`.

Описание
--------

Символы в строке идут слева направо. Индекс первого символа равен 0, а последнего символа в строке `stringName` равен `stringName.length - 1`.

```js
"Синий кит".indexOf("Синий"); // вернёт 0
"Синий кит".indexOf("Голубой"); // вернёт -1
"Синий кит".indexOf("кит", 0); // вернёт 6
"Синий кит".indexOf("кит", 5); // вернёт 6
"Синий кит".indexOf("", 8); // вернёт 8
"Синий кит".indexOf("", 9); // вернёт 9
"Синий кит".indexOf("", 10); // вернёт 9
```

### Регистрозависимость

Метод `indexOf()` является регистрозависимым. Например, следующее выражение вернёт -1:

```js
"Синий кит".indexOf("синий"); // вернёт -1
```

### Проверка на вхождение

Обратите внимание, что значение 0 не вычисляется в `true`, а значение -1 не вычисляется в `false`. Поэтому, для проверки того, что конкретная строка содержится в другой строке, правильно делать так:

```js
"Синий кит".indexOf("Синий") !== -1; // true
"Синий кит".indexOf("Голубой") !== -1; // false
```

Примеры
-------

### Пример: использование методов `indexOf()` и `lastIndexOf()`

В следующем примере используются методы `indexOf()` и `lastIndexOf()` для нахождения значений в строке `"Дивный новый мир"`.

```js
var anyString = "Дивный новый мир";

console.log(
  "Индекс первого вхождения «й» с начала строки равен " +
    anyString.indexOf("й"),
);
// Отобразит 5
console.log(
  "Индекс первого вхождения «й» с конца строки равен " +
    anyString.lastIndexOf("й"),
);
// Отобразит 11

console.log(
  "Индекс вхождения «новый» с начала строки равен " +
    anyString.indexOf("новый"),
);
// Отобразит 7
console.log(
  "Индекс вхождения «новый» с конца строки равен " +
    anyString.lastIndexOf("новый"),
);
// Отобразит 7
```

### Пример: метод `indexOf()` и регистрозависимость

В следующем примере определяются две строковых переменных. Переменные содержат одинаковые строки, за исключение того, что слова во второй строке начинаются с заглавных букв. Первый вызов метода `console.log()` отобразит 18. Но поскольку метод `indexOf()` является регистрозависимым, строка `"чеддер"` в переменной `myCapString` не будет найдена, так что второй вызов метода `console.log()` отобразит -1.

```js
var myString = "бри, пеппер джек, чеддер";
var myCapString = "Бри, Пеппер Джек, Чеддер";

console.log(
  'Вызов myString.indexOf("чеддер") вернул ' + myString.indexOf("чеддер"),
);
// Отобразит 18
console.log(
  'Вызов myCapString.indexOf("чеддер") вернул ' + myCapString.indexOf("чеддер"),
);
// Отобразит -1
```

### Пример: использование метода `indexOf()` для подсчёта вхождений буквы в строку

Следующий пример устанавливает значение переменной `count` в количество вхождений буквы `в` в строку `str`:

```js
var str = "Быть или не быть, вот в чём вопрос.";
var count = 0;
var pos = str.indexOf("в");

while (pos !== -1) {
  count++;
  pos = str.indexOf("в", pos + 1);
}

console.log(count); // отобразит 3
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.indexof |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.charAt()`
* `String.prototype.lastIndexOf()`
* `String.prototype.split()`
* `Array.prototype.indexOf()`


String.prototype.blink() - JavaScript

String.prototype.blink()
========================

**Устарело:** Эта возможность была удалена из веб-стандартов. Хотя некоторые браузеры по-прежнему могут поддерживать её, она находится в процессе удаления. Не используйте её ни в старых, ни в новых проектах. Страницы или веб-приложения, использующие её, могут в любой момент сломаться.

Сводка
------

Метод **`blink()`** создаёт HTML-элемент `<blink>`, заставляющий строку мерцать.

**Предупреждение:** мерцающий текст осуждается некоторыми стандартами доступности. Сам элемент `<blink>` является нестандартным и устаревшим!

Синтаксис
---------
```

str.blink()
```

Описание
--------

Метод `blink()` заключает строку в тег `<blink>`: `"<blink>str</blink>"`.

Примеры
-------

### Пример: использование метода `blink()`

В следующем примере демонстрируется использование нескольких строковых методов для изменения форматирования строки:

```js
var worldString = "Привет, мир";

document.write(worldString.blink());
document.write(worldString.bold());
document.write(worldString.italics());
document.write(worldString.strike());
```

Этот пример генерирует такой же вывод, как и следующий HTML:

```html
<blink>Привет, мир</blink>
<b>Привет, мир</b>
<i>Привет, мир</i>
<strike>Привет, мир</strike>
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.blink |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.bold()`
* `String.prototype.italics()`
* `String.prototype.strike()`


String.prototype.small() - JavaScript

String.prototype.small()
========================

**Устарело:** Эта возможность была удалена из веб-стандартов. Хотя некоторые браузеры по-прежнему могут поддерживать её, она находится в процессе удаления. Не используйте её ни в старых, ни в новых проектах. Страницы или веб-приложения, использующие её, могут в любой момент сломаться.

Сводка
------

Метод **`small()`** создаёт HTML-элемент `<small>` (en-US), заставляющий строку отображаться маленьким шрифтом.

Синтаксис
---------
```

str.small()
```

Описание
--------

Метод `small()` заключает строку в тег `<small>`: `"<small>str</small>"`.

Примеры
-------

### Пример: использование метода `small()`

В следующем примере демонстрируется использование нескольких строковых методов для изменения размера строки:

```js
var worldString = "Привет, мир";

console.log(worldString.small()); // <small>Привет, мир</small>
console.log(worldString.big()); // <big>Привет, мир</big>
console.log(worldString.fontsize(7)); // <fontsize=7>Привет, мир</fontsize>
```

При помощи объекта `element.style` (en-US) вы можете получить значение атрибута `style` элемента и управлять им более обобщённым способом, например:

```js
document.getElementById("yourElemId").style.fontSize = "0.7em";
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.small |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.fontsize()`
* `String.prototype.big()`


String.prototype.toString() - JavaScript

String.prototype.toString()
===========================

Сводка
------

Метод **`toString()`** возвращает строку, представляющую указанный объект.

Синтаксис
---------
```

str.toString()
```

Описание
--------

Объект `String` переопределяет метод `toString()`, унаследованный из объекта `Object`; он не наследует метод `Object.prototype.toString()`. Для объектов `String` метод `toString()` возвращает строку, представляющую объект и делает тоже самое, что и метод `String.prototype.valueOf()`.

Примеры
-------

### Пример: использование метода `toString()`

В следующем примере выводится строковое значение объекта `String`:

```js
var x = new String("Привет, мир");

console.log(x.toString()); // Отобразит 'Привет, мир'
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.tostring |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Object.prototype.toSource()` (en-US)
* `String.prototype.valueOf()`


String.prototype.replaceAll() - JavaScript

String.prototype.replaceAll()
=============================

Метод **`replaceAll()`** возвращает новую строку со всеми совпадениями `pattern` , который меняется на `replacement`. `pattern` может быть строкой или регулярным выражением, и `replacement` может быть строкой или функция возвращающая каждое совпадение.

Исходная строка остаётся без изменений.

Интерактивный пример
--------------------

Syntax
------
```

const newStr = str.replaceAll(regexp|substr, newSubstr|function)
```

**Примечание:** Когда вы используете `regexp` вы должны установить флаг глобального поиска ("g"), иначе вернётся ошибка `TypeError`: "replaceAll must be called with a global RegExp".

### Parameters

`regexp` (pattern)

Регулярное выражение или буква с глобальным флагом поиска ("g"). Совпадения меняются на `newSubstr` или значении возвращённое указанной функцией `function`. A RegExp без глобального флага поиска ("g") вернёт ошибку `TypeError`: "replaceAll must be called with a global RegExp".

`substr`

Подстрока, которая заменится `newSubstr`. Обрабатывается как буквенная строка, не интерпретируется как регулярное выражение.

`newSubstr` (replacement)

Новая строка, которая заменяет найденные подстроки указанные в `regexp` или `substr` параметрах. Поддерживается ряд специальных шаблонов замены; смотрите "Specifying a string as a parameter" блок ниже.

`function` (replacement)

Функция вызванная при создании новой строки которая используется для замены совпадений указанных в `regexp` or `substr`. Аргументы применяемы в этой функции описываются в "Specifying a function as a parameter" блок ниже.

### Return value

Новая строка, в которой все совпадения замены на указанную подстроку или специальный шаблон.

Описание
--------

Этот метод не изменяет исходную строку. Он просто возвращает новую.

### Указание строки в качестве параметра

Заменённая строка может включатся в следующие специальные шаблоны:

| Pattern | Inserts |
| --- | --- |
| `$$` | Вставляет `"$"`. |
| `$&` | Вставлять совпадения. |
| `$`` | Вставляет часть строки которая находится перед совпадениями (строка соответствующая шаблону). |
| `$'` | Вставляет часть строки которая следует после совпадения (строка соответствующая шаблону). |
| `$n` | Где `n` положительное цело число меньше чем 100, вставляет `n`th строки указанные в скобках, частичные совпадения, при условии, что первый аргумент был `RegExp` object. Обратите внимание, что это 1-индексированный. |

### Указание функции в качестве параметра

Вы можете передать функцию вторым параметром. Этом случае, функция вызывается после нахождения совпадений. Результат функции может быть использована как замещающая строка. (**Внимание:** Выше упомянутые специальные шаблоны замены в данном случае неприменимы.)

Функция может быть вызвана многократно для каждого заменённого совпадения, если регулярное выражение указано с глобальным флагом("g").

Функция имеет следующие аргументы:

| Possible name | Supplied value |
| --- | --- |
| `match` | Найденная постройка. (Соответствует `$&` указанному выше) |
| `p1, p2, ...` | \_n\_th количество строк найденных групповыми скобками указанные первым параметром в регулярном выражении. (Соответствует `$1`, `$2`, см. выше) Для примера, если `/(\a+)(\b+)/`, то `p1` это `\a+`, а `p2` это `\b+`. |
| `offset` | Смещение совпадающей подстроки в пределах всей исследуемой строки. (Например, если вся строка была 'abcd', а соответствующая подстрока была 'bc', то этот аргумент будет равен 1.) |
| `string` | Исследуется вся цепочка. |

(Точное количество аргументов зависит от того, является ли первый аргумент регулярным выражением — и, если да, то аргументов будет столько сколько указанно в скобках.)

Examples
--------

### Using replaceAll

```js
"aabbcc".replaceAll("b", ".");
// 'aa..cc'
```

### Non-global regex throws

Поиск с регулярными выражениями должен быть с ("g"). Это не работает:

```js
'aabbcc'.replaceAll(/b/, '.');
TypeError: replaceAll must be called with a global RegExp
```

Это работает:

```js
"aabbcc".replaceAll(/b/g, ".");
("aa..cc");
```

Specifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.replaceall |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

See also
--------

* `String.prototype.replace()`
* `String.prototype.match()`
* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`


String.prototype.anchor() - JavaScript

String.prototype.anchor()
=========================

**Устарело:** Эта возможность была удалена из веб-стандартов. Хотя некоторые браузеры по-прежнему могут поддерживать её, она находится в процессе удаления. Не используйте её ни в старых, ни в новых проектах. Страницы или веб-приложения, использующие её, могут в любой момент сломаться.

Сводка
------

Метод **`anchor()`** создаёт якорный HTML-элемент `<a>`, используемый в качестве цели гиперссылки.

Синтаксис
---------
```

str.anchor(name)
```

### Параметры

`name`

Строка, представляющая атрибут `name` создаваемого тега.

Описание
--------

Метод `anchor()` используется для программного создания и отображения якоря в документе.

Текстовая строка представляет из себя буквальный текст, который вы хотите показать пользователю. Строковый параметр `name` представляет атрибут `name` элемента `<a>`.

Якоря, созданные методом `anchor()`, становятся элементами в массиве `document.anchors`.

Примеры
-------

### Пример: использование метода `anchor()`

```js
var myString = "Оглавление";

document.body.innerHTML = myString.anchor("contents\_anchor");
```

приведёт к выводу следующего HTML:

```html
<a name="contents\_anchor">Оглавление</a>
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.anchor |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.link()`


String.prototype.fontsize() - JavaScript

String.prototype.fontsize()
===========================

**Устарело:** Эта возможность была удалена из веб-стандартов. Хотя некоторые браузеры по-прежнему могут поддерживать её, она находится в процессе удаления. Не используйте её ни в старых, ни в новых проектах. Страницы или веб-приложения, использующие её, могут в любой момент сломаться.

Сводка
------

Метод **`fontsize()`** создаёт HTML-элемент `<font>`, заставляющий строку отображаться шрифтом указанного размера.

**Примечание:** элемент <font> был удалён из HTML5 (en-US) и больше не должен использоваться. Вместо него веб-разработчикам следует использовать свойства CSS.

Синтаксис
---------
```

str.fontsize(size)
```

### Параметры

`size`

Целое число от 1 до 7, либо строка с целым числом со знаком по модулю от 1 до 7.

Описание
--------

При задании размера в виде целого числа, вы устанавливаете размер шрифта строки `str` в один из 7 предопределённых размеров. При задании размера в виде строки, например, "-2", вы задаёте размер шрифта строки `str` относительно размера, установленного тегом `<basefont>` (en-US).

Примеры
-------

### Пример: использование метода `fontsize()`

В следующем примере демонстрируется использование нескольких строковых методов для изменения размера строки:

```js
var worldString = "Привет, мир";

console.log(worldString.small()); // <small>Привет, мир</small>
console.log(worldString.big()); // <big>Привет, мир</big>
console.log(worldString.fontsize(7)); // <fontsize=7>Привет, мир</fontsize>
```

При помощи объекта `element.style` (en-US) вы можете получить значение атрибута `style` элемента и управлять им более обобщённым способом, например:

```js
document.getElementById("yourElemId").style.fontSize = "0.7em";
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.fontsize |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.big()`
* `String.prototype.small()`


String.prototype.slice() - JavaScript

String.prototype.slice()
========================

Сводка
------

Метод **`slice()`** извлекает часть строки и возвращает новую строку без изменения оригинальной строки.

Интерактивный пример
--------------------

Синтаксис
---------
```

str.slice(beginIndex[, endIndex])
```

### Параметры

*`beginIndex`*

Индекс, с которого начинать извлечение (нумерация начинается с нуля). Если аргумент отрицателен, то трактуется как `str.length + beginIndex` (например, если *`beginIndex`* равен `-3`, то он трактуется как `str.length - 3`). Если *`beginIndex`* не является числом при проверке `Number(beginIndex)`, он трактуется как `0`.

Если `beginIndex` больше или равен `str.length`, возвращается пустая строка.

*`endIndex`*

Индекс, *перед* которым заканчивать извлечение (нумерация начинается с нуля). Символ по этому индексу не будет включён.

Если \*`endIndex` \*опущен или является `undefined` или больше чем `str.length`, `slice()` извлечёт всё до конца строки. Если аргумент отрицателен, то трактуется как `str.length + endIndex` (например, если `endIndex` равен `-3`, то он трактуется как `str.length - 3`). Если аргумент не `undefined` и не является числом при проверке `Number(endIndex)`, возвращается пустая строка.

Если *`endIndex`* указан и меньше *`startIndex`*, то возвращается пустая строка (например, `slice(-1, -3)` или `slice(3, 1)` вернут `""`).

### Возвращаемое значение

Новая строка, содержащая извлечённую часть строки.

Описание
--------

Метод `slice()` извлекает текст из одной строки и возвращает новую строку. Изменения текста в одной строке не влияют на другую строку.

Метод `slice()` извлекает все символы до индекса *`endIndex`*, не включая сам этот индекс. Вызов `str.slice(1, 4)` извлечёт символы со второго по четвёртый (символы под индексами `1`, `2` и `3`).

К примеру, вызов `str.slice(2, -1)` извлечёт символы с третьего по второй с конца строки.

Примеры
-------

### Пример: использование метода `slice()` для создания новой строки

В следующем примере метод `slice()` используется для создания новой строки.

```js
let str1 = "Приближается утро.";
let str2 = str1.slice(1, 8);
let str3 = str1.slice(4, -2);
let str4 = str1.slice(12);
let str5 = str1.slice(30);

console.log(str2); // ВЫВОД: риближа
console.log(str3); // ВЫВОД: лижается утр
console.log(str4); // ВЫВОД: утро.
console.log(str5); // ВЫВОД: ""
```

### Пример: использование метода `slice()` с отрицательными индексами

В следующем примере метод `slice()` используется вместе с отрицательными индексами.

```js
let str = "Приближается утро.";
str.slice(-3); // вернёт 'ро.'
str.slice(-3, -1); // вернёт 'ро'
str.slice(0, -1); // вернёт 'Приближается утро'
```

В этом примере начальным индексом считается `11`-й символ с конца строки, а конечным - `16`-й с начала.

```js
str.slice(-11, 16); // вернёт 'ается утр'
```

Здесь начальным индексом считается `6`-й символ от начала строки, а конечным - 7-й с конца.

```js
str.slice(6, -7); // вернёт 'жаетс'
```

В этом примере оба индекса считаются с конца строки: 5-й для начального индекса, `1`-й для конечного.

```js
str.slice(-5, -1); // вернёт 'утро'
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.slice |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.substr()`
* `String.prototype.substring()`
* `Array.prototype.slice()`


String.length - JavaScript

String.length
=============

Сводка
------

Свойство **`length`** представляет длину строки.

Синтаксис
---------
```

str.length
```

Описание
--------

Это свойство возвращает количество кодовых значений в строке. В UTF-16, строковом формате, используемом в JavaScript, для представления большинства символов используется одно 16-битное кодовое значение, но для представления не так часто используемых символов требуется два кодовых значения, так что вполне может быть так, что значение, возвращённое свойством `length` не будет соответствовать действительному количеству символов в строке.

Для пустых строк свойство `length` возвращает 0.

Статическое свойство `String.length` возвращает значение 1.

Примеры
-------

### Пример: базовое использование

```js
var x = "Mozilla";
var empty = "";

console.log("Слово «Mozilla» занимает " + x.length + " кодовых значений");
/\* "Слово «Mozilla» занимает 7 кодовых значений" \*/

console.log("Пустая строка имеет длину, равную " + empty.length);
/\* "Пустая строка имеет длину, равную 0" \*/
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-properties-of-string-instances-length |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* Свойство `String.length` в JavaScript и интернационализация веб-приложений


String.prototype.trim() - JavaScript

String.prototype.trim()
=======================

Сводка
------

Метод **`trim()`** удаляет пробельные символы с начала и конца строки. Пробельными символами в этом контексте считаются все собственно пробельные символы (пробел, табуляция, неразрывный пробел и прочие) и все символы конца строки (LF, CR и прочие).

Синтаксис
---------
```

str.trim()
```

Описание
--------

Метод `trim()` возвращает строку с вырезанными пробельными символами с её концов. Метод `trim()` не изменяет значение самой строки.

Примеры
-------

### Пример: использование метода `trim()`

Следующий пример покажет строку `'foo'`:

```js
var orig = " foo ";
console.log(orig.trim()); // 'foo'

// Другой пример, в котором .trim() убирает пробельные символы только с одной стороны.

var orig = "foo ";
console.log(orig.trim()); // 'foo'
```

Полифил
-------

Запуск следующего кода до любого другого создаст метод `trim()`, если он ещё не реализуется браузером.

```js
if (!String.prototype.trim) {
  (function () {
    // Вырезаем BOM и неразрывный пробел
    String.prototype.trim = function () {
      return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
    };
  })();
}
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.trim |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.trimLeft()`
Non-standard
* `String.prototype.trimRight()`
Non-standard


String.prototype.toUpperCase() - JavaScript

String.prototype.toUpperCase()
==============================

Сводка
------

Метод **`toUpperCase()`** возвращает значение строки, на которой он был вызван, преобразованное в верхний регистр.

Синтаксис
---------
```

str.toUpperCase()
```

Описание
--------

Метод `toUpperCase()` возвращает значение строки, преобразованное в верхний регистр. Метод `toUpperCase()` не изменяет значение самой строки.

Примеры
-------

### Пример: использование метода `toUpperCase()`

```js
console.log("алфавит".toUpperCase()); // 'АЛФАВИТ'
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.touppercase |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.toLocaleLowerCase()`
* `String.prototype.toLocaleUpperCase()`
* `String.prototype.toLowerCase()`


String.prototype.search() - JavaScript

String.prototype.search()
=========================

Сводка
------

Метод **`search()`** выполняет поиск сопоставления между регулярным выражением и этим объектом `String`.

Синтаксис
---------
```

str.search([regexp])
```

### Параметры

`regexp`

Необязательный параметр. Объект регулярного выражения. Если будет передан не объект регулярного выражения, он будет неявно преобразован в объект `RegExp` через вызов конструктора `new RegExp(regexp)`.

Описание
--------

При успехе метод `search()` возвращает индекс первого сопоставления с регулярным выражением внутри строки. В противном случае метод вернёт -1.

Если вы хотите узнать, находится ли шаблон в строке, используйте метод `search()` (он работает почти так же, как и метод `test()` регулярного выражения, но вместо наличия подстроки возвращает её индекс); для получения дополнительной информации (за счёт более медленного выполнения) используйте метод `match()` (работает так же, как метод `exec()` регулярного выражения).

Примеры
-------

### Пример: использование метода `search()`

В следующем примере в журнал попадает сообщение, зависящее от успешности или неуспешности прохождения проверки.

```js
function testInput(re, str) {
  var midstring;
  if (str.search(re) != -1) {
    midstring = " содержит ";
  } else {
    midstring = " не содержит ";
  }
  console.log(str + midstring + re);
}

var testString = "hey JuDe";
var re = /[A-Z]/g;

testInput(re, testString); // выведет: hey Jude содержит /[A-Z]/g
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.search |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.match()`
* `RegExp.prototype.exec()`


String.prototype.italics() - JavaScript

String.prototype.italics()
==========================

**Устарело:** Эта возможность была удалена из веб-стандартов. Хотя некоторые браузеры по-прежнему могут поддерживать её, она находится в процессе удаления. Не используйте её ни в старых, ни в новых проектах. Страницы или веб-приложения, использующие её, могут в любой момент сломаться.

Сводка
------

Метод **`italics()`** создаёт HTML-элемент `<i>` (en-US), заставляющий строку отображаться курсивом.

Синтаксис
---------
```

str.italics()
```

Описание
--------

Метод `italics()` заключает строку в тег `<i>`: `"<i>str</i>"`.

Примеры
-------

### Пример: использование метода `italics()`

В следующем примере демонстрируется использование нескольких строковых методов для изменения форматирования строки:

```js
var worldString = "Привет, мир";

document.write(worldString.blink());
document.write(worldString.bold());
document.write(worldString.italics());
document.write(worldString.strike());
```

Этот пример генерирует такой же вывод, как и следующий HTML:

```html
<blink>Привет, мир</blink>
<b>Привет, мир</b>
<i>Привет, мир</i>
<strike>Привет, мир</strike>
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.italics |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.blink()`
* `String.prototype.bold()`
* `String.prototype.strike()`


String.prototype.codePointAt() - JavaScript

String.prototype.codePointAt()
==============================

Сводка
------

Метод **`codePointAt()`** возвращает неотрицательное целое число, являющееся закодированным в UTF-16 значением кодовой точки.

Синтаксис
---------
```

str.codePointAt(pos)
```

### Параметры

`pos`

Позиция элемента в строке, чья кодовая точка возвращается функцией.

Описание
--------

Если на указанной позиции нет элементов, будет возвращено значение `undefined`. Если суррогатная пара UTF-16 не начинается в позиции `pos`, будет возвращено кодовое значение в позиции `pos`.

Примеры
-------

### Пример: использование метода `codePointAt()`

```js
"ABC".codePointAt(1); // 66
"\uD800\uDC00".codePointAt(0); // 65536

"XYZ".codePointAt(42); // undefined
```

Полифил
-------

Следующий полифил расширяет прототип строки определённой в ECMAScript 6 функцией `codePointAt()`, если браузер не имеет её родной поддержки.

```js
/\*! http://mths.be/codepointat v0.1.0 от @mathias \*/
if (!String.prototype.codePointAt) {
  (function () {
    "use strict"; // необходимо для поддержки методов `apply`/`call` с `undefined`/`null`
    var codePointAt = function (position) {
      if (this == null) {
        throw TypeError();
      }
      var string = String(this);
      var size = string.length;
      // `ToInteger`
      var index = position ? Number(position) : 0;
      if (index != index) {
        // лучше, чем `isNaN`
        index = 0;
      }
      // Проверяем выход индекса за границы строки
      if (index < 0 || index >= size) {
        return undefined;
      }
      // Получаем первое кодовое значение
      var first = string.charCodeAt(index);
      var second;
      if (
        // проверяем, не начинает ли оно суррогатную пару
        first >= 0xd800 &&
        first <= 0xdbff && // старшая часть суррогатной пары
        size > index + 1 // следующее кодовое значение
      ) {
        second = string.charCodeAt(index + 1);
        if (second >= 0xdc00 && second <= 0xdfff) {
          // младшая часть суррогатной пары
          // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
          return (first - 0xd800) \* 0x400 + second - 0xdc00 + 0x10000;
        }
      }
      return first;
    };
    if (Object.defineProperty) {
      Object.defineProperty(String.prototype, "codePointAt", {
        value: codePointAt,
        configurable: true,
        writable: true,
      });
    } else {
      String.prototype.codePointAt = codePointAt;
    }
  })();
}
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.codepointat |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.fromCodePoint()`
* `String.fromCharCode()`
* `String.prototype.charCodeAt()`
* `String.prototype.charAt()`


String.raw() - JavaScript

String.raw()
============

Сводка
------

Статический метод **`String.raw()`** является теговой функцией для шаблонных строк; подобно префиксу `r` в Python или префиксу `@` в C# для строковых литералов, эта функция используется для получения необработанной строки из шаблона.

Синтаксис
---------
```

String.raw(callSite, ...substitutions)

String.raw`templateString`
```

### Параметры

`callSite`

Правильно сформированный объект вызова, например `{ raw: 'string' }`.

`...substitutions`

Значения подстановок.

`templateString`

Шаблонная строка, возможно с подстановками (`${...}`).

### Выбрасываемые исключения

`TypeError`

Если первый аргумент не является правильно сформированным объектом вызова, выбрасывается исключение `TypeError`.

Описание
--------

В большинстве случаев метод `String.raw()` используется вместе с шаблонными строками. Первый синтаксис, показанный выше, используется редко, поскольку движок JavaScript будет вызывать метод с соответствующими аргументами, подобно другим теговым функциям.

Метод `String.raw()` является единственной встроенной теговой функцией шаблонных строк, выступающей стандартной функцией по объединению их фрагментов. Вы и сами могли бы реализовать подобную функциональность на JavaScript.

Примеры
-------

### Пример: использование метода `String.raw()`

```js
String.raw`Привет\n${2 + 3}!`;
// 'Привет\n5!', символ после 'Привет' не является символом новой строки,
// '\' и 'n' - это два символа.

String.raw`Привет\u000A!`;
// 'Привет\u000A!', а здесь мы получим символы
// \, u, 0, 0, 0, A, всего 6 символов.
// Экранирующие символы не имеют особого значения и
// обратные слеши будут присутствовать в выходной строке.
// Вы можете убедиться в этом, проверив свойство .length строки.

let name = "Боб";
String.raw`Привет\n${name}!`;
// 'Привет\nБоб!', сработала подстановка.

// Обычно вам не нужно вызывать метод String.raw() как функцию,
// но никто не запрещает вам делать это:
String.raw({ raw: "тест" }, 0, 1, 2);
// 'т0е1с2т'
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.raw |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* Шаблонные строки
* `String`
* Лексическая грамматика


String.prototype.sup() - JavaScript

String.prototype.sup()
======================

**Устарело:** Эта возможность была удалена из веб-стандартов. Хотя некоторые браузеры по-прежнему могут поддерживать её, она находится в процессе удаления. Не используйте её ни в старых, ни в новых проектах. Страницы или веб-приложения, использующие её, могут в любой момент сломаться.

Сводка
------

Метод **`sup()`** создаёт HTML-элемент `<sup>` (en-US), заставляющий строку отображаться надстрочным текстом (верхним индексом).

Синтаксис
---------
```

str.sup()
```

Описание
--------

Метод `sup()` заключает строку в тег `<sup>`: `"<sup>str</sup>"`.

Примеры
-------

### Пример: использование методов `sub()` и `sup()`

В следующем примере для форматирования строки используются методы `sub()` и `sup()`:

```js
var superText = "надстрочный";
var subText = "подстрочный";

document.write("Вот так выглядит " + superText.sup() + " текст.");
document.write("Вот так выглядит " + subText.sub() + " текст.");
```

Этот пример генерирует такой же вывод, как и следующий HTML:

```html
Вот так выглядит <sup>надстрочный</sup> текст. Вот так выглядит
<sub>подстрочный</sub> текст.
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.sup |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.sub()`


String.prototype.fixed() - JavaScript

String.prototype.fixed()
========================

**Устарело:** Эта возможность была удалена из веб-стандартов. Хотя некоторые браузеры по-прежнему могут поддерживать её, она находится в процессе удаления. Не используйте её ни в старых, ни в новых проектах. Страницы или веб-приложения, использующие её, могут в любой момент сломаться.

Сводка
------

Метод **`fixed()`** создаёт HTML-элемент `<tt>` (en-US), заставляющий строку отображаться моноширинным шрифтом.

Синтаксис
---------
```

str.fixed()
```

Описание
--------

Метод `fixed()` заключает строку в тег `<tt>`: `"<tt>str</tt>"`.

Примеры
-------

### Пример: использование метода `fixed()`

В следующем примере для изменения форматирования строки используется метод `fixed()`:

```js
var worldString = "Привет, мир";

document.write(worldString.fixed());
```

Этот пример генерирует такой же вывод, как и следующий HTML:

```html
<tt>Привет, мир</tt>
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.fixed |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.bold()`
* `String.prototype.italics()`
* `String.prototype.strike()`


String.prototype.big() - JavaScript

String.prototype.big()
======================

**Устарело:** Эта возможность была удалена из веб-стандартов. Хотя некоторые браузеры по-прежнему могут поддерживать её, она находится в процессе удаления. Не используйте её ни в старых, ни в новых проектах. Страницы или веб-приложения, использующие её, могут в любой момент сломаться.

Сводка
------

Метод **`big()`** создаёт HTML-элемент `<big>` (en-US), заставляющий строку отображаться большим шрифтом.

**Примечание:** элемент <big> был удалён из HTML5 (en-US) и больше не должен использоваться. Вместо него веб-разработчикам следует использовать свойства CSS.

Синтаксис
---------
```

str.big()
```

Описание
--------

Метод `big()` заключает строку в тег `<big>`: `"<big>str</big>"`.

Примеры
-------

### Пример: использование метода `big()`

В следующем примере демонстрируется использование нескольких строковых методов для изменения размера строки:

```js
var worldString = "Привет, мир";

console.log(worldString.small()); // <small>Привет, мир</small>
console.log(worldString.big()); // <big>Привет, мир</big>
console.log(worldString.fontsize(7)); // <font size=7>Привет, мир</font>
```

При помощи объекта `element.style` (en-US) вы можете получить значение атрибута `style` элемента и управлять им более обобщённым способом, например:

```js
document.getElementById("yourElemId").style.fontSize = "2em";
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.big |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.fontsize()`
* `String.prototype.small()`


String.prototype.normalize() - JavaScript

String.prototype.normalize()
============================

Сводка
------

Метод **`normalize()`** возвращает форму нормализации Юникода данной строки (если значение не является строкой, сначала оно будет в неё преобразовано).

Одна из особенностей Юникода - возможность считать два разных символа эквивалентными при выполнении сортировки и иных операций, которые основаны на сравнении.

 Виды эквивалентности:
 - первый - каноническая эквивалентность, когда две последовательности code point являются полностью взаимозаменяемыми.

- второй - совместимость - две совместимые последовательности code point выглядят по-разному, но в некоторых случаях они могут быть взаимозаменяемыми.

'æ' взаимозаменяемый 'ae', но они не являются строго эквивалентными, если не провести некоторую нормализацию

Синтаксис
---------
```

str.normalize([form])
```

### Параметры

`form`

Одно из значений `"NFC"`, `"NFD"`, `"NFKC"` или `"NFKD"`, определяющих форму нормализации Юникода. Если параметр опущен или равен `undefined`, будет использоваться значение `"NFC"`.

* `NFC` — форма нормализации канонической композицией (Normalization Form Canonical Composition, 'NFC'), по умолчанию;
* `NFD` — форма нормализации канонической декомпозицией (Normalization Form Canonical Decomposition, 'NFD');
* `NFKC` — форма нормализации совместимой композицией (Normalization Form Compatibility Composition, 'NFKC');
* `NFKD` — форма нормализации совместимой декомпозицией (Normalization Form Compatibility Decomposition, 'NFKD').

### Выбрасываемые исключения

`RangeError`

Если параметр `form` не является одним из вышеперечисленных значений, будет выброшено исключение `RangeError`.

Описание
--------

Метод `normalize()` возвращает указанную форму нормализации Юникода строки. Он не изменяет значение самой строки.

Примеры
-------

### Пример: использование метода `normalize()`

```js
let valueStr = ["h", "ĥ", "æ", "ae", "g", "ġ"],
  normArr = valueStr.map(function (text) {
    return text.normalize(); // (по умолчанию 'NFC') normArr (после сортировки) -> [ae, g, h, æ, ġ, ĥ]
    //return text.normalize('NFD'); // normArr (после сортировки) -> [ae, g, ġ, h, ĥ, æ]
    //return text.normalize('NFKC'); // normArr (после сортировки) -> [ae, g, h, æ, ġ, ĥ]
    //return text.normalize('NFKD'); // normArr (после сортировки) -> [ae, g, ġ, h, ĥ, æ]
  });

//После приведение строк в нормальную форму, мы можем провести сортировку, массива:
normArr.sort(function (f, s) {
  if (f < s) {
    return -1;
  } else if (f === s) {
    return 0;
  } else {
    return 1;
  }
});

//Приведение к нормальной форме можно выполнить во время сортировки. Нормализацию при этом можно выполнять с помощью разных форм нормализации
let valueStrNorm = ["h", "s", "ĥ", "æ", "ș", "ae", "g", "ġ"];
valueStrNorm.sort(function (first, second) {
  let fN = first.normalize(),
    sN = second.normalize("NFKC");

  if (fN < sN) {
    return -1;
  } else if (fN === sN) {
    return 0;
  } else {
    return 1;
  }
});

valueStrNorm.join(", "); //-> ae, g, h, s, æ, ġ, ĥ, ș
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.normalize |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* Приложение №15 к стандарту Юникода: формы нормализации Юникода
* Эквивалентность в Юникоде


String.prototype.replace() - JavaScript

String.prototype.replace()
==========================

Сводка
------

Метод **`replace()`** возвращает новую строку с некоторыми или всеми сопоставлениями с шаблоном, заменёнными на заменитель. Шаблон может быть строкой или регулярным выражением, а заменитель может быть строкой или функцией, вызываемой при каждом сопоставлении.

Синтаксис
---------
```

str.replace(regexp|substr, newSubStr|function[, flags])
```

### Параметры

`regexp`

Объект регулярного выражения `RegExp`. Сопоставление заменяется возвращаемым значением второго параметра.

`substr`

Строка, заменяемая на `newSubStr`. Обратите внимание, будет заменено только первое вхождение искомой строки.

`newSubStr`

Строка, заменяющая подстроку из первого параметра. Поддерживает несколько специальных шаблонов замены; смотрите ниже раздел Передача строки в качестве второго параметра.

`function`

Функция, вызываемая для создания новой подстроки (помещаемой вместо подстроки из первого параметра). Аргументы, передаваемые функции, описаны ниже в разделе Передача функции в качестве второго параметра.

`flags`
Non-standard

**Обратите внимание: аргумент `flags` не работает в ядре v8 (движок JavaScript в Chrome и NodeJs).** Строка, задающая комбинацию флагов регулярного выражения. Параметр `flags` в методе `String.prototype.replace()` является нестандартным расширением. Вместо использования этого параметра используйте объект `RegExp` с соответствующими флагами. Значение этого параметра, если он используется, должно быть строкой, состоящей из одного или более следующих символов, следующим образом влияющих на обработку регулярного выражения:

`g`

глобальное сопоставление

`i`

игнорировать регистр

`m`

сопоставление по нескольким строкам

`y`
Экспериментальная возможность

«липкий» поиск, сопоставление начинается с текущей позиции в строке

### Возвращаемое значение

Новая строка с некоторыми или всеми сопоставлениями шаблона, заменёнными на заменитель.

Описание
--------

Этот метод не изменяет объект `String`, на котором он вызывается. Он просто возвращает новую строку.

Для выполнения глобального поиска и замены либо включите флаг `g` в регулярное выражение, либо, если первый параметр является строкой, включите флаг `g` в параметр `flags`.

### Передача строки в качестве второго параметра

строка замены может включать следующие специальные шаблоны замены:

| Шаблон | Замена |
| --- | --- |
| `$$` | Вставляет символ доллара «$». |
| `$&` | Вставляет сопоставившуюся подстроку. |
| `$`` | Вставляет часть строки, предшествующую сопоставившейся подстроке. |
| `$'` | Вставляет часть строки, следующую за сопоставившейся подстрокой. |
| `$n` или `$nn` | Символы `n` или `nn` являются десятичными цифрами, вставляет *n*-ную сопоставившуюся подгруппу из объекта `RegExp` в первом параметре. |

### Передача функции в качестве второго параметра

В качестве второго параметра вы можете передать функцию. В этом случае функция будет выполнена после произошедшего сопоставления. Результат вызова функции (её возвращаемое значение) будет использоваться в качестве строки замены (обратите внимание: описанные выше специальные шаблоны замены в этом случае *не* применяются). Обратите внимание, что функция будет вызвана несколько раз для каждого полного сопоставления, если регулярное выражение в первом параметре является глобальным.

Функция принимает следующие аргументы:

| Возможное имя | Получаемое значение |
| --- | --- |
| `match` | Сопоставившаяся подстрока (соответствует шаблону замены `$&`, описанному выше). |
| `p1, p2, ...` | *n*-ная сопоставившаяся подгруппа из объекта `RegExp` в первом параметре метода `replace()` (соответствует шаблонам замены `$1`, `$2` и так далее, описанным выше). Например, если в качестве шаблона передано регулярное выражение `/(\a+)(\b+)/`, параметр `p1` будет значение сопоставления с подгруппой `\a+`, а параметр `p2` — с подгруппой `\b+`. |
| `offset` | Смещение сопоставившейся подстроки внутри всей рассматриваемой строки (например, если вся строка равна `'abcd'`, а сопоставившаяся подстрока равна `'bc'`, то этот аргумент будет равен 1). |
| `string` | Вся рассматриваемая строка. |

Точное число аргументов будет зависеть от того, был ли первым аргументом объект `RegExp` и, если был, сколько подгрупп в нём определено.

Следующий пример установит переменную `newString` в значение `'abc - 12345 - #$*%'`:

```js
function replacer(match, p1, p2, p3, offset, string) {
  // p1 - не цифры, p2 - цифры, p3 - не буквы и не цифры
  return [p1, p2, p3].join(" - ");
}
var newString = "abc12345#$\*%".replace(/([^\d]\*)(\d\*)([^\w]\*)/, replacer);
```

Примеры
-------

### Пример: использование флагов `global` и `ignore` с методом `replace()`

В следующем примере регулярное выражение включает флаги для глобального поиска и игнорирования регистра, которые позволяют методу `replace()` заменить все вхождения слова «яблоки» в строке на слово «апельсины».

```js
var re = /яблоки/gi;
var str = "Яблоки круглые и яблоки сочные.";
var newstr = str.replace(re, "апельсины");
console.log(newstr); // апельсины круглые и апельсины сочные.
```

### Пример: передача регулярного выражения в метод `replace()`

В следующем примере в метод `replace()` передаётся регулярное выражение вместе с флагом игнорирования регистра.

```js
// Ночь перед Рождеством, Xmas - сокращение для Christmas
var str = "Twas the night before Xmas...";
var newstr = str.replace(/xmas/i, "Christmas");
console.log(newstr); // Twas the night before Christmas...
```

Пример выведет строку 'Twas the night before Christmas...'

### Пример: смена местами слов в строке

Следующий скрипт меняет местами слова в строке. В качестве текста замены он использует шаблоны замены `$1` и `$2`.

```js
var re = /([А-ЯЁа-яё]+)\s([А-ЯЁа-яё]+)/;
var str = "Джон Смит";
var newstr = str.replace(re, "$2, $1");
console.log(newstr); // Смит, Джон
```

Пример выведет строку 'Смит, Джон'.

### Пример: использование функции для изменения сопоставившихся символов

В этом примере все входящие в строку (латинские) буквы в верхнем регистре преобразуются в нижний регистр, а перед самой буквой вставляется дефис. Здесь важно то, что прежде чем элемент вставится в качестве замены, над ним нужно провести дополнительные преобразования.

Функция замены своим параметром принимает сопоставившийся кусок и перед возвратом использует его для преобразования регистра и соединения с дефисом.

```js
function styleHyphenFormat(propertyName) {
  function upperToHyphenLower(match) {
    return "-" + match.toLowerCase();
  }
  return propertyName.replace(/[A-Z]/g, upperToHyphenLower);
}
```

Вызов `styleHyphenFormat('borderTop')` вернёт строку 'border-top'.

Поскольку мы хотим провести дополнительные преобразования *результата* сопоставления до того, как будет использована окончательная подстановка, мы должны использовать функцию. Это заставляет нас принудительно вычислить сопоставление перед использование метода `toLowerCase()`. Если бы мы попытались использовать сопоставление без функции, метод `toLowerCase()` не сработал бы.

```js
var newString = propertyName.replace(/[A-Z]/g, "-" + "$&".toLowerCase()); // не работает
```

Происходит это потому, что сначала часть `'$&'.toLowerCase()` вычисляется в строковый литерал (результат по-прежнему равен `'$&'`), а только потом его символы используются в качестве шаблона.

### Пример: замена градусов по Фаренгейту на эквивалент в градусах по Цельсию

В следующем примере градусы по Фаренгейту заменяются на эквивалентные градусы по Цельсию. Градусы по Фаренгейту должны быть числом, оканчивающимся на букву F. Функция возвращает количество градусов по Цельсию, оканчивающиеся на букву C. Например, если входное число равняется 212F, функция вернёт 100C. Если число равняется 0F, функция вернёт -17.77777777777778C.

Регулярное выражение `test` сопоставляется с любым числом, оканчивающимся на букву F. Количество градусов по Фаренгейту передаётся в функцию через её второй параметр, `p1`. Функция переводит градусы по Фаренгейту, переданные в виде строки в функцию code>f2c(), в градусы по Цельсию. Затем функция `f2c()` возвращает количество градусов по Цельсию. Эта функция работает примерно так же, как и флаг `s///e` в Perl.

```js
function f2c(x) {
  function convert(str, p1, offset, s) {
    return ((p1 - 32) \* 5) / 9 + "C";
  }
  var s = String(x);
  var test = /(\d+(?:\.\d\*)?)F\b/g;
  return s.replace(test, convert);
}
```

### Пример: использование функции вместе с регулярным выражением для избавления от цикла `for`

Следующий пример принимает строку шаблона и преобразует её в массив объектов.

**Входные данные:**

Строка, состоящая из символов `x`, `-` и `_`
```

x-x_
x---x---x---x---
x-xxx-xx-x-
x_x_x___x___x___
```

**Выходные данные:**

Массив объектов. Символ `'x'` означает состояние `'on'`, символ `'-'` (дефис) означает состояние `'off'`, а символ `'_'` (нижнее подчёркивание) означает продолжительность состояния `'on'`.

```json
[
  { on: true, length: 1 },
  { on: false, length: 1 },
  { on: true, length: 2 }
  ...
]
```

**Код:**

```js
var str = "x-x\_";
var retArr = [];
str.replace(/(x\_\*)|(-)/g, function (match, p1, p2) {
  if (p1) {
    retArr.push({ on: true, length: p1.length });
  }
  if (p2) {
    retArr.push({ on: false, length: 1 });
  }
});

console.log(retArr);
```

Этот код сгенерирует массив из трёх объектов в описанном формате без использования цикла `for`.

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.replace |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.match()`
* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`


String.prototype.padEnd() - JavaScript

String.prototype.padEnd()
=========================

**Экспериментальная возможность:** **Это экспериментальная технология**
Так как спецификация этой технологии ещё не стабилизировалась, смотрите таблицу совместимости по поводу использования в различных браузерах. Также заметьте, что синтаксис и поведение экспериментальной технологии может измениться в будущих версиях браузеров, вслед за изменениями спецификации.

Метод **`padEnd()`** дополняет текущую строку с помощью заданной строки (в конечном счёте повторяя), так чтобы результирующая строка достигла заданной длины. Дополнение применяется в конце (справа) текущей строки.

Синтаксис
---------
```

str.padEnd(targetLength [, padString])
```

### Параметры

`targetLength`

Длина результирующей строки, после того как текущая строка была дополнена. Если этот параметр меньше длины текущей строки, то будет возвращена текущая строка , как она есть.

`padString` Необязательный

Строка для дополнения текущей строки с. Если эта строка слишком длинная, она будет урезана и будет применяться её левая большая часть. " " (U+0020) - значение по умолчанию для этого параметра.

### Возвращаемое значение

Строка указанной длинны дополненная с помощью дополнительной строки в конце текущей строки.

Примеры
-------

```js
"abc".padEnd(10); // "abc "
"abc".padEnd(10, "foo"); // "abcfoofoof"
"abc".padEnd(6, "123456"); // "abc123"
```

Характеристики
--------------

Этот метод ещё не достиг стандарта ECMAScript. Сейчас он в состоянии proposal for ECMAScript.

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.


String.prototype.split() - JavaScript

String.prototype.split()
========================

Сводка
------

Метод **`split()`** разбивает объект `String` на массив строк путём разделения строки указанной подстрокой.

Синтаксис
---------
```

str.split([separator[, limit]])
```

### Параметры

`separator`

Необязательный параметр. Указывает символы, используемые в качестве разделителя внутри строки. Параметр `separator` может быть как строкой, так и регулярным выражением. Если параметр опущен, возвращённый массив будет содержать один элемент со всей строкой. Если параметр равен пустой строке, строка `str` будет преобразована в массив символов.

`limit`

Необязательный параметр. Целое число, определяющее ограничение на количество найденных подстрок. Метод `split()` всё равно разделяет строку на каждом сопоставлении с разделителем `separator`, но обрезает возвращаемый массив так, чтобы он содержал не более `limit` элементов.

Описание
--------

Метод `split()` возвращает новый массив.

Если разделитель `separator` найден, он удаляется из строки, а подстроки возвращаются в массиве. Если разделитель опущен, массив будет содержать только один элемент, состоящий из всей строки. Если разделитель является пустой строкой, строка `str` будет преобразована в массив символов.

Если разделитель является регулярным выражением, содержащим подгруппы, то каждый раз при сопоставлении с разделителем, результаты (включая те, что не определены) захвата подгруппы будут помещаться внутрь выходного массива. Однако, не все браузеры поддерживают эту возможность.

**Примечание:** Если строка является пустой строкой, метод `split()` вернёт массив, состоящий из одной пустой строки, а не пустой массив.

Примеры
-------

### Пример: использование метода `split()`

В следующем примере определяется функция, которая разбивает строку на массив строк, используя указанный разделитель. После разбиения строки, функция отображает сообщения, показывающие оригинальную строку (до разбиения), используемый разделитель, количество элементов в массиве и сами эти элементы.

```js
function splitString(stringToSplit, separator) {
  var arrayOfStrings = stringToSplit.split(separator);

  console.log('Оригинальная строка: "' + stringToSplit + '"');
  console.log('Разделитель: "' + separator + '"');
  console.log(
    "Массив содержит " +
      arrayOfStrings.length +
      " элементов: " +
      arrayOfStrings.join(" / "),
  );
}

// Строчка из «Бури» Шекспира. Перевод Михаила Донского.
var tempestString = "И как хорош тот новый мир, где есть такие люди!";
var monthString = "Янв,Фев,Мар,Апр,Май,Июн,Июл,Авг,Сен,Окт,Ноя,Дек";

var space = " ";
var comma = ",";

splitString(tempestString, space);
splitString(tempestString);
splitString(monthString, comma);
```

Пример сгенерирует следующий вывод:
```

Оригинальная строка: "И как хорош тот новый мир, где есть такие люди!"
Разделитель: " "
Массив содержит 10 элементов: И / как / хорош / тот / новый / мир, / где / есть / такие / люди!

Оригинальная строка: "И как хорош тот новый мир, где есть такие люди!"
Разделитель: "undefined"
Массив содержит 1 элементов: И как хорош тот новый мир, где есть такие люди!

Оригинальная строка: "Янв,Фев,Мар,Апр,Май,Июн,Июл,Авг,Сен,Окт,Ноя,Дек"
Разделитель: ","
Массив содержит 12 элементов: Янв / Фев / Мар / Апр / Май / Июн / Июл / Авг / Сен / Окт / Ноя / Дек
```

### Пример: удаление пробелов из строки

В следующем примере метод `split()` ищет 0 или более пробелов, за которыми следует точка с запятой, за которой снова следуют 0 или более пробелов, и, если этот шаблон найден, удаляет пробелы из строки. Переменная `nameList` является массивом, возвращённым в результате работы метода `split()`.

```js
var names = "Гарри Трамп ;Фрэд Барни; Хелен Ригби ; Билл Абель ;Крис Ханд ";

console.log(names);

var re = /\s\*;\s\*/;
var nameList = names.split(re);

console.log(nameList);
```

Пример напечатает две строки; на первой строке напечатана оригинальная строчка, а на второй — получившийся массив.
```

Гарри Трамп ;Фред Барни; Хелен Ригби ; Билл Абель ;Крис Ханд
Гарри Трамп,Фред Барни,Хелен Ригби,Билл Абель,Крис Ханд
```

### Пример: возврат ограниченного числа подстрок

В следующем примере метод `split()` ищет 0 или более пробелов в строке и возвращает первые три найденных подстроки.

```js
var myString = "Привет, мир. Как дела?";
var splits = myString.split(" ", 3);

console.log(splits);
```

Вывод скрипта будет следующим:

```js
Привет,,мир.,Как
```

### Пример: захват подгрупп

Если параметр `separator` содержит подгруппы, сопоставившиеся результаты также будут присутствовать в возвращённом массиве.

```js
var myString = "Привет 1 мир. Предложение номер 2.";
var splits = myString.split(/(\d)/);

console.log(splits);
```

Вывод скрипта будет следующим:

```js
Привет ,1, мир. Предложение номер ,2,.
```

### Пример: обращение строки при помощи метода `split()`

```js
var str = "фывапролд";
var strReverse = str.split("").reverse().join(""); // 'длорпавыф'
// split() возвращает массив, к которому применяются методы reverse() и join()
```

**Бонус:** используя оператор `===` (en-US), можно проверить, являлась ли строка палиндромом.

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.split |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.charAt()`
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
* `Array.prototype.join()`


String.prototype.substring() - JavaScript

String.prototype.substring()
============================

Сводка
------

Метод **`substring()`** возвращает подстроку строки между двумя индексами, или от одного индекса и до конца строки.

Синтаксис
---------
```

str.substring(indexA[, indexB])
```

### Параметры

`indexA`

Целое число от `0` до длины строки, определяющее смещение в строке первого символа, который будет включён в результирующую подстроку.

`indexB`

Необязательный параметр. Целое число от `0` до длины строки, определяющее смещение в строке первого символа, который **не будет** включён в результирующую подстроку.

Описание
--------

Метод `substring()` извлекает символы, начиная с индекса `indexA` до, но не включая, индекс `indexB`. В частности:

* Если аргумент `indexA` равен аргументу `indexB`, метод `substring()` вернёт пустую строку.
* Если аргумент `indexB` опущен, метод `substring()` извлечёт символы до конца строки.
* Если любой из аргументов меньше, либо равен нулю или равен `NaN`, он будет трактоваться как равный 0.
* Если любой из аргументов больше, чем `stringName.length`, он будет трактоваться как равный `stringName.length`.

Если аргумент `indexA` будет больше аргумента `indexB`, то метод `substring()` сработает так, как если бы аргументы были поменяны местами; например, `str.substring(1, 0) == str.substring(0, 1)`.

Примеры
-------

### Пример: использование метода `substring()`

В следующем примере метод `substring()` используется для отображения символов из строки `'Mozilla'`:

```js
var anyString = "Mozilla";

// Отобразит 'Moz'
console.log(anyString.substring(0, 3));
console.log(anyString.substring(3, 0));

// Отобразит 'lla'
console.log(anyString.substring(4, 7));
console.log(anyString.substring(7, 4));

// Отобразит 'Mozill'
console.log(anyString.substring(0, 6));

// Отобразит 'Mozilla'
console.log(anyString.substring(0, 7));
console.log(anyString.substring(0, 10));
```

### Пример: использование метода `substring()` вместе со свойством `length`

Следующий пример использует метод `substring()` и свойство `length` для извлечения последних символов из строки. Этот метод может оказаться легче для запоминания, особенно если учесть, что вам не нужно знать начальный и конечный индексы, как это было в примере выше.

```js
// Отобразит 'illa' - последние 4 символа
var anyString = "Mozilla";
var anyString4 = anyString.substring(anyString.length - 4);
console.log(anyString4);

// Отобразит 'zilla' - последние 5 символов
var anyString = "Mozilla";
var anyString5 = anyString.substring(anyString.length - 5);
console.log(anyString5);
```

### Пример: замена подстроки в строке

Следующий пример демонстрирует замену подстроки в строке. Он заменит как отдельные символы, так и целые подстроки. Вызов функции в конце примера изменит строку `'Дивный новый мир'` на строку `'Дивный новый веб'`.

```js
// Заменяет oldS на newS в строке fullS
function replaceString(oldS, newS, fullS) {
  for (var i = 0; i < fullS.length; ++i) {
    if (fullS.substring(i, i + oldS.length) == oldS) {
      fullS =
        fullS.substring(0, i) +
        newS +
        fullS.substring(i + oldS.length, fullS.length);
    }
  }
  return fullS;
}

replaceString("мир", "веб", "Дивный новый мир");
```

Обратите внимание, что функция может скатиться в бесконечный цикл, если строка `oldS` сама является подстрокой для `newS` — например, если вы попытаетесь заменить слово «мир» на слово «другоймир». Лучше использоваться следующий метод для замены строк:

```js
function replaceString(oldS, newS, fullS) {
  return fullS.split(oldS).join(newS);
}
```

Код выше следует рассматривать всего лишь как пример работы с подстроками. Если вам нужно заменить подстроки, скорее всего вы захотите использовать метод `String.prototype.replace()`.

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.substring |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.substr()`
* `String.prototype.slice()`


String.prototype.includes() - JavaScript

String.prototype.includes()
===========================

Метод **`includes()`** проверяет, содержит ли строка заданную подстроку, и возвращает, соответственно `true` или `false`.

Синтаксис
---------
```

str.includes(searchString[, position])
```

### Параметры

`searchString`

Строка для поиска в данной строке.

`position` Необязательный

Позиция в строке, с которой начинать поиск строки `searchString`, по умолчанию 0.

### Возвращаемое значение

**`true`**, если искомая строка была найдена в данной строке; иначе **`false`**.

Описание
--------

Этот метод позволяет вам определять, содержит ли строка другую строку.

### Чувствительность к регистру символов

Метод `includes()` является регистрозависимым. Например, следующее выражение вернёт `false`:

```js
"Синий кит".includes("синий"); // вернёт false
```

Примеры
-------

### Использование `includes()`

```js
var str = "Быть или не быть вот в чём вопрос.";

console.log(str.includes("Быть")); // true
console.log(str.includes("вопрос")); // true
console.log(str.includes("несуществующий")); // false
console.log(str.includes("Быть", 1)); // false
console.log(str.includes("БЫТЬ")); // false
```

Полифил
-------

Этот метод был добавлен в спецификации ECMAScript 2015 и может быть недоступен в некоторых реализациях JavaScript. Однако, можно легко эмулировать этот метод:

```js
if (!String.prototype.includes) {
  String.prototype.includes = function (search, start) {
    "use strict";
    if (typeof start !== "number") {
      start = 0;
    }

    if (start + search.length > this.length) {
      return false;
    } else {
      return this.indexOf(search, start) !== -1;
    }
  };
}
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.includes |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

String.prototype.contains
-------------------------

В Firefox с версии 18 по версию 39, этот метод назывался «contains». Он был переименован в «includes» в замечании Firefox bug 1102219 по следующей причине:

Как было сообщено, некоторые сайты, использующие MooTools 1.2, ломаются в Firefox 17. Эта версия MooTools проверяет существование метода `String.prototype.contains()` и, если он не существует, добавляет свой собственный. С введением этого метода в Firefox 17, поведение этой проверки изменилось таким образом, что реализация `String.prototype.contains()`, основанная на MooTools, сломалась. В результате это изменение было отключено в Firefox 17. Метод `String.prototype.contains()` доступен в следующей версии Firefox — Firefox 18.

MooTools 1.3 принудительно использует свою собственную версию метода `String.prototype.contains()`, так что использующие его веб-сайты не должны ломаться. Тем не менее, следует отметить, что сигнатура метода в MooTools 1.3 отличается от сигнатуры метода в ECMAScript 2015 (во втором аргументе). В MooTools 1.5+ сигнатура изменена для соответствия стандарту ES2015.

В Firefox 48, метод `String.prototype.contains()` был удалён. Следует использовать только `String.prototype.includes()`.

Смотрите также
--------------

* `Array.prototype.includes()`
Экспериментальная возможность
* `TypedArray.prototype.includes()` (en-US)
Экспериментальная возможность
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
* `String.prototype.startsWith()`
* `String.prototype.endsWith()`


String.prototype.fontcolor() - JavaScript

String.prototype.fontcolor()
============================

**Устарело:** Эта возможность была удалена из веб-стандартов. Хотя некоторые браузеры по-прежнему могут поддерживать её, она находится в процессе удаления. Не используйте её ни в старых, ни в новых проектах. Страницы или веб-приложения, использующие её, могут в любой момент сломаться.

Сводка
------

Метод **`fontcolor()`** создаёт HTML-элемент `<font>`, заставляющий строку отображаться шрифтом указанного цвета.

**Примечание:** элемент <font> был удалён из HTML5 (en-US) и больше не должен использоваться. Вместо него веб-разработчикам следует использовать свойства CSS.

Синтаксис
---------
```

str.fontcolor(color)
```

### Параметры

`color`

Строка, выражающая цвет в виде шестнадцатеричного триплета RGB, либо в виде названия цвета. Названия цветов перечислены в справочнике по значению цвета в CSS.

Описание
--------

Если вы выразили цвет в виде шестнадцатеричного триплета RGB, вы должны использовать формат `rrggbb`. Например, шестнадцатеричные значения RGB для оранжево-розового цвета такие: красный=FA, зелёный=80 и синий=72, так что RGB-триплет для оранжево-розового цвета будет следующим `"FA8072"`.

Примеры
-------

### Пример: использование метода `fontcolor()`

В следующем примере метод `fontcolor()` используется для изменения цвета строки путём генерирования строки с HTML-тегом `<font>`.

```js
var worldString = "Привет, мир";

console.log(worldString.fontcolor("red") + " на этой строке красный");
// '<font color="red">Привет, мир</font> на этой строке красный'

console.log(
  worldString.fontcolor("FF00") +
    " на этой строке красный в шестнадцатеричной форме",
);
// '<font color="FF00">Привет, мир</font> на этой строке красный в шестнадцатеричной форме'
```

При помощи объекта `element.style` (en-US) вы можете получить значение атрибута `style` элемента и управлять им более обобщённым способом, например:

```js
document.getElementById("yourElemId").style.color = "red";
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.fontcolor |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.fontsize()`


String.prototype.endsWith() - JavaScript

String.prototype.endsWith()
===========================

Сводка
------

Метод **`endsWith()`** позволяет определить, заканчивается ли строка символами указанными в скобках, возвращая, соответственно, `true` или `false`.

Синтаксис
---------
```

str.endsWith(searchString[, length])
```

### Параметры

`searchString`

Символы, искомые в конце строки.

`length`

Необязательный параметр. Позволяет искать внутри строки, обрезая её по диапазону; по умолчанию равен длине строки.

### Возвращаемое значение

**`true`** если данные символы находятся в конце строки; в противном случае, **`false`**.

Описание
--------

Этот метод позволяет определять, заканчивается ли строка искомыми символами. Метод чувствителен к регистру.

Примеры
-------

### Пример: использование метода `endsWith()`

```js
var str = "Быть или не быть, вот в чём вопрос.";

console.log(str.endsWith("вопрос.")); // true
console.log(str.endsWith("быть")); // false
console.log(str.endsWith("быть", 16)); // true
```

Полифил
-------

Этот метод был добавлен к спецификации ECMAScript 6 и может быть доступен ещё не во всех реализациях JavaScript. Однако, вы можете легко эмулировать этот метод при помощи следующего кода:

```js
if (!String.prototype.endsWith) {
  Object.defineProperty(String.prototype, "endsWith", {
    value: function (searchString, position) {
      var subjectString = this.toString();
      if (position === undefined || position > subjectString.length) {
        position = subjectString.length;
      }
      position -= searchString.length;
      var lastIndex = subjectString.indexOf(searchString, position);
      return lastIndex !== -1 && lastIndex === position;
    },
  });
}
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.endswith |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.startsWith()`
Экспериментальная возможность
* `String.prototype.contains()`
Экспериментальная возможность
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`


String.prototype.matchAll() - JavaScript

String.prototype.matchAll()
===========================

Метод **`matchAll()`** возвращает итератор по всем результатам при сопоставлении *строки с регулярным выражением*.

Интерактивный пример
--------------------

Синтаксис
---------
```

str.matchAll(regexp)
```

### Параметры

`regexp`

Объект регулярного выражения. Если передано значение, не являющееся объектом регулярного выражения, оно неявно преобразуется в `RegExp` используя `new RegExp(obj)`.

### Возвращаемое значение

Возвращается iterator (не перезапускаемый).

Примеры
-------

### Regexp.exec() и matchAll()

До добавления метода `matchAll` в JavaScript, можно было использовать метод regexp.exec (и регулярные выражения с флагом `/g` ) в цикле для получения доступа к совпадениям:

```js
const regexp = RegExp("foo\*", "g");
const str = "table football, foosball";

while ((matches = regexp.exec(str)) !== null) {
  console.log(`Found ${matches[0]}. Next starts at ${regexp.lastIndex}.`);
  // expected output: "Found foo. Next starts at 9."
  // expected output: "Found foo. Next starts at 19."
}
```

 С появлением `matchAll`, нет необходимости использовать цикл `while` и метод `exec` с флагом `/g`.
 Используя вместо этого метод `matchAll`, вы получаете итератор, который вы можете использовать более удобно с конструкциями `for...of`, array spread, или `Array.from()` :

```js
const regexp = RegExp("foo\*", "g");
const str = "table football, foosball";
let matches = str.matchAll(regexp);

for (const match of matches) {
  console.log(match);
}
// Array [ "foo" ]
// Array [ "foo" ]

// итерация больше недоступна после вызова for of
// Для создания нового итератора вызовите matchAll повторно
matches = str.matchAll(regexp);

Array.from(matches, (m) => m[0]);
// Array [ "foo", "foo" ]
```

### Улучшенный доступ к группам захвата

Ещё одна веская причина использовать `matchAll` это улучшенный доступ к группам захвата. Группы захвата игнорируются при использовании `match()` с глобальным флагом `/g`:

```js
var regexp = /t(e)(st(\d?))/g;
var str = "test1test2";

str.match(regexp);
// Array ['test1', 'test2']
```

С `matchAll` у вас появляется к ним доступ:

```js
let array = [...str.matchAll(regexp)];

array[0];
// ['test1', 'e', 'st1', '1', index: 0, input: 'test1test2', length: 4]
array[1];
// ['test2', 'e', 'st2', '2', index: 5, input: 'test1test2', length: 4]
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.matchall |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `RegExp`
* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`


String.prototype.valueOf() - JavaScript

String.prototype.valueOf()
==========================

Сводка
------

Метод **`valueOf()`** возвращает примитивное значение объекта `String`.

Синтаксис
---------
```

str.valueOf()
```

Описание
--------

Метод `valueOf()` возвращает примитивное значение объекта `String` в виде строкового типа данных. Это значение эквивалентно значению вызова метода `String.prototype.toString()`.

Этот метод обычно вызывается внутренними механизмами движка JavaScript, а не явно в коде.

Примеры
-------

### Пример: использование метода `valueOf()`

```js
var x = new String("Привет, мир");
console.log(x.valueOf()); // Отобразит 'Привет, мир'
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.valueof |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.toString()`
* `Object.prototype.valueOf()`


String.prototype.repeat() - JavaScript

String.prototype.repeat()
=========================

Метод **`repeat()`** конструирует и возвращает новую строку, содержащую указанное количество соединённых вместе копий строки, на которой он был вызван.Синтаксис
---------
```

str.repeat(count)
```

### Параметры

`count`

Целое число от 0 до +∞: [0, +∞), определяющее число повторений строки во вновь создаваемой и возвращаемой строке.

### Возвращаемое значение

Новая строка, содержащая указанное количество копий строки, для которой был вызван метод.

### Исключения

* `RangeError`: число повторений не должно быть отрицательным.
* `RangeError`: число повторений должно быть меньше бесконечности и не должно превышать максимально допустимую длину строки.

Примеры
-------

```js
"абв".repeat(-1); // RangeError
"абв".repeat(0); // ''
"абв".repeat(1); // 'абв'
"абв".repeat(2); // 'абвабв'
"абв".repeat(3.5); // 'абвабвабв' (количество будет преобразовано в целое число)
"абв".repeat(1 / 0); // RangeError

({ toString: () => "абв", repeat: String.prototype.repeat }).repeat(2);
// 'абвабв' (метод repeat() является обобщённым методом)
```

Полифил
-------

Этот метод был добавлен к спецификации ECMAScript 2015 и может быть доступен ещё не во всех реализациях JavaScript. Однако, вы можете легко эмулировать этот метод при помощи следующего кода:

```js
if (!String.prototype.repeat) {
  String.prototype.repeat = function (count) {
    "use strict";
    if (this == null) {
      throw new TypeError("can't convert " + this + " to object");
    }
    var str = "" + this;
    count = +count;
    if (count != count) {
      count = 0;
    }
    if (count < 0) {
      throw new RangeError("repeat count must be non-negative");
    }
    if (count == Infinity) {
      throw new RangeError("repeat count must be less than infinity");
    }
    count = Math.floor(count);
    if (str.length == 0 || count == 0) {
      return "";
    }
    // Обеспечение того, что count является 31-битным целым числом, позволяет нам значительно
    // соптимизировать главную часть функции. Впрочем, большинство современных (на август
    // 2014 года) браузеров не обрабатывают строки, длиннее 1 << 28 символов, так что:
    if (str.length \* count >= 1 << 28) {
      throw new RangeError(
        "repeat count must not overflow maximum string size",
      );
    }
    var rpt = "";
    for (var i = 0; i < count; i++) {
      rpt += str;
    }
    return rpt;
  };
}
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.repeat |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.


String.prototype.lastIndexOf() - JavaScript

String.prototype.lastIndexOf()
==============================

Сводка
------

Метод **`lastIndexOf()`** возвращает индекс последнего вхождения указанного значения в строковый объект `String`, на котором он был вызван, или -1, если ничего не было найдено. Поиск по строке ведётся от конца к началу, начиная с индекса `fromIndex`.

Синтаксис
---------
```

str.lastIndexOf(searchValue[, fromIndex])
```

### Параметры

`searchValue`

Строка, представляющая искомое значение.

`fromIndex`

Необязательный параметр. Местоположение внутри строки, откуда начинать поиск, нумерация индексов идёт слева направо. Может быть любым целым числом. Значение по умолчанию установлено в `str.length`. Если оно отрицательно, трактуется как 0. Если `fromIndex > str.length`, параметр `fromIndex` будет трактоваться как `str.length`.

Описание
--------

Символы в строке идут слева направо. Индекс первого символа равен 0, а последнего символа в строке `stringName` равен `stringName.length - 1`.

```js
"канал".lastIndexOf("а"); // вернёт 3
"канал".lastIndexOf("а", 2); // вернёт 1
"канал".lastIndexOf("а", 0); // вернёт -1
"канал".lastIndexOf("ч"); // вернёт -1
```

### Регистрозависимость

Метод `lastIndexOf()` является регистрозависимым. Например, следующее выражение вернёт -1:

```js
"Синий кит, касатка".lastIndexOf("синий"); // вернёт -1
```

Примеры
-------

### Пример: использование методов `indexOf()` и `lastIndexOf()`

В следующем примере используются методы `indexOf()` и `lastIndexOf()` для нахождения значений в строке `"Дивный новый мир"`.

```js
var anyString = "Дивный новый мир";

console.log(
  "Индекс первого вхождения «й» с начала строки равен " +
    anyString.indexOf("й"),
);
// Отобразит 5
console.log(
  "Индекс первого вхождения «й» с конца строки равен " +
    anyString.lastIndexOf("й"),
);
// Отобразит 11

console.log(
  "Индекс вхождения «новый» с начала строки равен " +
    anyString.indexOf("новый"),
);
// Отобразит 7
console.log(
  "Индекс вхождения «новый» с конца строки равен " +
    anyString.lastIndexOf("новый"),
);
// Отобразит 7
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.lastindexof |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.charAt()`
* `String.prototype.indexOf()`
* `String.prototype.split()`
* `Array.prototype.indexOf()`
* `Array.prototype.lastIndexOf()`


String.fromCharCode() - JavaScript

String.fromCharCode()
=====================

Сводка
------

Статический метод **`String.fromCharCode()`** возвращает строку, созданную из указанной последовательности значений единиц кода UTF-16.

.

Синтаксис
---------
```

String.fromCharCode(num1[, ...[, numN]])
```

### Параметры

`num1, ..., numN`

Последовательность чисел, являющихся значениями единиц кода UTF-16. Диапазон составляет от 0 до 65535 (0xFFFF). Числа больше 0xFFFF усекаются. Проверка достоверности не производится.

Описание
--------

Этот метод возвращает примитивную строку, а не объект `String`.

Поскольку метод `fromCharCode()` является статическим методом объекта `String`, вы всегда должны использовать его как `String.fromCharCode()`, а не как метод созданного вами экземпляра `String`.

Примеры
-------

### Пример: использование метода `fromCharCode()`

Следующий пример вернёт строку "ABC".

```js
String.fromCharCode(65, 66, 67); // "ABC"
```

Полная таблица UTF-16

Как заставить его работать с большими значениями
------------------------------------------------

Хотя большинство распространённых значений Юникода может быть представлено одним 16-битным числом (как ожидалось на ранней стадии стандартизации JavaScript) и метод `fromCharCode()` может использоваться для возврата одного символа для самых распространённых значений (точнее, значений UCS-2, которые являются подмножеством самых распространённых символов UTF-16), для работы со ВСЕМИ допустимыми значениями Юникода (занимающими до 21 бита) одного метода `fromCharCode()` недостаточно. Поскольку большие кодовые точки используют (самое меньшее) два «суррогатных» числа для представления одного символа, для возврата таких пар можно использовать метод `String.fromCodePoint()` (являющийся частью черновика ES6) и, таким образом, адекватно представлять эти символы.

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.fromcharcode |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.fromCodePoint()`
* `String.prototype.charAt()`
* `String.prototype.charCodeAt()`
* `String.prototype.codePointAt()`


String.prototype.toLowerCase() - JavaScript

String.prototype.toLowerCase()
==============================

Сводка
------

Метод **`toLowerCase()`** возвращает значение строки, на которой он был вызван, преобразованное в нижний регистр.

Синтаксис
---------
```

str.toLowerCase()
```

Описание
--------

Метод `toLowerCase()` возвращает значение строки, преобразованное в нижний регистр. Метод `toLowerCase()` не изменяет значение самой строки.

Примеры
-------

### Пример: использование метода `toLowerCase()`

```js
console.log("АЛФАВИТ".toLowerCase()); // 'алфавит'
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.tolowercase |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.toLocaleLowerCase()`
* `String.prototype.toLocaleUpperCase()`
* `String.prototype.toUpperCase()`


RegExp.prototype[@@split]() - JavaScript

RegExp.prototype[@@split]()
===========================

**`[@@split]()`** метод делит объект `String` в массив строк, путём разбиения строки на подстроки.

Интерактивный пример
--------------------

Синтаксис
---------
```

regexp[Symbol.split](str[, limit])
```

### Параметры

`str`

Цель разбиения.

`limit`

Необязательное. Целое число ограничивающее кол-во разбиений. `[@@split]()` метод разбивает все совпадения `this` RegExp шаблона, до тех пор пока не достигнет числа `limit` или строка будет короче `this` шаблона.

### Возвращаемое значение

`Array` содержит подстроки как элементы.

Описание
--------

Этот метод вызывает `String.prototype.split()`, если аргумент `separator` объект `RegExp`. Для примера, два данных выражения возвращают одинаковый результат.

```js
"a-b-c".split(/-/);

/-/[Symbol.split]("a-b-c");
```

Этот метод существует для кастомизации поведения (разбиения) подкласса `RegExp`.

Если аргумент `str` **не** объект типа `RegExp`, метод `String.prototype.split()` не вызывается, так же не создаётся объект типа `RegExp`.

Примеры
-------

### Прямой вызов

Этот метод может быть использован, так же как `String.prototype.split()`, кроме случаев когда `this` отличаются и аргументы идут в разном порядке.

```js
var re = /-/g;
var str = "2016-01-02";
var result = re[Symbol.split](str);
console.log(result); // ["2016", "01", "02"]
```

### Использование `@@split` в подклассах

Подклассы `RegExp` могут переопределить `[@@split]()` для изменения стандартного поведения.

```js
class MyRegExp extends RegExp {
  [Symbol.split](str, limit) {
    var result = RegExp.prototype[Symbol.split].call(this, str, limit);
    return result.map((x) => "(" + x + ")");
  }
}

var re = new MyRegExp("-");
var str = "2016-01-02";
var result = str.split(re); // String.prototype.split calls re[@@split].
console.log(result); // ["(2016)", "(01)", "(02)"]
```

Specifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype-@@split |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

See also
--------

* `String.prototype.split()`
* `RegExp.prototype[@@match]()` (en-US)
* `RegExp.prototype[@@replace]()` (en-US)
* `RegExp.prototype[@@search]()`
* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`


RegExp.prototype.toString() - JavaScript

RegExp.prototype.toString()
===========================

Сводка
------

Метод **`toString()`** возвращает строковое представление регулярного выражения.

Синтаксис
---------
```

regexObj.toString()
```

### Параметры

Нет.

Описание
--------

Объект `RegExp` переопределяет метод `toString()` объекта `Object`; он не наследует метод `Object.prototype.toString()`. Для объектов `RegExp`, метод `toString()` возвращает строковое представление регулярного выражения.

Примеры
-------

### Пример: использование метода `toString()`

Следующий пример отображает строковое значение объекта `RegExp`:

```js
var myExp = new RegExp("a+b+c");
console.log(myExp.toString()); // отобразит '/a+b+c/'

var foo = new RegExp("bar", "g");
console.log(foo.toString()); // отобразит '/bar/g'
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype.tostring |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Object.prototype.toString()`


RegExp.prototype[@@search]() - JavaScript

RegExp.prototype[@@search]()
============================

Метод **`[@@search]()`** выполняет поиск совпадения между регулярным выражением `this` и строкой.

Синтаксис
---------
```

regexp[Symbol.search](str)
```

### Параметры

`str`

`String`, являющийся объектом поиска.

### Возвращаемое значение

integer

В случае успеха, `[@@search]()` вернёт индекс первого совпадения регулярного выражения внутри строки. В противном случае, он вернёт -1.

Описание
--------

Этот метод вызывается внутреннее в `String.prototype.search()`. Например, два следующих примера вернут один и тот же результат.

```js
"abc".search(/a/);

/a/[Symbol.search]("abc");
```

Этот метод существует для настройки поведения поиска в подклассах `RegExp`.

Примеры
-------

### Прямой вызов

Этот метод можно использовать почти так же, как `String.prototype.search()`, за исключением другого `this` и другого порядка аргументов.

```js
var re = /-/g;
var str = "2016-01-02";
var result = re[Symbol.search](str);
console.log(result); // 4
```

### Используя `@@search` в подклассах

Подкласс `RegExp` может быть перезаписан с помощью метода `[@@search]()` для изменения поведения.

```js
class MyRegExp extends RegExp {
  constructor(str) {
    super(str);
    this.pattern = str;
  }
  [Symbol.search](str) {
    return str.indexOf(this.pattern);
  }
}

var re = new MyRegExp("a+b");
var str = "ab a+b";
var result = str.search(re); // String.prototype.search calls re[@@search].
console.log(result); // 3
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype-@@search |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `String.prototype.search()`
* `RegExp.prototype[@@match]()` (en-US)
* `RegExp.prototype[@@replace]()` (en-US)
* `RegExp.prototype[@@split]()`
* `RegExp.prototype.exec()`
* `RegExp.prototype.test()`


RegExp.prototype.flags - JavaScript

RegExp.prototype.flags
======================

Сводка
------

Свойство **`flags`** возвращает строку, состоящую из флагов текущего регулярного выражения.

Описание
--------

Флаги в свойстве `flags` упорядочены по алфавиту (слева направо, то есть `"gimuy"`).

Примеры
-------

### Пример: использование свойства `flags`

```js
/foo/gi.flags; // "gi"
/bar/muy.flags; // "muy"
```

Полифил
-------

```js
if (RegExp.prototype.flags === undefined) {
  Object.defineProperty(RegExp.prototype, "flags", {
    configurable: true,
    get: function () {
      return this.toString().match(/[gimuy]\*$/)[0];
    },
  });
}
```

Спецификации
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.flags |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `RegExp.prototype.source`