Update article.md

Author: keslo

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

@@ -5,19 +5,19 @@
 У такого выделения есть два эффекта:
 
 1. Позволяет поместить часть совпадения в отдельный массив.
-2. Если установить квантификтор после скобок, то он будет применяться к всему содержимому скобки, а не к одному символу.
+2. Если установить квантификтор после скобок, то он будет применяться ко всему содержимому скобки, а не к одному символу.
 
 ## Пример
 
-В примере ниже шаблон `pattern:(go)+` один или более `match:'go'`:
+В примере ниже шаблон `pattern:(go)+` ищет как минимум одно совпадение с `match:'go'`:
 
 ```js run
 alert( 'Gogogo now!'.match(/(go)+/i) ); // "Gogogo"
 ```
 
-Без скобок, шаблон `pattern:/go+/` означает `subject:g` и, идущий после него, `subject:o`, который повторяется один или более раз. Например, `match:goooo` или `match:gooooooooo`.
+Без скобок, шаблон `pattern:/go+/` означает символ `subject:g` и идущий после него символ `subject:o`, который повторяется один или более раз. Например, `match:goooo` или `match:gooooooooo`.
 
-Скобки группирую символы в слово `pattern:(go)`.
+Скобки группируют символы в слово `pattern:(go)`.
 
 Сделаем что-то более сложное -- регулярное выражение, которое соответствует адресу электронной почты.
 
@@ -31,11 +31,11 @@ john.smith@site.com.uk
 Шаблон: `pattern:[-.\w]+@([\w-]+\.)+[\w-]{2,20}`.
 
 1. Первая часть `pattern:[-.\w]+` (перед `@`) может включать любые числовые или буквенные символы, точку и тире, чтобы соответствовать `match:john.smith`.
-2. Затем идет `pattern:@` и домен. Это может быть поддомен (например, `host.site.com.uk`), поэтому мы сопоставляем его как слово, за которым следует точка `pattern:([\w-]+\.)` (повторяется). Затем в конце должно быть слово: `match:com` или `match:uk` (но не очень длинное: 2-20 символов).
+2. Затем идёт `pattern:@` и домен. Это может быть поддомен (например, `host.site.com.uk`), поэтому мы сопоставляем его как слово, за которым следует точка `pattern:([\w-]+\.)` (повторяется). Затем в конце должно быть слово: `match:com` или `match:uk` (но не очень длинное: 2-20 символов).
 
-Это выражение не идеально, но достаточно хорошее для исправления ошибок и опечаток.
+Это выражение не идеальное, но достаточно хорошее для исправления ошибок и опечаток.
 
-Например,  мы можем найти все электронные адреса в строке:
+Например, мы можем найти все электронные адреса в строке:
 
 ```js run
 let reg = /[-.\w]+@([\w-]+\.)+[\w-]{2,20}/g;
@@ -47,13 +47,13 @@ alert("my@mail.com @ his@site.com.uk".match(reg)); // my@mail.com, his@site.com.
 
 ## Содержимое скобок  
 
-Группы скобок нумируются слева направо. Поисковый движок запоминает содержимое в каждой группе и позволяет ссылаться на него в шаблоне регулярного выражения или строке для замены.
+Группы скобок нумеруются слева направо. Поисковый движок запоминает содержимое в каждой группе и позволяет ссылаться на него в шаблоне регулярного выражения или строке для замены.
 
-Например, мы хотим найти HTML теги `pattern:<.*?>` и обрадотать их.
+Например, мы хотим найти HTML теги `pattern:<.*?>` и обработать их.
 
 Давайте заключим внутреннее содержимое в круглые скобки: `pattern:<(.*?)>`.
 
-Соберем их в массив:
+Соберём их в массив:
 
 ```js run
 let str = '<h1>Hello, world!</h1>';
@@ -62,9 +62,9 @@ let reg = /<(.*?)>/;
 alert( str.match(reg) ); // Array: ["<h1>", "h1"]
 ```
 
-Вызов [String#match](mdn:js/String/match) возвращает группы только если регулярное выражение не имеет флаг `pattern:/.../g`.
+Вызов [String#match](mdn:js/String/match) возвращает группы, только если регулярное выражение не имеет флага `pattern:/.../g`.
 
-Если необходимы все совпадения с их группировкой, то мы можем использовать `.matchAll` или `regexp.exec` как описано в <info:regexp-methods>:
+Если необходимы все совпадения с их группировкой, то мы можем использовать `.matchAll` или `regexp.exec`, как описано в <info:regexp-methods>:
 
 ```js run
 let str = '<h1>Hello, world!</h1>';
@@ -78,7 +78,7 @@ alert(matches[0]); //  Array: ["<h1>", "h1"]
 alert(matches[1]); //  Array: ["</h1>", "/h1"]
 ```
 
-Здесь мы имеем два совпадения для `pattern:<(.*?)>`. Каждый из них является массивом с полным совдаением и группой.
+Здесь мы имеем два совпадения для `pattern:<(.*?)>`. Каждое из них является массивом с полным совпадением и группами.
 
 ## Вложенные группы
 
@@ -88,7 +88,7 @@ alert(matches[1]); //  Array: ["</h1>", "/h1"]
 
 1. Содержимое тега целиком: `match:span class="my"`.
 2. Название тега: `match:span`.
-3. Аттрибуты тега: `match:class="my"`.
+3. Атрибуты тега: `match:class="my"`.
 
 Давайте добавим скобки для них:
 
@@ -105,17 +105,17 @@ alert(result); // <span class="my">, span class="my", span, class="my"
 
 ![](regexp-nested-groups.png)
 
-С нулевым индексом `result` всегда идет совпадение полностью.
+По нулевому индексу в `result` всегда идёт полное совпадение.
 
-Затем группы, нумеруемые слева направо. Та, которая открывается первой, получает первую группу `result[1]`. Она заключает в себе все содержимое тега.
+Затем следуют группы, нумеруемые слева направо. Группа, которая идёт первой, получает первый индекс в результате -- `result[1]`. Там находится всё содержимое тега.
 
-Затем в `result[2]` идет группа от второй открывающей скобки  `pattern:(` до соответствующей `pattern:)` -- имя тега, тогда мы группируем не пространства, а группу аттрибутов для `result[3]`.
+Затем в `result[2]` идёт группа, образованная второй открывающей скобкой `pattern:(` до следующей закрывающей скобки `pattern:)` -- имя тега, далее в `result[3]` мы группируем не пробелы, а атрибуты.
 
 **Даже если скобочная группа необязательна и не входит в совпадение, соответствующий элемент массива `result` существует (и равен `undefined`).**
 
-Например, рассмотрим регэксп `pattern:a(z)?(c)?`. Он ищет `"a"`, за которой не обязательно идёт буква `"z"`, за которой не обязательно идёт буква `"c"`.
+Например, рассмотрим регулярное выражение `pattern:a(z)?(c)?`. Оно ищет букву `"a"`, за которой опционально идёт буква `"z"`, за которой, в свою очередь, опционально идёт буква `"c"`.
 
-Если запустить его на строку из одной буквы `subject:a`, то результат будет таков:
+Если применить его к строке из одной буквы `subject:a`, то результат будет такой:
 
 ```js run
 let match = 'a'.match(/a(z)?(c)?/);
@@ -139,11 +139,11 @@ alert( match[1] ); // undefined, потому что для (z)? ничего н
 alert( match[2] ); // c
 ```
 
-Длинна массива всегда: `3`. Для группы `pattern:(z)?` ничего нет, поэтому результат `["ac", undefined, "c"]`.
+Длинна массива всегда равна `3`. Для группы `pattern:(z)?` ничего нет, поэтому результат `["ac", undefined, "c"]`.
 
 ## Именованные группы
 
-Запоминать группы по числам сложно. Для простых шаблонов это допустимо, но в более сложных случаях мы можем дать имена скобкам.
+Запоминать группы по числам сложно. Для простых шаблонов это допустимо, но в более сложных случаях мы можем давать имена скобкам.
 
 Это делается добавлением `pattern:?<name>` непосредственно после открытия скобки. Например:
 
@@ -162,7 +162,7 @@ alert(groups.day); // 30
 
 Как вы можете видеть, группы располагаются в свойстве  `.groups` совпадения.
 
-МЫ также можем использовать их для замены, как `pattern:$<name>` (как в случае с `$1..9`, но использовать имя вместо цифры).
+Мы также можем использовать их для замены, как `pattern:$<name>` (как в случае с `$1..9`, но использовать имя вместо цифры).
 
 Например, давайте переделаем информацию о дате `day.month.year`:
 
@@ -191,9 +191,9 @@ let rearranged = str.replace(dateRegexp,
 alert(rearranged); // 30.04.2019
 ```
 
-Обычно, когдам мы планируем использовать именованные группы, то нам не нужны позиционированные аргументы функции. Для большинства реальных случаев нам нужны только `str` и` groups`.
+Обычно, когда мы планируем использовать именованные группы, то из всех аргументов функции нам нужны только `str` и` groups`.
 
-Таким образом, мы можем написать это немного короче:
+Таким образом, мы можем переписать код:
 
 ```js
 let rearranged = str.replace(dateRegexp, (str, ...args) => {
@@ -208,13 +208,13 @@ let rearranged = str.replace(dateRegexp, (str, ...args) => {
 
 ## Исключение из запоминания через ?:
 
-Бывает так, что скобки нужны, чтобы квантификатор правильно применился, но мы не хотим содержимое в результате.
+Бывает так, что скобки нужны, чтобы квантификатор правильно применился, но мы не хотим, чтобы их содержимое попало в результат.
 
 Скобочную группу можно исключить из запоминаемых и нумеруемых, добавив в её начало `pattern:?:`.
 
 Например, если мы хотим найти `pattern:(go)+`, но не хотим запоминать содержимое (`go`) в отдельный элемент массива, то можем написать так: `pattern:(?:go)+`.
 
-В примере ниже мы получаем только имя "John", как отдельный член массива `results`:
+В примере ниже мы получаем только имя "John" как отдельный член массива `results`:
 
 ```js run
 let str = "Gogo John!";
@@ -234,4 +234,4 @@ alert( result[1] ); // John
 - Скобки могут:
   - запоминать `(...)`, нумеровать слева направо, давать доступ по номеру.
   - именовать группы `(?<name>...)`, давать доступ по имени.
-  - исключать из запоминания `(?:...)`, использоваться только для применения квантификатора ко всем группам.
+  - исключать из запоминания `(?:...)`, использоваться только для применения квантификатора ко всей группе символов.