Работа со строками в javascript

str.replace(str|regexp, str|func)

Это универсальный метод поиска-и-замены, один из самых полезных. Этакий швейцарский армейский нож для поиска и замены в строке.

Мы можем использовать его и без регулярных выражений, для поиска-и-замены подстроки:

Хотя есть подводный камень.

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

Вы можете видеть это в приведённом выше примере: только первый заменяется на .

Чтобы найти все дефисы, нам нужно использовать не строку , а регулярное выражение с обязательным флагом :

Второй аргумент – строка замены. Мы можем использовать специальные символы в нем:

Спецсимволы	Действие в строке замены
	вставляет
	вставляет всё найденное совпадение
	вставляет часть строки до совпадения
	вставляет часть строки после совпадения
	если это 1-2 значное число, то вставляет содержимое n-й скобки
	вставляет содержимое скобки с указанным именем

Например:

Для ситуаций, которые требуют «умных» замен, вторым аргументом может быть функция.

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

Функция вызывается с аргументами :

1. – найденное совпадение,
2. – содержимое скобок (см. главу Скобочные группы).
3. – позиция, на которой найдено совпадение,
4. – исходная строка,
5. – объект с содержимым именованных скобок (см. главу Скобочные группы).

Если скобок в регулярном выражении нет, то будет только 3 аргумента: .

Например, переведём выбранные совпадения в верхний регистр:

Заменим каждое совпадение на его позицию в строке:

В примере ниже две скобки, поэтому функция замены вызывается с 5-ю аргументами: первый – всё совпадение, затем два аргумента содержимое скобок, затем (в примере не используются) индекс совпадения и исходная строка:

Если в регулярном выражении много скобочных групп, то бывает удобно использовать остаточные аргументы для обращения к ним:

Или, если мы используем именованные группы, то объект с ними всегда идёт последним, так что можно получить его так:

Использование функции даёт нам максимальные возможности по замене, потому что функция получает всю информацию о совпадении, имеет доступ к внешним переменным и может делать всё что угодно.

Сравнение строк в JavaScript

Строки в JS сравниваются посимвольно в алфавитном порядке.

Особенности посимвольного сравнения строк в JS:

1. Символы сравниваются по их кодам (больший код — больший символ, все строчные буквы идут после (правее) заглавных, так как их коды больше (‘a’ > ‘Z’  // 97>65 true) ;
2. Буквы, имеющие диакритические знаки, идут «не по порядку» ( ‘Österreich’ > ‘Zealand’ );

Для получения символа по его коду (и наоборот) используется методы:

• codePointAt(pos), который возвращает код Unicode для символа, находящегося на позиции pos;
• charCodeAt(pos), который возвращает числовое значение Unicode UTF-16 для символа по указанному индексу (за исключением кодовых точек Unicode, больших 0x10000).
• String.fromCodePoint(code) — создаёт символ по его коду code

JavaScript

// одна и та же буква в нижнем и верхнем регистре будет иметь разные коды
alert( «z».codePointAt(0) ); // 122
alert( «Z».codePointAt(0) ); // 90

// Создание символа по его коду code
alert( String.fromCodePoint(90) ); // Z

// Добавление юникодного символа по коду, используя спецсимвол \u
alert( ‘\u005a’ ); // Z

1 2 3 4 5 6 7 8 9

// одна и та же буква в нижнем и верхнем регистре будет иметь разные коды alert(«z».codePointAt());// 122 alert(«Z».codePointAt());// 90   // Создание символа по его коду code alert(String.fromCodePoint(90));// Z   // Добавление юникодного символа по коду, используя спецсимвол \u alert(‘\u005a’);// Z

Выведем строку, содержащую символы с кодами от 65 до 90 — это латиница (символы заглавных букв):

JavaScript

let str_1 = «»;

for (let i = 65; i <= 90; i++) {
  str_1 += String.fromCodePoint(i);
}
console.log(str_1); // ABCDEFGHIJKLMNOPQRSTUVWXYZ

1 2 3 4 5 6

let str_1 = «»; for (let i = 65; i <= 90; i++) {   str_1 += String.fromCodePoint(i); } console.log(str_1);// ABCDEFGHIJKLMNOPQRSTUVWXYZ

Правильное сравнение строк (метод str1.localeCompare(str2))

Вызов метода str1.localeCompare(str2) возвращает число, которое показывает, какая строка больше в соответствии с правилами языка:

• Отрицательное число, если str1 меньше str2.
• Положительное число, если str1 больше str2.
• 0, если строки равны.

JavaScript

let str_1 = ‘Alex’.localeCompare(‘NAV’);
console.log(str_1); // -1
let str_2 = ‘Alex’.localeCompare(‘Alex’);
console.log(str_2); // 0

1 2 3 4

let str_1=’Alex’.localeCompare(‘NAV’); console.log(str_1);// -1 let str_2=’Alex’.localeCompare(‘Alex’); console.log(str_2);// 0

regexp.exec(str)

Метод ищет совпадение с в строке . В отличие от предыдущих методов, вызывается на регулярном выражении, а не на строке.

Он ведёт себя по-разному в зависимости от того, имеет ли регулярное выражение флаг .

Если нет , то возвращает первое совпадение в точности как . Такое поведение не даёт нам ничего нового.

Но если есть , то:

• Вызов возвращает первое совпадение и запоминает позицию после него в свойстве .
• Следующий такой вызов начинает поиск с позиции , возвращает следующее совпадение и запоминает позицию после него в .
• …И так далее.
• Если совпадений больше нет, то возвращает , а для устанавливается значение .

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

В прошлом, до появления метода в JavaScript, вызов в цикле использовали для получения всех совпадений с их позициями и группами скобок в цикле:

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

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

Например:

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

В примере выше заменим флаг на . Ничего найдено не будет, поскольку именно на позиции слова нет:

Это удобно в тех ситуациях, когда мы хотим «прочитать» что-то из строки по регулярному выражению именно на конкретной позиции, а не где-то далее.

JS Учебник

JS ГлавнаяJS ВведениеJS Что? Где? Куда?JS ВыводJS ЗаявленияJS СинтаксисJS КомментарииJS ПеременныеJS ОператорыJS АрифметикаJS ПрисваиванияJS Типы данныхJS ФункцииJS ОбъектыJS СобытияJS СтрокиJS Методы строкJS ЧислаJS Методы чиселJS МассивыJS Методы массиваJS Сортировка массиваJS Итерация массиваJS Объекты датJS Формат датJS Метод получения датJS Метод набора датJS Математические…JS Случайные числаJS БулевыJS Сравнение…JS Заявления if…elseJS Заявление switchJS Цикл forJS Цикл whileJS Заявление break…JS Преобразование…JS Битовые…JS Регулярные выраженияJS ОшибкиJS ОбластьJS ПодъемныйJS СтрогийJS Ключевое слово thisJS Ключевое слово letJS КонстантыJS Функция стрелкиJS КлассыJS ОтладчикJS Руководство стиляJS ПрактикаJS Распространенные ошибкиJS ЭффективностьJS Зарезервированные словаJS ВерсииJS Версия ES5JS Версия ES6JS Версия 2016JS Версия 2017JS JSON

JavaScript

JS Array
concat()
constructor
copyWithin()
entries()
every()
fill()
filter()
find()
findIndex()
forEach()
from()
includes()
indexOf()
isArray()
join()
keys()
length
lastIndexOf()
map()
pop()
prototype
push()
reduce()
reduceRight()
reverse()
shift()
slice()
some()
sort()
splice()
toString()
unshift()
valueOf()

JS Boolean
constructor
prototype
toString()
valueOf()

JS Classes
constructor()
extends
static
super

JS Date
constructor
getDate()
getDay()
getFullYear()
getHours()
getMilliseconds()
getMinutes()
getMonth()
getSeconds()
getTime()
getTimezoneOffset()
getUTCDate()
getUTCDay()
getUTCFullYear()
getUTCHours()
getUTCMilliseconds()
getUTCMinutes()
getUTCMonth()
getUTCSeconds()
now()
parse()
prototype
setDate()
setFullYear()
setHours()
setMilliseconds()
setMinutes()
setMonth()
setSeconds()
setTime()
setUTCDate()
setUTCFullYear()
setUTCHours()
setUTCMilliseconds()
setUTCMinutes()
setUTCMonth()
setUTCSeconds()
toDateString()
toISOString()
toJSON()
toLocaleDateString()
toLocaleTimeString()
toLocaleString()
toString()
toTimeString()
toUTCString()
UTC()
valueOf()

JS Error
name
message

JS Global
decodeURI()
decodeURIComponent()
encodeURI()
encodeURIComponent()
escape()
eval()
Infinity
isFinite()
isNaN()
NaN
Number()
parseFloat()
parseInt()
String()
undefined
unescape()

JS JSON
parse()
stringify()

JS Math
abs()
acos()
acosh()
asin()
asinh()
atan()
atan2()
atanh()
cbrt()
ceil()
clz32()
cos()
cosh()
E
exp()
expm1()
floor()
fround()
LN2
LN10
log()
log10()
log1p()
log2()
LOG2E
LOG10E
max()
min()
PI
pow()
random()
round()
sign()
sin()
sqrt()
SQRT1_2
SQRT2
tan()
tanh()
trunc()

JS Number
constructor
isFinite()
isInteger()
isNaN()
isSafeInteger()
MAX_VALUE
MIN_VALUE
NEGATIVE_INFINITY
NaN
POSITIVE_INFINITY
prototype
toExponential()
toFixed()
toLocaleString()
toPrecision()
toString()
valueOf()

JS OperatorsJS RegExp
constructor
compile()
exec()
g
global
i
ignoreCase
lastIndex
m
multiline
n+
n*
n?
n{X}
n{X,Y}
n{X,}
n$
^n
?=n
?!n
source
test()
toString()

(x|y)
.
\w
\W
\d
\D
\s
\S
\b
\B
\0
\n
\f
\r
\t
\v
\xxx
\xdd
\uxxxx

JS Statements
break
class
continue
debugger
do…while
for
for…in
for…of
function
if…else
return
switch
throw
try…catch
var
while

JS String
charAt()
charCodeAt()
concat()
constructor
endsWith()
fromCharCode()
includes()
indexOf()
lastIndexOf()
length
localeCompare()
match()
prototype
repeat()
replace()
search()
slice()
split()
startsWith()
substr()
substring()
toLocaleLowerCase()
toLocaleUpperCase()
toLowerCase()
toString()
toUpperCase()
trim()
valueOf()

Свойства строки JS

Свойство length (длина строки)

Свойство length содержит длину строки:

JavaScript

const firstName = «Alex»;
const lastName = «NAV»;
let value = firstName + » » + lastName; // ‘Alex NAV’
value = value.length; // 8 (длина строки посимвольно, с пробелами)
alert( `My\n`.length ); // 3 (длина строки посимвольно, с учетом спецсимвола \n)

1 2 3 4 5

constfirstName=»Alex»; constlastName=»NAV»; let value=firstName+» «+lastName;// ‘Alex NAV’ value=value.length;// 8 (длина строки посимвольно, с пробелами) alert(`My\n`.length);// 3 (длина строки посимвольно, с учетом спецсимвола \n)

Так как length— это числовое свойство, а не функция, то добавлять скобки не нужно.

Конкатенация строк в JavaScript

Конкатенация (объединение) строк в JS возможно двумя способами:

1. с использованием оператора «+«;
2. с использованием метода concat.

JavaScript

const firstName = «Alex»;
const lastName = «NAV»;
const age = 30;

let value;

value = firstName + » » + lastName; // Alex NAV (конкатенация бинарным «+»)
value += » My age » + age; // Alex NAV My age 30 (конкатенация бинарным «+»)

value = lastName.concat(» «, firstName); // NAV Alex (конкатенация методом concat)

1 2 3 4 5 6 7 8 9 10

constfirstName=»Alex»; constlastName=»NAV»; constage=30; let value; value=firstName+» «+lastName;// Alex NAV (конкатенация бинарным «+») value+=» My age «+age;// Alex NAV My age 30 (конкатенация бинарным «+») value=lastName.concat(» «,firstName);// NAV Alex (конкатенация методом concat)

Замена содержимого строки

Метод заменяет указанное значение с другим значением в строке:

Пример

str = «Пожалуйста, посетите Microsoft!»;
var n = str.replace(«Microsoft», «Schoolsw3»);

Метод не изменяет строку она вызвана. Он возвращает новую строку.

По умолчанию метод заменяет только первое совпадение:

Пример

str = «Пожалуйста, посетите Microsoft и Microsoft!»;
var n = str.replace(«Microsoft», «Schoolsw3»);

По умолчанию метод чувствителен к регистру.
Записать MICROSOFT (в верхнем регистре) не получится:

Пример

str = «Пожалуйста, посетите Microsoft!»;
var n = str.replace(«MICROSOFT», «Schoolsw3»);

Чтобы заменить нечувствительность к регистру, используйте регулярное выражение
с флагом (нечувствительность):

Пример

str = «Пожалуйста, посетите Microsoft!»;
var n = str.replace(/MICROSOFT/i, «Schoolsw3»);

Обратите внимание, что регулярные выражения пишутся без кавычек. Чтобы заменить все совпадения, используйте регулярное выражение
с флагом (глобальное совпадение):

Чтобы заменить все совпадения, используйте регулярное выражение
с флагом (глобальное совпадение):

Пример

str = «Пожалуйста, посетите Microsoft и Microsoft!»;
var n = str.replace(/Microsoft/g, «Schoolsw3»);

Вы узнаете намного больше о регулярных выражениях в главе Регулярные выражения JavaScript.

Доступ к символам

Продемонстрируем, как получить доступ к символам и индексам строки How are you?

"How are you?";

Используя квадратные скобки, можно получить доступ к любому символу строки.

"How are you?";

Вывод

r

Мы также можем использовать метод charAt(), чтобы вернуть символ, передавая индекс в качестве параметра.

"Howareyou?".charAt(5);

Вывод

r

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

"How are you?".indexOf("o");

Вывод

1

Несмотря на то, что символ «o» появляется в строке How are you? дважды, indexOf() вернёт позицию первого вхождения.

lastIndexOf() используется, чтобы найти последнее вхождение.

"How are you?".lastIndexOf("o");

Вывод

9

Оба метода также можно использовать для поиска нескольких символов в строке. Они вернут индекс первого символа.

"How are you?".indexOf("are");

Вывод

4

А вот метод slice() вернёт символы между двумя индексами.

"How are you?".slice(8, 11);

Вывод

you

Обратите внимание на то, что 11– это ?, но? не входит в результирующую строку. slice() вернёт всё, что между указанными значениями индекса

Если второй параметр опускается, slice() вернёт всё, начиная от первого параметра до конца строки.

"How are you?".slice(8);

Вывод

you?

Методы charAt() и slice() помогут получить строковые значения на основании индекса. А indexOf() и lastIndexOf() делают противоположное, возвращая индексы на основании переданной им строки.

Улучшена поддержка юникода

Внутренняя кодировка строк в JavaScript – это UTF-16, то есть под каждый символ отводится ровно два байта.

Но под всевозможные символы всех языков мира 2 байт не хватает. Поэтому бывает так, что одному символу языка соответствует два юникодных символа (итого 4 байта). Такое сочетание называют «суррогатной парой».

Самый частый пример суррогатной пары, который можно встретить в литературе – это китайские иероглифы.

Заметим, однако, что не всякий китайский иероглиф – суррогатная пара. Существенная часть «основного» юникод-диапазона как раз отдана под китайский язык, поэтому некоторые иероглифы – которые в неё «влезли» – представляются одним юникод-символом, а те, которые не поместились (реже используемые) – двумя.

Например:

В тексте выше для первого иероглифа есть отдельный юникод-символ, и поэтому длина строки , а для второго используется суррогатная пара. Соответственно, длина – .

Китайскими иероглифами суррогатные пары, естественно, не ограничиваются.

Ими представлены редкие математические символы, а также некоторые символы для эмоций, к примеру:

В современный JavaScript добавлены методы String.fromCodePoint и str.codePointAt – аналоги и , корректно работающие с суррогатными парами.

Например, считает суррогатную пару двумя разными символами и возвращает код каждой:

…В то время как возвращает его Unicode-код суррогатной пары правильно:

Метод корректно создаёт строку из «длинного кода», в отличие от старого .

Например:

Более старый метод в последней строке дал неверный результат, так как он берёт только первые два байта от числа и создаёт символ из них, а остальные отбрасывает.

Есть и ещё синтаксическое улучшение для больших Unicode-кодов.

В JavaScript-строках давно можно вставлять символы по Unicode-коду, вот так:

Синтаксис: , где – четырёхзначный шестнадцатиричный код, причём он должен быть ровно четырёхзначным.

«Лишние» цифры уже не войдут в код, например:

Чтобы вводить более длинные коды символов, добавили запись , где – максимально восьмизначный (но можно и меньше цифр) код.

Например:

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

Например, на основе обычного символа существуют символы: . Самые часто встречающиеся подобные сочетания имеют отдельный юникодный код. Но отнюдь не все.

Для генерации произвольных сочетаний используются несколько юникодных символов: основа и один или несколько значков.

Например, если после символа идёт символ «точка сверху» (код ), то показано это будет как «S с точкой сверху» .

Если нужен ещё значок над той же буквой (или под ней) – без проблем. Просто добавляем соответствующий символ.

К примеру, если добавить символ «точка снизу» (код ), то будет «S с двумя точками сверху и снизу» .

Пример этого символа в JavaScript-строке:

Такая возможность добавить произвольной букве нужные значки, с одной стороны, необходима, а с другой стороны – возникает проблемка: можно представить одинаковый с точки зрения визуального отображения и интерпретации символ – разными сочетаниями Unicode-кодов.

Вот пример:

В первой строке после основы идёт сначала значок «верхняя точка», а потом – нижняя, во второй – наоборот. По кодам строки не равны друг другу. Но символ задают один и тот же.

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

В современном JavaScript это делает метод str.normalize().

Забавно, что в данной конкретной ситуации приведёт последовательность из трёх символов к одному: \u1e68 (S с двумя точками).

Это, конечно, не всегда так, просто в данном случае оказалось, что именно такой символ в юникоде уже есть. Если добавить значков, то нормализация уже даст несколько символов.

Для большинства практических задач информации, данной выше, должно быть вполне достаточно, но если хочется более подробно ознакомиться с вариантами и правилами нормализации – они описаны в приложении к стандарту юникод Unicode Normalization Forms.

Примеры

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

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

Пример выведет строку ‘Twas the night before Christmas…’

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

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

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

Здесь важно то, что прежде чем элемент вставится в качестве замены, над ним нужно провести дополнительные преобразования

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

Вызов вернёт строку ‘border-top’.

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

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

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

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

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

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

Строка, состоящая из символов , и

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

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

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

Код:

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

Примеры операций со строками JS

Посимвольный перебор строки

JavaScript

for (let char of «Hello») {
alert(char); // H,e,l,l,o (char — сначала «H», потом «e», потом «l» и т. д.)
}

1 2 3

for(let charof»Hello»){ alert(char);// H,e,l,l,o (char — сначала «H», потом «e», потом «l» и т. д.) }

Получить первую и последнюю буквы строки

JavaScript

console.log(string); // первая буква
console.log(string); // последняя буква

1 2	console.log(string);// первая буква console.log(stringstring.length-1);// последняя буква

Сделать первую и последнюю буквы строки в верхнем регистре

JavaScript

string =
  string.toUpperCase() +
  string.slice(1, -1) +
  string.toUpperCase();

// или
string = `${string.toUpperCase()}${string.slice(1, -1)}${string.toUpperCase()}`;

1 2 3 4 5 6 7 8

string=   string.toUpperCase()+   string.slice(1,-1)+   stringstring.length-1.toUpperCase();   // или string=`${string.toUpperCase()}${string.slice(1,-1)}${string   string.length-1.toUpperCase()}`;

JavaScript

value = string.indexOf(«string»);

1	value = string.indexOf(«string»);

Найти положение второго пробела

JavaScript

let value_1 = string.indexOf(» «); // позиция первого пробела
let  value_2 = string.indexOf(» «, value_1 + 1); // позиция второго пробела
console.log(value_2);

1 2 3

let value_1=string.indexOf(» «);// позиция первого пробела let value_2=string.indexOf(» «,value_1+1);// позиция второго пробела console.log(value_2);

Получить строку с i-го символа длиной n букв

JavaScript

value = string.substr(i, n);
console.log(value); 

1 2	value=string.substr(i,n); console.log(value);

Получить строку с i-го по n-й символы

JavaScript

value = string.slice(i, n+1); // т.к. по n-й символ, аргумент (n+1) (он в выборку не включается)
console.log(value); 

1 2	value=string.slice(i,n+1);// т.к. по n-й символ, аргумент (n+1) (он в выборку не включается) console.log(value);

Удаление из строки последних n символов

JavaScript

value = string.slice(0, -6); // т.к. метод slice поддерживает отрицательные значения

// или
value = string.slice(0, string.length — 6);

1 2 3 4

value=string.slice(,-6);// т.к. метод slice поддерживает отрицательные значения   // или value = string.slice(, string.length — 6);

Получение строки из переменных

JavaScript

let a = 20;
let b = 16;

let string = a.toString()+b.toString();
// Или
let string = String(a)+String(b);
// Или
let string = a + «» + b;
console.log(string, typeof string); // 2016 string

1 2 3 4 5 6 7 8 9

let a = 20; let b = 16; let string = a.toString()+b.toString(); // Или let string=String(a)+String(b); // Или let string = a + «» + b; console.log(string, typeof string); // 2016 string

str.matchAll(regexp)

Новая возможность

Эта возможность была добавлена в язык недавно.
В старых браузерах может понадобиться полифил.

Метод – «новый, улучшенный» вариант метода .

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

У него 3 отличия от :

1. Он возвращает не массив, а перебираемый объект с результатами, обычный массив можно сделать при помощи .
2. Каждое совпадение возвращается в виде массива со скобочными группами (как без флага ).
3. Если совпадений нет, то возвращается не , а пустой перебираемый объект.

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

При переборе результатов в цикле вызов , разумеется, не нужен.

Синтаксис

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

Строка, заменяемая на

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

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

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

Аргументы, передаваемые функции, описаны ниже в разделе .

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

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

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

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

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

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