regexp

Author: iliakan

1-js/09-classes/02-class-inheritance/article.md

@@ -520,7 +520,7 @@ Here's the diagram of what happens:
 
 ```js run
 let animal = {
-  eat: function() { // должен быть короткий синтаксис: eat() {...}
+  eat: function() { // намеренно не пишем так, а не eat() { ...
     // ...
   }
 };

9-regular-expressions/11-regexp-groups/article.md

@@ -200,15 +200,16 @@ let results = '<h1> <h2>'.matchAll(/<(.*?)>/gi);
 
 // results - не массив, а перебираемый объект
 alert(results); // [object RegExp String Iterator]
-alert(results[0]); // undefined
+
+alert(results[0]); // undefined (*)
 
 results = Array.from(results); // превращаем в массив
 
 alert(results[0]); // <h1>,h1 (первый тег)
 alert(results[1]); // <h2>,h2 (второй тег)
 ```
 
-Как видите, первое отличие - очень важное. Мы не можем получить совпадение как  `results[0]`, так как этот объект не является псевдомассивом. Его можно превратить в настоящий массив при помощи `Array.from`. Более подробно о псевдомассивах и перебираемых объектов мы говорили в главе <info:iterable>.
+Как видите, первое отличие - очень важное, это демонстрирует строка `(*)`. Мы не можем получить совпадение как  `results[0]`, так как этот объект не является псевдомассивом. Его можно превратить в настоящий массив при помощи `Array.from`. Более подробно о псевдомассивах и перебираемых объектов мы говорили в главе <info:iterable>.
 
 В явном преобразовании через `Array.from` нет необходимости, если мы перебираем результаты в цикле, вот так:
 
@@ -228,6 +229,19 @@ for(let result of results) {
 let [tag1, tag2] = '<h1> <h2>'.matchAll(/<(.*?)>/gi);
 ```
 
+Каждое совпадение, возвращаемое `matchAll`, имеет тот же вид, что и при `match` без флага `pattern:g`: это массив с дополнительными свойствами `index` (позиция совпадения) и `input` (исходный текст):
+
+```js run
+let results = '<h1> <h2>'.matchAll(/<(.*?)>/gi);
+
+let [tag1, tag2] = results;
+
+alert( tag1[0] ); // <h1>
+alert( tag1[1] ); // h1
+alert( tag1.index ); // 0
+alert( tag1.input ); // <h1> <h2>
+```
+
 ```smart header="Почему результат `matchAll` - перебираемый объект, а не обычный массив?"
 Зачем так сделано? Причина проста - для оптимизации.
 

9-regular-expressions/16-regexp-sticky/article.md

@@ -1,51 +1,76 @@
 # Поиск на заданной позиции, флаг "y"
 
-Флаг `pattern:y` позволяет произвести поиск, начиная с определённой позиции в исходной строке.
+Флаг `pattern:y` позволяет произвести поиск на определённой позиции в исходной строке.
 
 Чтобы разобрать флаг `pattern:y` и понять, чем же он хорош, рассмотрим практический пример.
 
-Одна из часто встречающихся задач регулярных выражений - лексический разбор: мы имеем текст на каком-то языке программирования и с помощью регулярных выражений (или иным способом) получаем его структурные элементы.
+Одна из часто встречающихся задач регулярных выражений - лексический разбор: мы имеем текст, например, на каком-то языке программирования и получаем его структурные элементы.
 
-Например, в браузеры встроен лексический анализатор HTML, а также для языка JavaScript.
+Например, в HTML есть теги и атрибуты, в JavaScript-коде - переменные и функции, и т.п.
 
 Мы не будем погружаться глубоко в тему написания таких анализаторов (это специализированная область со своим набором инструментов и алгоритмов). Но в процессе их работы, вообще, в процессе анализа текста, очень часто возникает задача "прочитать что-то на заданной позиции".
 
 Например, у нас есть строка кода `subject:let varName = "value"`, и нам надо прочитать из неё имя переменной, которое начинается с позиции `4`.
 
 Имя переменной будем искать как слово `pattern:\w+`. Вообще, в языке JavaScript для имени переменной нужно чуть более сложное регулярное выражение, но здесь это не важно.
 
-Обычный поиск, такой как `str.match` найдёт только первое слово в строке или все слова (с флагом `pattern:g`), а нам нужно одно слово именно на позиции `4`.
+Вызов `str.match(/\w+/)` найдёт только первое слово в строке или все слова (с флагом `pattern:g`), а нам нужно одно слово именно на позиции `4`.
 
-Для использования флага `pattern:y` понадобится метод `regexp.exec(str)`.
+Для поиска, начиная с нужной позиции, можно использовать метод `regexp.exec(str)`.
 
-Если у регулярного выражения нет флагов `pattern:g` или `pattern:y`, то он ищет первое совпадение с `regexp` в строке `str`, аналогично `str.match(regexp)`. Здесь нас вариант без флагов не интересует.
+Если у регулярного выражения `regexp` нет флагов `pattern:g` или `pattern:y`, то этот метод ищет первое совпадение в строке `str`, точно так же, как `str.match(regexp)`. Здесь нас этот простейший вариант без флагов не интересует.
 
 Если флаг `pattern:g` есть, то он осуществляет поиск в строке `str`, начиная с позиции, заданной свойством `regexp.lastIndex`. И, когда находит, обновляет `regexp.lastIndex` на позицию после совпадения.
 
 При создании регулярного выражения его свойство `lastIndex` равно `0`.
 
-Например (пока без флага `y`):
+Так что повторные вызовы `regexp.exec` возвращают совпадения по очереди, одно за другим.
+
+Например (с флагом `pattern:g`):
 
 ```js run
-let str = 'let varName = "value"';
+let str = 'let varName';
 
 let regexp = /\w+/g;
 alert(regexp.lastIndex); // 0 (при создании lastIndex=0)
 
 let word1 = regexp.exec(str);
-alert(word1); // let (первое слово)
+alert(word1[0]); // let (первое слово)
 alert(regexp.lastIndex); // 3 (позиция за первым совпадением)
 
 let word2 = regexp.exec(str);
-alert(word2); // varName (второе слово)
+alert(word2[0]); // varName (второе слово)
 alert(regexp.lastIndex); // 11 (позиция за вторым совпадением)
+
+let word3 = regexp.exec(str);
+alert(word3); // null (больше совпадений нет)
+alert(regexp.lastIndex); // 0 (сбрасывается по окончании поиска)
 ```
 
+Заметим, что каждое совпадение возвращается в виде массива, со всеми скобочными группами и дополнительными свойствами.
+
+Можно перебрать все совпадения в цикле:
+
+```js run
+let str = 'let varName';
+let regexp = /\w+/g;
+
+let result;
+
+while (result = regexp.exec(str)) {
+  alert( `Найдено ${result[0]} на позиции ${result.index}` );
+  // Найдено let на позиции 0, затем
+  // Найдено varName на позиции 4
+}
+```
+
+Такое использование `regexp.exec` представляет собой альтернативу методу `str.matchAll`.
+
 Таким образом, последовательные вызовы `regexp.exec` могут найти все совпадения, представляя собой альтернативу методам `str.match/matchAll`.
 
-Но, в отличие от этих методов, мы можем поставить самостоятельно `lastIndex`, начав тем самым поиск именно с нужной позиции.
+Но, в отличие от других методов, мы можем поставить самостоятельно `lastIndex`, начав тем самым поиск именно с нужной позиции.
 
-Например, найдём слово на позиции `4`:
+Например, найдём слово, начиная с позиции `4`:
 
 ```js run
 let str = 'let varName = "value"';
@@ -68,12 +93,14 @@ alert(word); // varName
 let str = 'let varName = "value"';
 
 let regexp = /\w+/g;
+
 *!*
 regexp.lastIndex = 3;
 */!*
 
 let word = regexp.exec(str);
-alert(word); // varName
+alert(word[0]); // varName
+alert(word.index); // 4
 ```
 
 ...То есть, при флаге `pattern:g` свойство `lastIndex` задаёт *стартовую позицию* поиска.
@@ -94,10 +121,8 @@ regexp.lastIndex = 4;
 alert( regexp.exec(str) ); // varName (слово на позиции 4)
 ```
 
-Как можно видеть, регулярное выражение `pattern:\w+` не найдено на позиции `3` (в отличие от флага `pattern:g`), но найдено на позиции `4`.
-
-Флаг `pattern:y` позволяет проверять регулярное выражение именно на конкретной позиции. Это очень важно с точки зрения производительности.
+Как можно видеть, регулярное выражение `pattern:/\w+/y` не найдено на позиции `3` (в отличие от флага `pattern:g`), но найдено на позиции `4`.
 
-При лексическом анализе больших текстов зачастую нужно применять несколько регэкспов на конкретной позиции текста, чтобы понять, что там находится (функция или переменная или число и т.п.)
+Представим себе, что у нас большой текст, и в нём нет ни одного совпадения. В таком случае регэксп с флагом `pattern:g` будет идти до самого конца текста, и это займёт гораздо больше времени, чем поиск с флагом `pattern:y`.
 
-Без флага `pattern:y` регулярное выражение будет искать, начиная с `lastIndex` и далее по всему тексту, что будет занимать время, особенно, если текст большой. А по всему тексту дальше не надо. Флаг `pattern:y` для подобных задач -- именно то, что нужно.
+В задачах, подобных лексическому анализу, обычно много поисков на конкретной позиции. Использование флага `pattern:y` - ключ к хорошей производительности.