From 418ca73fb8da255c1c1b3353ebb41b6f334ff599 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Fri, 31 May 2019 10:08:57 +0300
Subject: [PATCH 01/34] 9-regular-expressions/09-regexp-groups

---
 .../09-regexp-groups/article.md               | 34 +++++++++----------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/article.md b/9-regular-expressions/09-regexp-groups/article.md
index 6b2a17f11b..e922f7c780 100644
--- a/9-regular-expressions/09-regexp-groups/article.md
+++ b/9-regular-expressions/09-regexp-groups/article.md
@@ -1,41 +1,41 @@
-# Capturing groups
+# Скобочные группы
 
-A part of a pattern can be enclosed in parentheses `pattern:(...)`. This is called a "capturing group".
+Часть шаблона можно заключить в скобки `pattern:(...)`. Это называется "скобочная группа".
 
-That has two effects:
+У такого выделения есть два эффекта:
 
-1. It allows to place a part of the match into a separate array.
-2. If we put a quantifier after the parentheses, it applies to the parentheses as a whole, not the last character.
+1. Позволяет поместить часть совпадения в отдельный массив.
+2. Если установить квантификтор после скобок, то он будет применяться к всему содержимому скобки, а не к одному символу.
 
-## Example
+## Пример
 
-In the example below the pattern `pattern:(go)+` finds one or more `match:'go'`:
+В примере ниже шаблон `pattern:(go)+` один или более `match:'go'`:
 
 ```js run
 alert( 'Gogogo now!'.match(/(go)+/i) ); // "Gogogo"
 ```
 
-Without parentheses, the pattern `pattern:/go+/` means `subject:g`, followed by `subject:o` repeated one or more times. For instance, `match:goooo` or `match:gooooooooo`.
+Без скобок, шаблон `pattern:/go+/` означает `subject:g` и, идущий после него, `subject:o`, который повторяется один или более раз. Например, `match:goooo` или `match:gooooooooo`.
 
-Parentheses group the word `pattern:(go)` together.
+Скобки группирую символы в слово `pattern:(go)`.
 
-Let's make something more complex -- a regexp to match an email.
+Сделаем что-то более сложное -- регулярное выражение, которое соответствует адресу электронной почты.
 
-Examples of emails:
+Пример такой почты:
 
 ```
 my@mail.com
 john.smith@site.com.uk
 ```
 
-The pattern: `pattern:[-.\w]+@([\w-]+\.)+[\w-]{2,20}`.
+Шаблон: `pattern:[-.\w]+@([\w-]+\.)+[\w-]{2,20}`.
 
-1. The first part `pattern:[-.\w]+` (before `@`) may include any alphanumeric word characters, a dot and a dash, to match `match:john.smith`.
-2. Then `pattern:@`, and the domain. It may be a subdomain like `host.site.com.uk`, so we match it as "a word followed by a dot `pattern:([\w-]+\.)` (repeated), and then the last part must be a word: `match:com` or `match:uk` (but not very long: 2-20 characters).
+1. Первая часть `pattern:[-.\w]+` (перед `@`) может включать любые числовые или буквенные символы, точку и тире, чтобы соответствовать `match:john.smith`.
+2. Затем идет `pattern:@` и домен. Это может быть поддомен (например, `host.site.com.uk`), поэтому мы сопоставляем его как слово, за которым следует точка `pattern:([\w-]+\.)` (повторяется). Затем в конце должно быть слово: `match:com` или `match:uk` (но не очень длинное: 2-20 символов).
 
-That regexp is not perfect, but good enough to fix errors or occasional mistypes.
+Это выражение не идеально, но достаточно хорошее для исправления ошибок и опечаток.
 
-For instance,  we can find all emails in the string:
+Например,  мы можем найти все электронные адреса в строке:
 
 ```js run
 let reg = /[-.\w]+@([\w-]+\.)+[\w-]{2,20}/g;
@@ -43,7 +43,7 @@ let reg = /[-.\w]+@([\w-]+\.)+[\w-]{2,20}/g;
 alert("my@mail.com @ his@site.com.uk".match(reg)); // my@mail.com, his@site.com.uk
 ```
 
-In this example parentheses were used to make a group for repeating `pattern:(...)+`. But there are other uses too, let's see them.
+В примере скобки используются для создания повторяющейся группы `pattern:(...)+`. Но есть и другие применения. Посмотрим на них.
 
 ## Contents of parentheses  
 

From c976c085561f0580c163ed60c2026f5b56ad29b3 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Fri, 31 May 2019 10:11:03 +0300
Subject: [PATCH 02/34] Update article.md

---
 9-regular-expressions/09-regexp-groups/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/09-regexp-groups/article.md b/9-regular-expressions/09-regexp-groups/article.md
index e922f7c780..096576e608 100644
--- a/9-regular-expressions/09-regexp-groups/article.md
+++ b/9-regular-expressions/09-regexp-groups/article.md
@@ -45,7 +45,7 @@ alert("my@mail.com @ his@site.com.uk".match(reg)); // my@mail.com, his@site.com.
 
 В примере скобки используются для создания повторяющейся группы `pattern:(...)+`. Но есть и другие применения. Посмотрим на них.
 
-## Contents of parentheses  
+## Содержимое скобок  
 
 Parentheses are numbered from left to right. The search engine remembers the content of each and allows to reference it in the pattern or in the replacement string.
 

From a7b707f3d5331d3ba884c0d34db236275ca5a673 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Fri, 31 May 2019 10:30:30 +0300
Subject: [PATCH 03/34] Update article.md

---
 9-regular-expressions/09-regexp-groups/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/09-regexp-groups/article.md b/9-regular-expressions/09-regexp-groups/article.md
index 096576e608..c3fe4923fd 100644
--- a/9-regular-expressions/09-regexp-groups/article.md
+++ b/9-regular-expressions/09-regexp-groups/article.md
@@ -47,7 +47,7 @@ alert("my@mail.com @ his@site.com.uk".match(reg)); // my@mail.com, his@site.com.
 
 ## Содержимое скобок  
 
-Parentheses are numbered from left to right. The search engine remembers the content of each and allows to reference it in the pattern or in the replacement string.
+Группы скобок нумируются слева направо. Поисковый движок запоминает содержимое в каждой группе и позволяет ссылаться на него в шаблоне регулярного выражения или строке для замены.
 
 For instance, we'd like to find HTML tags `pattern:<.*?>`, and process them.
 

From 73d9d16de9c61e98a7cb7f290a73a0e0d7a1425d Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Sun, 9 Jun 2019 18:28:26 +0300
Subject: [PATCH 04/34] Update article.md

---
 9-regular-expressions/09-regexp-groups/article.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/article.md b/9-regular-expressions/09-regexp-groups/article.md
index c3fe4923fd..ae08d7bbb9 100644
--- a/9-regular-expressions/09-regexp-groups/article.md
+++ b/9-regular-expressions/09-regexp-groups/article.md
@@ -49,11 +49,11 @@ alert("my@mail.com @ his@site.com.uk".match(reg)); // my@mail.com, his@site.com.
 
 Группы скобок нумируются слева направо. Поисковый движок запоминает содержимое в каждой группе и позволяет ссылаться на него в шаблоне регулярного выражения или строке для замены.
 
-For instance, we'd like to find HTML tags `pattern:<.*?>`, and process them.
+Например, мы хотим найти HTML теги `pattern:<.*?>` и обрадотать их.
 
-Let's wrap the inner content into parentheses, like this: `pattern:<(.*?)>`.
+Давайте заключим внутреннее содержимое в круглые скобки: `pattern:<(.*?)>`.
 
-We'll get them into an array:
+Соберем их в массив:
 
 ```js run
 let str = '<h1>Hello, world!</h1>';
@@ -62,14 +62,14 @@ let reg = /<(.*?)>/;
 alert( str.match(reg) ); // Array: ["<h1>", "h1"]
 ```
 
-The call to [String#match](mdn:js/String/match) returns groups only if the regexp has no `pattern:/.../g` flag.
+Вызов [String#match](mdn:js/String/match) возвращает группы только если регулярное выражение не имеет флаг `pattern:/.../g`.
 
-If we need all matches with their groups then we can use `.matchAll` or `regexp.exec` as described in <info:regexp-methods>:
+Если необходимы все совпадения с их группировкой, то мы можем использовать `.matchAll` или `regexp.exec` как описано в <info:regexp-methods>:
 
 ```js run
 let str = '<h1>Hello, world!</h1>';
 
-// two matches: opening <h1> and closing </h1> tags
+// два совпадения: теги открытия <h1> и закрытия </h1>
 let reg = /<(.*?)>/g;
 
 let matches = Array.from( str.matchAll(reg) );
@@ -78,7 +78,7 @@ alert(matches[0]); //  Array: ["<h1>", "h1"]
 alert(matches[1]); //  Array: ["</h1>", "/h1"]
 ```
 
-Here we have two matches for `pattern:<(.*?)>`, each of them is an array with the full match and groups.
+Здесь мы имеем два совпадения для `pattern:<(.*?)>`. Каждый из них является массивом с полным совдаением и группой.
 
 ## Nested groups
 

From 7e8cf039e9a6dea29ac45ca646d234122004782e Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Sun, 9 Jun 2019 18:35:59 +0300
Subject: [PATCH 05/34] Update article.md

---
 .../09-regexp-groups/article.md                  | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/article.md b/9-regular-expressions/09-regexp-groups/article.md
index ae08d7bbb9..f097920cfb 100644
--- a/9-regular-expressions/09-regexp-groups/article.md
+++ b/9-regular-expressions/09-regexp-groups/article.md
@@ -80,17 +80,17 @@ alert(matches[1]); //  Array: ["</h1>", "/h1"]
 
 Здесь мы имеем два совпадения для `pattern:<(.*?)>`. Каждый из них является массивом с полным совдаением и группой.
 
-## Nested groups
+## Вложенные группы
 
-Parentheses can be nested. In this case the numbering also goes from left to right.
+Скобки могут быть и вложенными. В этом случае нумерация также идёт слева направо.
 
-For instance, when searching a tag in `subject:<span class="my">` we may be interested in:
+Например, при поиске тега в `subject:<span class="my">` нас может интересовать:
 
-1. The tag content as a whole: `match:span class="my"`.
-2. The tag name: `match:span`.
-3. The tag attributes: `match:class="my"`.
+1. Содержимое тега целиком: `match:span class="my"`.
+2. Название тега: `match:span`.
+3. Аттрибуты тега: `match:class="my"`.
 
-Let's add parentheses for them:
+Давайте добавим скобки для них:
 
 ```js run
 let str = '<span class="my">';
@@ -101,7 +101,7 @@ let result = str.match(reg);
 alert(result); // <span class="my">, span class="my", span, class="my"
 ```
 
-Here's how groups look:
+Вот так выглядят скобочные группы:
 
 ![](regexp-nested-groups.png)
 

From b189e228ce8854bff20d7c91fc9d9ba4699c38f8 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Sun, 9 Jun 2019 19:00:23 +0300
Subject: [PATCH 06/34] Update article.md

---
 9-regular-expressions/09-regexp-groups/article.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/article.md b/9-regular-expressions/09-regexp-groups/article.md
index f097920cfb..27a92305d0 100644
--- a/9-regular-expressions/09-regexp-groups/article.md
+++ b/9-regular-expressions/09-regexp-groups/article.md
@@ -105,13 +105,13 @@ alert(result); // <span class="my">, span class="my", span, class="my"
 
 ![](regexp-nested-groups.png)
 
-At the zero index of the `result` is always the full match.
+С нулевым индексом `result` всегда идет совпадение полностью.
 
-Then groups, numbered from left to right. Whichever opens first gives the first group `result[1]`. Here it encloses the whole tag content.
+Затем группы, нумеруемые слева направо. Та, которая открывается первой, получает первую группу `result[1]`. Она заключает в себе все содержимое тега.
 
-Then in `result[2]` goes the group from the second opening `pattern:(` till the corresponding `pattern:)` -- tag name, then we don't group spaces, but group attributes for `result[3]`.
+Затем в `result[2]` идет группа от второй открывающей скобки  `pattern:(` до соответствующей `pattern:)` -- имя тега, тогда мы группируем не пространства, а группу аттрибутов для `result[3]`.
 
-**If a group is optional and doesn't exist in the match, the corresponding `result` index is present (and equals `undefined`).**
+**Даже если скобочная группа необязательна и не входит в совпадение, соответствующий элемент массива `result` существует (и равен `undefined`).**
 
 For instance, let's consider the regexp `pattern:a(z)?(c)?`. It looks for `"a"` optionally followed by `"z"` optionally followed by `"c"`.
 

From 5514faec7aff309800515d40ccc9ca858ae3fe39 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Mon, 10 Jun 2019 15:36:37 +0300
Subject: [PATCH 07/34] Update article.md

---
 .../09-regexp-groups/article.md               | 56 +++++++++----------
 1 file changed, 28 insertions(+), 28 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/article.md b/9-regular-expressions/09-regexp-groups/article.md
index 27a92305d0..5a18041e6e 100644
--- a/9-regular-expressions/09-regexp-groups/article.md
+++ b/9-regular-expressions/09-regexp-groups/article.md
@@ -113,39 +113,39 @@ alert(result); // <span class="my">, span class="my", span, class="my"
 
 **Даже если скобочная группа необязательна и не входит в совпадение, соответствующий элемент массива `result` существует (и равен `undefined`).**
 
-For instance, let's consider the regexp `pattern:a(z)?(c)?`. It looks for `"a"` optionally followed by `"z"` optionally followed by `"c"`.
+Например, рассмотрим регэксп `pattern:a(z)?(c)?`. Он ищет `"a"`, за которой не обязательно идёт буква `"z"`, за которой не обязательно идёт буква `"c"`.
 
-If we run it on the string with a single letter `subject:a`, then the result is:
+Если запустить его на строку из одной буквы `subject:a`, то результат будет таков:
 
 ```js run
 let match = 'a'.match(/a(z)?(c)?/);
 
 alert( match.length ); // 3
-alert( match[0] ); // a (whole match)
+alert( match[0] ); // a (всё совпадение)
 alert( match[1] ); // undefined
 alert( match[2] ); // undefined
 ```
 
-The array has the length of `3`, but all groups are empty.
+Массив имеет длинну `3`, но все скобочные группы пустые.
 
-And here's a more complex match for the string `subject:ack`:
+А теперь более сложная ситуация для строки `subject:ack`:
 
 ```js run
 let match = 'ack'.match(/a(z)?(c)?/)
 
 alert( match.length ); // 3
-alert( match[0] ); // ac (whole match)
-alert( match[1] ); // undefined, because there's nothing for (z)?
+alert( match[0] ); // ac (всё совпадение)
+alert( match[1] ); // undefined, потому что для (z)? ничего нет
 alert( match[2] ); // c
 ```
 
-The array length is permanent: `3`. But there's nothing for the group `pattern:(z)?`, so the result is `["ac", undefined, "c"]`.
+Длинна массива всегда: `3`. Для группы `pattern:(z)?` ничего нет, поэтому результат `["ac", undefined, "c"]`.
 
-## Named groups
+## Именованные группы
 
-Remembering groups by their numbers is hard. For simple patterns it's doable, but for more complex ones we can give names to parentheses.
+Запоминать группы по числам сложно. Для простых шаблонов это допустимо, но в более сложных случаях мы можем дать имена скобкам.
 
-That's done by putting `pattern:?<name>` immediately after the opening paren, like this:
+Это делается добавлением `pattern:?<name>` непосредственно после открытия скобки. Например:
 
 ```js run
 *!*
@@ -160,11 +160,11 @@ alert(groups.month); // 04
 alert(groups.day); // 30
 ```
 
-As you can see, the groups reside in the `.groups` property of the match.
+Как вы можете видеть, группы располагаются в свойстве  `.groups` совпадения.
 
-We can also use them in replacements, as `pattern:$<name>` (like `$1..9`, but name instead of a digit).
+МЫ также можем использовать их для замены, как `pattern:$<name>` (как в случае с `$1..9`, но использовать имя вместо цифры).
 
-For instance, let's rearrange the date into `day.month.year`:
+Например, давайте переделаем информацию о дате `day.month.year`:
 
 ```js run
 let dateRegexp = /(?<year>[0-9]{4})-(?<month>[0-9]{2})-(?<day>[0-9]{2})/;
@@ -176,7 +176,7 @@ let rearranged = str.replace(dateRegexp, '$<day>.$<month>.$<year>');
 alert(rearranged); // 30.04.2019
 ```
 
-If we use a function, then named `groups` object is always the last argument:
+Если используем функцию, тогда именованный объект `groups` всегда является последним аргументом:
 
 ```js run
 let dateRegexp = /(?<year>[0-9]{4})-(?<month>[0-9]{2})-(?<day>[0-9]{2})/;
@@ -191,9 +191,9 @@ let rearranged = str.replace(dateRegexp,
 alert(rearranged); // 30.04.2019
 ```
 
-Usually, when we intend to use named groups, we don't need positional arguments of the function. For the majority of real-life cases we only need `str` and `groups`.
+Обычно, когдам мы планируем использовать именованные группы, то нам не нужны позиционированные аргументы функции. Для большинства реальных случаев нам нужны только `str` и` groups`.
 
-So we can write it a little bit shorter:
+Таким образом, мы можем написать это немного короче:
 
 ```js
 let rearranged = str.replace(dateRegexp, (str, ...args) => {
@@ -206,20 +206,20 @@ let rearranged = str.replace(dateRegexp, (str, ...args) => {
 ```
 
 
-## Non-capturing groups with ?:
+## Исключение из запоминания через ?:
 
-Sometimes we need parentheses to correctly apply a quantifier, but we don't want the contents in results.
+Бывает так, что скобки нужны, чтобы квантификатор правильно применился, но мы не хотим содержимое в результате.
 
-A group may be excluded by adding `pattern:?:` in the beginning.
+Скобочную группу можно исключить из запоминаемых и нумеруемых, добавив в её начало `pattern:?:`.
 
-For instance, if we want to find `pattern:(go)+`, but don't want to remember the contents (`go`) in a separate array item, we can write: `pattern:(?:go)+`.
+Например, если мы хотим найти `pattern:(go)+`, но не хотим запоминать содержимое (`go`) в отдельный элемент массива, то можем написать так: `pattern:(?:go)+`.
 
-In the example below we only get the name "John" as a separate member of the `results` array:
+В примере ниже мы получаем только имя "John", как отдельный член массива `results`:
 
 ```js run
 let str = "Gogo John!";
 *!*
-// exclude Gogo from capturing
+// исключает Gogo из запоминания
 let reg = /(?:go)+ (\w+)/i;
 */!*
 
@@ -229,9 +229,9 @@ alert( result.length ); // 2
 alert( result[1] ); // John
 ```
 
-## Summary
+## Итого
 
-- Parentheses can be:
-  - capturing `(...)`, ordered left-to-right, accessible by number.
-  - named capturing `(?<name>...)`, accessible by name.
-  - non-capturing `(?:...)`, used only to apply quantifier to the whole groups.
+- Скобки могут:
+  - запоминать `(...)`, нумеровать слева направо, давать доступ по номеру.
+  - именовать группы `(?<name>...)`, давать доступ по имени.
+  - исключать из запоминания `(?:...)`, использоваться только для применения квантификатора ко всем группам.

From efb2159a6750857b1bb610cde500f01354a16514 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Mon, 10 Jun 2019 15:44:40 +0300
Subject: [PATCH 08/34] Update solution.md

---
 .../1-find-webcolor-3-or-6/solution.md             | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md b/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
index d653ff970a..61d9142b69 100644
--- a/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
+++ b/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
@@ -1,14 +1,14 @@
-A regexp to search 3-digit color `#abc`: `pattern:/#[a-f0-9]{3}/i`.
+Регэксп для поиска номера цвета из трех символов `#abc`: `pattern:/#[a-f0-9]{3}/i`.
 
-We can add exactly 3 more optional hex digits. We don't need more or less. Either we have them or we don't.
+Мы можем добавить точно 3 дополнительные шестнадцатеричные цифры. Нам не нужно больше или меньше. Либо у нас они есть, либо у нас нет.
 
-The simplest way to add them -- is to append to the regexp: `pattern:/#[a-f0-9]{3}([a-f0-9]{3})?/i`
+Простейший способ добавить их -- добавить в регулярное выражение: `pattern:/#[a-f0-9]{3}([a-f0-9]{3})?/i`
 
-We can do it in a smarter way though: `pattern:/#([a-f0-9]{3}){1,2}/i`.
+Мы можем сделать это более интересным способом: `pattern:/#([a-f0-9]{3}){1,2}/i`.
 
-Here the regexp `pattern:[a-f0-9]{3}` is in parentheses to apply the quantifier `pattern:{1,2}` to it as a whole.
+Этот регэксп `pattern:[a-f0-9]{3}` в скобках для применения квантификатора `pattern:{1,2}` к нему вцелом.
 
-In action:
+В действии:
 
 ```js run
 let reg = /#([a-f0-9]{3}){1,2}/gi;
@@ -18,7 +18,7 @@ let str = "color: #3f3; background-color: #AA00ef; and: #abcd";
 alert( str.match(reg) ); // #3f3 #AA00ef #abc
 ```
 
-There's a minor problem here: the pattern found `match:#abc` in `subject:#abcd`. To prevent that we can add `pattern:\b` to the end:
+Здесь есть небольшая проблема: шаблон находит `match: # abc` в` subject: # abcd`. Чтобы предотвратить это, мы можем добавить `pattern: \ b` в конец:
 
 ```js run
 let reg = /#([a-f0-9]{3}){1,2}\b/gi;

From ce60cc2d9e24c908f370b50ca9330f4e2c9f51fe Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Thu, 13 Jun 2019 16:26:48 +0300
Subject: [PATCH 09/34] Update task.md

---
 .../09-regexp-groups/1-find-webcolor-3-or-6/task.md    | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/task.md b/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/task.md
index 4efd6f61f8..b8a16fb6a1 100644
--- a/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/task.md
+++ b/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/task.md
@@ -1,14 +1,14 @@
-# Find color in the format #abc or #abcdef
+# Найти цвет в формате #abc или #abcdef
 
-Write a RegExp that matches colors in the format `#abc` or `#abcdef`. That is: `#` followed by 3 or 6 hexadecimal digits.
+Напишите регэксп, который соответствует цветам в формате `#abc` или `#abcdef`. То есть: `#` и за ним 3 или 6 шестнадцатеричных цифры.
 
-Usage example:
+Пример использования:
 ```js
-let reg = /your regexp/g;
+let reg = /ваш регэксп/g;
 
 let str = "color: #3f3; background-color: #AA00ef; and: #abcd";
 
 alert( str.match(reg) ); // #3f3 #AA00ef
 ```
 
-P.S. This should be exactly 3 or 6 hex digits: values like `#abcd` should not match.
+P.S. Это должно быть ровно 3 или 6 шестнадцатеричных цифры, такие как "abcd" не должны совпадать.

From 0bb446fce37e48318eb9224a871dba9d09847939 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Mon, 17 Jun 2019 15:03:38 +0300
Subject: [PATCH 10/34] Update solution.md

---
 .../3-find-decimal-positive-numbers/solution.md        | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/solution.md b/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/solution.md
index 23065413ef..62629f0e57 100644
--- a/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/solution.md
+++ b/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/solution.md
@@ -1,13 +1,13 @@
 
-An non-negative integer number is `pattern:\d+`. We should exclude `0` as the first digit, as we don't need zero, but we can allow it in further digits.
+Регэксп для неотрицательного целого числа `pattern:\d+`. Мы должны исключить `0` в качестве первой цифры, так как нам не нужен ноль, но мы можем разрешить его появление в составе чисел.
 
-So that gives us `pattern:[1-9]\d*`.
+Нам позволит сделать это регэксп: `pattern:[1-9]\d*`.
 
-A decimal part is: `pattern:\.\d+`.
+Десятичная часть находится с помощью: `pattern:\.\d+`.
 
-Because the decimal part is optional, let's put it in parentheses with the quantifier `pattern:'?'`.
+Поскольку десятичная часть является необязательной, то давайте заключим ее в скобки с квантификатором `pattern:'?'`.
 
-Finally we have the regexp: `pattern:[1-9]\d*(\.\d+)?`:
+В итоге, мы получаем регэксп: `pattern:[1-9]\d*(\.\d+)?`:
 
 ```js run
 let reg = /[1-9]\d*(\.\d+)?/g;

From 1a0833592da375d0b192ec14c822c823608b5c3f Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Tue, 18 Jun 2019 22:11:38 +0300
Subject: [PATCH 11/34] Update task.md

---
 .../3-find-decimal-positive-numbers/task.md            | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/task.md b/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/task.md
index ad8c81eaec..3bb81a2df6 100644
--- a/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/task.md
+++ b/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/task.md
@@ -1,12 +1,12 @@
-# Find positive numbers
+# Найти положительные числа
 
-Create a regexp that looks for positive numbers, including those without a decimal point.
+Создайте регэксп, который ищет положительные числа, включая числа без десятичной части.
 
-An example of use:
+Пример использования:
 ```js
-let reg = /your regexp/g;
+let reg = /ваш регэксп/g;
 
 let str = "1.5 0 -5 12. 123.4.";
 
-alert( str.match(reg) ); // 1.5, 12, 123.4 (ignores 0 and -5)
+alert( str.match(reg) ); // 1.5, 12, 123.4 (игнорирует 0 и -5)
 ```

From 602f794df31ded3722c97ec39c49bdbf83dc5760 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Tue, 18 Jun 2019 22:14:41 +0300
Subject: [PATCH 12/34] Update solution.md

---
 .../09-regexp-groups/4-find-decimal-numbers/solution.md       | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/solution.md b/9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/solution.md
index dd2410847b..84826d8a9b 100644
--- a/9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/solution.md
+++ b/9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/solution.md
@@ -1,6 +1,6 @@
-A positive number with an optional decimal part is (per previous task): `pattern:\d+(\.\d+)?`.
+Положительное число с необязательным присутствием десятичной части (из прошлой задачи): `pattern:\d+(\.\d+)?`.
 
-Let's add an optional `-` in the beginning:
+Давайте добавим необязательный `-` в начало:
 
 ```js run
 let reg = /-?\d+(\.\d+)?/g;

From c4f9c0f6e6511554ba0c54ad1faa1c3957eacefe Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Tue, 18 Jun 2019 22:17:28 +0300
Subject: [PATCH 13/34] Update task.md

---
 .../09-regexp-groups/4-find-decimal-numbers/task.md       | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/task.md b/9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/task.md
index 121a18a41b..3061f0ca11 100644
--- a/9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/task.md
+++ b/9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/task.md
@@ -1,11 +1,11 @@
-# Find all numbers
+# Найти все числа
 
-Write a regexp that looks for all decimal numbers including integer ones, with the floating point and negative ones.
+Напишите регэксп, который соответствует всем десятичным числам, включая целочисленные, с плавающей точкой и отрицательные.
 
-An example of use:
+Пример использования:
 
 ```js
-let reg = /your regexp/g;
+let reg = /ваш регэксп/g;
 
 let str = "-1.5 0 2 -123.4.";
 

From 78b19184b0c1e457b607b6967d5c727a901b2e47 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Tue, 18 Jun 2019 22:36:41 +0300
Subject: [PATCH 14/34] Update solution.md

---
 .../5-parse-expression/solution.md            | 36 +++++++++----------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/5-parse-expression/solution.md b/9-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
index 3db5f667c2..da7fa898aa 100644
--- a/9-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
+++ b/9-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
@@ -1,16 +1,16 @@
-A regexp for a number is: `pattern:-?\d+(\.\d+)?`. We created it in previous tasks.
+Регэксп для числа: `pattern:-?\d+(\.\d+)?`. Мы создали его в предыдущих задачах.
 
-An operator is `pattern:[-+*/]`. We put the dash `pattern:-` first, because in the middle it would mean a character range, we don't need that.
+Регэксп для оператора `pattern:[-+*/]`. Мы вставили тире `pattern:-` в начале, потому что в середине этот символ будет означать диапазон, а нам это не нужно.
 
-Note that a slash should be escaped inside a JavaScript regexp `pattern:/.../`.
+Отметим, что косая черта должна быть экранированна внутри регэксп JavaScript `pattern:/.../`.
 
-We need a number, an operator, and then another number. And optional spaces between them.
+Нам необходимо число, оператор и, затем, другие числа. И необязательные символы пробела между ними.
 
-The full regular expression: `pattern:-?\d+(\.\d+)?\s*[-+*/]\s*-?\d+(\.\d+)?`.
+Полное выражение: `pattern:-?\d+(\.\d+)?\s*[-+*/]\s*-?\d+(\.\d+)?`.
 
-To get a result as an array let's put parentheses around the data that we need: numbers and the operator: `pattern:(-?\d+(\.\d+)?)\s*([-+*/])\s*(-?\d+(\.\d+)?)`.
+Для получения результата в виде массива давайте вставим скобки вокруг данных, которые нам необходимы: чисел и операторов: `pattern:(-?\d+(\.\d+)?)\s*([-+*/])\s*(-?\d+(\.\d+)?)`.
 
-In action:
+В действии:
 
 ```js run
 let reg = /(-?\d+(\.\d+)?)\s*([-+*\/])\s*(-?\d+(\.\d+)?)/;
@@ -18,22 +18,22 @@ let reg = /(-?\d+(\.\d+)?)\s*([-+*\/])\s*(-?\d+(\.\d+)?)/;
 alert( "1.2 + 12".match(reg) );
 ```
 
-The result includes:
+Результат включает:
 
-- `result[0] == "1.2 + 12"` (full match)
-- `result[1] == "1.2"` (first group `(-?\d+(\.\d+)?)` -- the first number, including the decimal part)
-- `result[2] == ".2"` (second group`(\.\d+)?` -- the first decimal part)
-- `result[3] == "+"` (third group `([-+*\/])` -- the operator)
-- `result[4] == "12"` (forth group `(-?\d+(\.\d+)?)` -- the second number)
-- `result[5] == undefined` (fifth group `(\.\d+)?` -- the last decimal part is absent, so it's undefined)
+- `result[0] == "1.2 + 12"` (полное совпадение)
+- `result[1] == "1.2"` (первая группа `(-?\d+(\.\d+)?)` -- первое число, включая десятичную часть)
+- `result[2] == ".2"` (вторая группа `(\.\d+)?` -- первая десятичная часть)
+- `result[3] == "+"` (третья группа `([-+*\/])` -- оператор)
+- `result[4] == "12"` (чертвертая группа `(-?\d+(\.\d+)?)` -- второе число)
+- `result[5] == undefined` (пятая группа `(\.\d+)?` -- вторая десятичная часть отсутствует, поэтому значение `undefined`)
 
-We only want the numbers and the operator, without the full match or the decimal parts.
+Нам необходимы только числа и оператор без полного совпадения или десятичной части.
 
-The full match (the arrays first item) can be removed by shifting the array `pattern:result.shift()`.
+Полное совпадение (первый элемент массива) может быть удален при помощи сдвига массива `pattern:result.shift()`.
 
-The decimal groups can be removed by making them into non-capturing groups, by adding `pattern:?:` to the beginning: `pattern:(?:\.\d+)?`.
+От десятичных групп можно избавиться, если исключить захват скобочной группы добавив `pattern:?:` в начало: `pattern:(?:\.\d+)?`.
 
-The final solution:
+Итоговое решение:
 
 ```js run
 function parse(expr) {

From e4dc2dcec6c209d8615698805a24f1c59189f826 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Tue, 18 Jun 2019 22:42:05 +0300
Subject: [PATCH 15/34] Update task.md

---
 .../5-parse-expression/task.md                 | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/5-parse-expression/task.md b/9-regular-expressions/09-regexp-groups/5-parse-expression/task.md
index 8b54d46832..48afb193e4 100644
--- a/9-regular-expressions/09-regexp-groups/5-parse-expression/task.md
+++ b/9-regular-expressions/09-regexp-groups/5-parse-expression/task.md
@@ -1,23 +1,23 @@
-# Parse an expression
+# Разобрать выражение
 
-An arithmetical expression consists of 2 numbers and an operator between them, for instance:
+Арифметическое выражение включает два числа и оператор между ними. Например:
 
 - `1 + 2`
 - `1.2 * 3.4`
 - `-3 / -6`
 - `-2 - 2`
 
-The operator is one of: `"+"`, `"-"`, `"*"` or `"/"`.
+Оператором может быть: `"+"`, `"-"`, `"*"` или `"/"`.
 
-There may be extra spaces at the beginning, at the end or between the parts.
+В выражении могут быть пробелы вначале, конце или между частями выражения.
 
-Create a function `parse(expr)` that takes an expression and returns an array of 3 items:
+Создайте функцию `parse(expr)`, которая принимает выражение и возвращает массив из трех элементов:
 
-1. The first number.
-2. The operator.
-3. The second number.
+1. Первое число.
+2. Оператор.
+3. Второе число.
 
-For example:
+Например:
 
 ```js
 let [a, op, b] = parse("1.2 * 3.4");

From 7e9f49e91bac141aec69122de007f368d13eae60 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Mon, 24 Jun 2019 09:25:36 +0300
Subject: [PATCH 16/34] Update article.md

---
 .../09-regexp-groups/article.md               | 54 +++++++++----------
 1 file changed, 27 insertions(+), 27 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/article.md b/9-regular-expressions/09-regexp-groups/article.md
index 5a18041e6e..2308da679b 100644
--- a/9-regular-expressions/09-regexp-groups/article.md
+++ b/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>...)`, давать доступ по имени.
-  - исключать из запоминания `(?:...)`, использоваться только для применения квантификатора ко всем группам.
+  - исключать из запоминания `(?:...)`, использоваться только для применения квантификатора ко всей группе символов.

From 57061e8faa7905affee8fad88e19c7fe0af17fc2 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Mon, 24 Jun 2019 09:28:02 +0300
Subject: [PATCH 17/34] Update solution.md

---
 .../09-regexp-groups/1-find-webcolor-3-or-6/solution.md         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md b/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
index 61d9142b69..9bbd05c2a3 100644
--- a/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
+++ b/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
@@ -1,4 +1,4 @@
-Регэксп для поиска номера цвета из трех символов `#abc`: `pattern:/#[a-f0-9]{3}/i`.
+Регулярное выражение для поиска номера цвета из трёх символов `#abc`: `pattern:/#[a-f0-9]{3}/i`.
 
 Мы можем добавить точно 3 дополнительные шестнадцатеричные цифры. Нам не нужно больше или меньше. Либо у нас они есть, либо у нас нет.
 

From 909b88d5ef57e37c5276c168d02f400b2948fc7a Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Mon, 24 Jun 2019 09:35:57 +0300
Subject: [PATCH 18/34] Update solution.md

---
 .../09-regexp-groups/1-find-webcolor-3-or-6/solution.md     | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md b/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
index 9bbd05c2a3..670c5f6957 100644
--- a/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
+++ b/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
@@ -1,12 +1,12 @@
 Регулярное выражение для поиска номера цвета из трёх символов `#abc`: `pattern:/#[a-f0-9]{3}/i`.
 
-Мы можем добавить точно 3 дополнительные шестнадцатеричные цифры. Нам не нужно больше или меньше. Либо у нас они есть, либо у нас нет.
+Мы можем задать ещё ровно 3 дополнительных шестнадцатеричных цифры. Нам не нужно больше или меньше - совпадение либо будет, либо нет.
 
 Простейший способ добавить их -- добавить в регулярное выражение: `pattern:/#[a-f0-9]{3}([a-f0-9]{3})?/i`
 
 Мы можем сделать это более интересным способом: `pattern:/#([a-f0-9]{3}){1,2}/i`.
 
-Этот регэксп `pattern:[a-f0-9]{3}` в скобках для применения квантификатора `pattern:{1,2}` к нему вцелом.
+Регулярное выражение `pattern:[a-f0-9]{3}` заключено в скобки для корректного применения к нему квантификатора `pattern:{1,2}`.
 
 В действии:
 
@@ -18,7 +18,7 @@ let str = "color: #3f3; background-color: #AA00ef; and: #abcd";
 alert( str.match(reg) ); // #3f3 #AA00ef #abc
 ```
 
-Здесь есть небольшая проблема: шаблон находит `match: # abc` в` subject: # abcd`. Чтобы предотвратить это, мы можем добавить `pattern: \ b` в конец:
+Здесь есть небольшая проблема: шаблон находит `match: # abc` в `subject: # abcd`. Чтобы предотвратить это, мы можем добавить `pattern: \ b` в конец:
 
 ```js run
 let reg = /#([a-f0-9]{3}){1,2}\b/gi;

From bcdab02f9afa9af8a8bec7f497e0add13e2dd3ac Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Mon, 24 Jun 2019 10:12:35 +0300
Subject: [PATCH 19/34] Update task.md

---
 .../09-regexp-groups/1-find-webcolor-3-or-6/task.md           | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/task.md b/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/task.md
index b8a16fb6a1..dddc31ae10 100644
--- a/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/task.md
+++ b/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/task.md
@@ -1,6 +1,6 @@
 # Найти цвет в формате #abc или #abcdef
 
-Напишите регэксп, который соответствует цветам в формате `#abc` или `#abcdef`. То есть: `#` и за ним 3 или 6 шестнадцатеричных цифры.
+Напишите регулярное выражение, которое соответствует цветам в формате `#abc` или `#abcdef`. То есть: `#` и за ним 3 или 6 шестнадцатеричных цифр.
 
 Пример использования:
 ```js
@@ -11,4 +11,4 @@ let str = "color: #3f3; background-color: #AA00ef; and: #abcd";
 alert( str.match(reg) ); // #3f3 #AA00ef
 ```
 
-P.S. Это должно быть ровно 3 или 6 шестнадцатеричных цифры, такие как "abcd" не должны совпадать.
+P.S. Это должно быть ровно 3 или 6 шестнадцатеричных цифр. При этом значения типа "abcd" не должны совпадать в результат.

From 354b84a4bb53c2c90af47d7b3921c446720ebbd9 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Mon, 24 Jun 2019 10:15:59 +0300
Subject: [PATCH 20/34] Update solution.md

---
 .../3-find-decimal-positive-numbers/solution.md             | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/solution.md b/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/solution.md
index 62629f0e57..4898f79ee4 100644
--- a/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/solution.md
+++ b/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/solution.md
@@ -1,13 +1,13 @@
 
-Регэксп для неотрицательного целого числа `pattern:\d+`. Мы должны исключить `0` в качестве первой цифры, так как нам не нужен ноль, но мы можем разрешить его появление в составе чисел.
+Регулярное выражение для неотрицательного целого числа `pattern:\d+`. Мы должны исключить `0` в качестве первой цифры, так как нам не нужен ноль, но мы можем разрешить его появление далее.
 
-Нам позволит сделать это регэксп: `pattern:[1-9]\d*`.
+Нам позволит сделать это регулярное выражение: `pattern:[1-9]\d*`.
 
 Десятичная часть находится с помощью: `pattern:\.\d+`.
 
 Поскольку десятичная часть является необязательной, то давайте заключим ее в скобки с квантификатором `pattern:'?'`.
 
-В итоге, мы получаем регэксп: `pattern:[1-9]\d*(\.\d+)?`:
+В итоге, мы получаем регулярное выражение: `pattern:[1-9]\d*(\.\d+)?`:
 
 ```js run
 let reg = /[1-9]\d*(\.\d+)?/g;

From e504b6204ee4f180dfaad8d1a8679a779f885793 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Mon, 24 Jun 2019 10:16:37 +0300
Subject: [PATCH 21/34] Update task.md

---
 .../09-regexp-groups/3-find-decimal-positive-numbers/task.md    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/task.md b/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/task.md
index 3bb81a2df6..1191ffe35d 100644
--- a/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/task.md
+++ b/9-regular-expressions/09-regexp-groups/3-find-decimal-positive-numbers/task.md
@@ -1,6 +1,6 @@
 # Найти положительные числа
 
-Создайте регэксп, который ищет положительные числа, включая числа без десятичной части.
+Создайте регулярное выражение, которое ищет положительные числа, включая числа без десятичной части.
 
 Пример использования:
 ```js

From e57098d78fa4a8011f42f3082d30baf59c3d81bd Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Mon, 24 Jun 2019 10:17:26 +0300
Subject: [PATCH 22/34] Update task.md

---
 .../09-regexp-groups/4-find-decimal-numbers/task.md           | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/task.md b/9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/task.md
index 3061f0ca11..49ecdaad29 100644
--- a/9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/task.md
+++ b/9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/task.md
@@ -1,11 +1,11 @@
 # Найти все числа
 
-Напишите регэксп, который соответствует всем десятичным числам, включая целочисленные, с плавающей точкой и отрицательные.
+Напишите регулярное выражение, которое соответствует всем десятичным числам, включая целочисленные, с плавающей точкой и отрицательные.
 
 Пример использования:
 
 ```js
-let reg = /ваш регэксп/g;
+let reg = /ваше выражение/g;
 
 let str = "-1.5 0 2 -123.4.";
 

From 7de8bb615952f2db3db7e6092a244b1a98ed5344 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Mon, 24 Jun 2019 10:20:08 +0300
Subject: [PATCH 23/34] Update solution.md

---
 .../09-regexp-groups/5-parse-expression/solution.md       | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/5-parse-expression/solution.md b/9-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
index da7fa898aa..d8445e83b1 100644
--- a/9-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
+++ b/9-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
@@ -1,8 +1,8 @@
-Регэксп для числа: `pattern:-?\d+(\.\d+)?`. Мы создали его в предыдущих задачах.
+Регулярное выражение для числа: `pattern:-?\d+(\.\d+)?`. Мы создали его в предыдущих задачах.
 
-Регэксп для оператора `pattern:[-+*/]`. Мы вставили тире `pattern:-` в начале, потому что в середине этот символ будет означать диапазон, а нам это не нужно.
+Регулярное выражение для оператора `pattern:[-+*/]`. Мы вставили тире `pattern:-` в начало выражения, потому что в середине этот символ будет означать диапазон, а нам это не нужно.
 
-Отметим, что косая черта должна быть экранированна внутри регэксп JavaScript `pattern:/.../`.
+Отметим, что косая черта должна быть экранирована внутри регулярного выражения JavaScript `pattern:/.../`.
 
 Нам необходимо число, оператор и, затем, другие числа. И необязательные символы пробела между ними.
 
@@ -31,7 +31,7 @@ alert( "1.2 + 12".match(reg) );
 
 Полное совпадение (первый элемент массива) может быть удален при помощи сдвига массива `pattern:result.shift()`.
 
-От десятичных групп можно избавиться, если исключить захват скобочной группы добавив `pattern:?:` в начало: `pattern:(?:\.\d+)?`.
+От десятичных групп можно избавиться, если исключить захват скобочной группы, добавив `pattern:?:` в начало: `pattern:(?:\.\d+)?`.
 
 Итоговое решение:
 

From d70a5837e5f8c16b0d9585476a4ed8a4f51230fe Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Mon, 24 Jun 2019 10:21:02 +0300
Subject: [PATCH 24/34] Update task.md

---
 .../09-regexp-groups/5-parse-expression/task.md               | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/5-parse-expression/task.md b/9-regular-expressions/09-regexp-groups/5-parse-expression/task.md
index 48afb193e4..c40452279e 100644
--- a/9-regular-expressions/09-regexp-groups/5-parse-expression/task.md
+++ b/9-regular-expressions/09-regexp-groups/5-parse-expression/task.md
@@ -9,9 +9,9 @@
 
 Оператором может быть: `"+"`, `"-"`, `"*"` или `"/"`.
 
-В выражении могут быть пробелы вначале, конце или между частями выражения.
+В выражении могут быть пробелы в начале, в конце или между частями выражения.
 
-Создайте функцию `parse(expr)`, которая принимает выражение и возвращает массив из трех элементов:
+Создайте функцию `parse(expr)`, которая принимает выражение и возвращает массив из трёх элементов:
 
 1. Первое число.
 2. Оператор.

From e4c8a998b3a7d9b6c373e3770517e1ed4b385395 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Mon, 24 Jun 2019 14:43:51 +0300
Subject: [PATCH 25/34] Update solution.md

---
 .../09-regexp-groups/1-find-webcolor-3-or-6/solution.md         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md b/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
index 670c5f6957..fcd1956c1a 100644
--- a/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
+++ b/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
@@ -18,7 +18,7 @@ let str = "color: #3f3; background-color: #AA00ef; and: #abcd";
 alert( str.match(reg) ); // #3f3 #AA00ef #abc
 ```
 
-Здесь есть небольшая проблема: шаблон находит `match: # abc` в `subject: # abcd`. Чтобы предотвратить это, мы можем добавить `pattern: \ b` в конец:
+Здесь есть небольшая проблема: шаблон находит `match:#abc` в `subject:#abcd`. Чтобы предотвратить это, мы можем добавить `pattern:\b` в конец:
 
 ```js run
 let reg = /#([a-f0-9]{3}){1,2}\b/gi;

From 97f1a92ff50f38efa1a3b5c5b03f5fd4da055a60 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Mon, 24 Jun 2019 14:44:38 +0300
Subject: [PATCH 26/34] Update article.md

---
 9-regular-expressions/09-regexp-groups/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/09-regexp-groups/article.md b/9-regular-expressions/09-regexp-groups/article.md
index 2308da679b..ded2ddf057 100644
--- a/9-regular-expressions/09-regexp-groups/article.md
+++ b/9-regular-expressions/09-regexp-groups/article.md
@@ -139,7 +139,7 @@ alert( match[1] ); // undefined, потому что для (z)? ничего н
 alert( match[2] ); // c
 ```
 
-Длинна массива всегда равна `3`. Для группы `pattern:(z)?` ничего нет, поэтому результат `["ac", undefined, "c"]`.
+Длина массива всегда равна `3`. Для группы `pattern:(z)?` ничего нет, поэтому результат `["ac", undefined, "c"]`.
 
 ## Именованные группы
 

From c1a58da1c05429f080a969f15eed8b7a5de0502d Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Tue, 25 Jun 2019 16:53:52 +0300
Subject: [PATCH 27/34] Update solution.md

---
 .../09-regexp-groups/1-find-webcolor-3-or-6/solution.md         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md b/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
index fcd1956c1a..7af0f697ac 100644
--- a/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
+++ b/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/solution.md
@@ -1,6 +1,6 @@
 Регулярное выражение для поиска номера цвета из трёх символов `#abc`: `pattern:/#[a-f0-9]{3}/i`.
 
-Мы можем задать ещё ровно 3 дополнительных шестнадцатеричных цифры. Нам не нужно больше или меньше - совпадение либо будет, либо нет.
+Мы можем задать ещё ровно 3 дополнительных шестнадцатеричных цифры. Нам не нужно больше или меньше - в цвете либо 3, либо 6 цифр.
 
 Простейший способ добавить их -- добавить в регулярное выражение: `pattern:/#[a-f0-9]{3}([a-f0-9]{3})?/i`
 

From bb076a1bb7203ff15960b4e6e73cd8f13268161a Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Tue, 25 Jun 2019 16:54:53 +0300
Subject: [PATCH 28/34] Update task.md

---
 .../09-regexp-groups/1-find-webcolor-3-or-6/task.md             | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/task.md b/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/task.md
index dddc31ae10..f0dad1b0c3 100644
--- a/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/task.md
+++ b/9-regular-expressions/09-regexp-groups/1-find-webcolor-3-or-6/task.md
@@ -11,4 +11,4 @@ let str = "color: #3f3; background-color: #AA00ef; and: #abcd";
 alert( str.match(reg) ); // #3f3 #AA00ef
 ```
 
-P.S. Это должно быть ровно 3 или 6 шестнадцатеричных цифр. При этом значения типа "abcd" не должны совпадать в результат.
+P.S. Это должно быть ровно 3 или 6 шестнадцатеричных цифр. При этом значения типа `#abcd` не должны совпадать в результат.

From 1f7421ab89d611c0d86275e00f630ca0dce683c6 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Tue, 25 Jun 2019 16:55:48 +0300
Subject: [PATCH 29/34] Update task.md

---
 .../09-regexp-groups/4-find-decimal-numbers/task.md             | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/task.md b/9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/task.md
index 49ecdaad29..be6245689d 100644
--- a/9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/task.md
+++ b/9-regular-expressions/09-regexp-groups/4-find-decimal-numbers/task.md
@@ -1,6 +1,6 @@
 # Найти все числа
 
-Напишите регулярное выражение, которое соответствует всем десятичным числам, включая целочисленные, с плавающей точкой и отрицательные.
+Напишите регулярное выражение, которое ищет любые десятичные числа, включая целочисленные, с плавающей точкой и отрицательные.
 
 Пример использования:
 

From 73590f91df252184a418d89fdc5cf91f16c3d0f6 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Tue, 25 Jun 2019 16:56:30 +0300
Subject: [PATCH 30/34] Update solution.md

---
 .../09-regexp-groups/5-parse-expression/solution.md             | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/09-regexp-groups/5-parse-expression/solution.md b/9-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
index d8445e83b1..bdb6d2bcd7 100644
--- a/9-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
+++ b/9-regular-expressions/09-regexp-groups/5-parse-expression/solution.md
@@ -18,7 +18,7 @@ let reg = /(-?\d+(\.\d+)?)\s*([-+*\/])\s*(-?\d+(\.\d+)?)/;
 alert( "1.2 + 12".match(reg) );
 ```
 
-Результат включает:
+Результат `result` включает в себя:
 
 - `result[0] == "1.2 + 12"` (полное совпадение)
 - `result[1] == "1.2"` (первая группа `(-?\d+(\.\d+)?)` -- первое число, включая десятичную часть)

From 07fcbd8ebcd8e4843bfde0f4ccca8a2887a22fb9 Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Tue, 25 Jun 2019 17:05:24 +0300
Subject: [PATCH 31/34] Update article.md

---
 .../09-regexp-groups/article.md               | 24 ++++++++++---------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/article.md b/9-regular-expressions/09-regexp-groups/article.md
index ded2ddf057..a4c76f5852 100644
--- a/9-regular-expressions/09-regexp-groups/article.md
+++ b/9-regular-expressions/09-regexp-groups/article.md
@@ -43,17 +43,17 @@ let reg = /[-.\w]+@([\w-]+\.)+[\w-]{2,20}/g;
 alert("my@mail.com @ his@site.com.uk".match(reg)); // my@mail.com, his@site.com.uk
 ```
 
-В примере скобки используются для создания повторяющейся группы `pattern:(...)+`. Но есть и другие применения. Посмотрим на них.
+В этом примере скобки были использованы для создания повторяющейся группы `pattern:(...)+`. Но есть и другие применения. Посмотрим на них.
 
 ## Содержимое скобок  
 
-Группы скобок нумеруются слева направо. Поисковый движок запоминает содержимое в каждой группе и позволяет ссылаться на него в шаблоне регулярного выражения или строке для замены.
+Скобочные группы нумеруются слева направо. Поисковой движок запоминает содержимое, которое "поймала" каждая группа, и позволяет ссылаться на него в шаблоне регулярного выражения или строке для замены.
 
 Например, мы хотим найти HTML теги `pattern:<.*?>` и обработать их.
 
 Давайте заключим внутреннее содержимое в круглые скобки: `pattern:<(.*?)>`.
 
-Соберём их в массив:
+Мы получим как тег целиком, так и его содержимое в виде массива:
 
 ```js run
 let str = '<h1>Hello, world!</h1>';
@@ -62,7 +62,7 @@ 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>:
 
@@ -126,7 +126,7 @@ alert( match[1] ); // undefined
 alert( match[2] ); // undefined
 ```
 
-Массив имеет длинну `3`, но все скобочные группы пустые.
+Массив имеет длину `3`, но все скобочные группы пустые.
 
 А теперь более сложная ситуация для строки `subject:ack`:
 
@@ -143,9 +143,11 @@ alert( match[2] ); // c
 
 ## Именованные группы
 
-Запоминать группы по числам сложно. Для простых шаблонов это допустимо, но в более сложных случаях мы можем давать имена скобкам.
+Запоминать группы по номерам не очень удобно. Для простых шаблонов это допустимо, но в более сложных случаях мы можем давать скобкам имена.
 
-Это делается добавлением `pattern:?<name>` непосредственно после открытия скобки. Например:
+Это делается добавлением `pattern:?<name>` непосредственно после открытия скобки.
+
+Например:
 
 ```js run
 *!*
@@ -162,9 +164,9 @@ alert(groups.day); // 30
 
 Как вы можете видеть, группы располагаются в свойстве  `.groups` совпадения.
 
-Мы также можем использовать их для замены, как `pattern:$<name>` (как в случае с `$1..9`, но использовать имя вместо цифры).
+Мы также можем использовать их в строке замены как `pattern:$<name>` (аналогично `$1..9`, но имя вместо цифры).
 
-Например, давайте переделаем информацию о дате `day.month.year`:
+Например, давайте поменяем формат даты в `день.месяц.год`:
 
 ```js run
 let dateRegexp = /(?<year>[0-9]{4})-(?<month>[0-9]{2})-(?<day>[0-9]{2})/;
@@ -176,7 +178,7 @@ let rearranged = str.replace(dateRegexp, '$<day>.$<month>.$<year>');
 alert(rearranged); // 30.04.2019
 ```
 
-Если используем функцию, тогда именованный объект `groups` всегда является последним аргументом:
+Если используем функцию для замены, тогда именованный объект `groups` всегда является последним аргументом:
 
 ```js run
 let dateRegexp = /(?<year>[0-9]{4})-(?<month>[0-9]{2})-(?<day>[0-9]{2})/;
@@ -193,7 +195,7 @@ alert(rearranged); // 30.04.2019
 
 Обычно, когда мы планируем использовать именованные группы, то из всех аргументов функции нам нужны только `str` и` groups`.
 
-Таким образом, мы можем переписать код:
+Так что мы можем написать код чуть короче:
 
 ```js
 let rearranged = str.replace(dateRegexp, (str, ...args) => {

From 70a75f6fa8435d0b7761f8576670efbab018914c Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Tue, 25 Jun 2019 17:32:10 +0300
Subject: [PATCH 32/34] Update article.md

---
 9-regular-expressions/09-regexp-groups/article.md | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/article.md b/9-regular-expressions/09-regexp-groups/article.md
index a4c76f5852..bd9fc4b580 100644
--- a/9-regular-expressions/09-regexp-groups/article.md
+++ b/9-regular-expressions/09-regexp-groups/article.md
@@ -233,7 +233,12 @@ alert( result[1] ); // John
 
 ## Итого
 
-- Скобки могут:
-  - запоминать `(...)`, нумеровать слева направо, давать доступ по номеру.
-  - именовать группы `(?<name>...)`, давать доступ по имени.
-  - исключать из запоминания `(?:...)`, использоваться только для применения квантификатора ко всей группе символов.
+Круглые скобки объединяют часть регулярного выражения, так что квантификатор применяется к нему в целом.
+
+Группы в круглых скобках нумеруются слева направо и могут опционально именоваться с помощью `(?<name>...)`.
+
+На контент, сопоставляемый группой, можно ссылаться в строке замены через `$1`, `$2` и т.д. или по имени `$name`, если он именован.
+
+Группы в скобках называются «скобочными группами», поскольку они «захватывают» часть сопостовляемого контента. Мы получаем эту часть отдельно от результата.
+
+Можно исключить скобочную группу из запоминания, добавив в её начало `pattern:?:` -- `(?:...)`. Это используется, если необходимо применить квантификатор ко всей группе, но исключить попадание их содержимого в результат.

From af77e1e24092b631fc366a92a3bf0c08555c3dae Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Tue, 25 Jun 2019 17:35:12 +0300
Subject: [PATCH 33/34] Update article.md

---
 9-regular-expressions/09-regexp-groups/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/9-regular-expressions/09-regexp-groups/article.md b/9-regular-expressions/09-regexp-groups/article.md
index bd9fc4b580..f541c04e41 100644
--- a/9-regular-expressions/09-regexp-groups/article.md
+++ b/9-regular-expressions/09-regexp-groups/article.md
@@ -239,6 +239,6 @@ alert( result[1] ); // John
 
 На контент, сопоставляемый группой, можно ссылаться в строке замены через `$1`, `$2` и т.д. или по имени `$name`, если он именован.
 
-Группы в скобках называются «скобочными группами», поскольку они «захватывают» часть сопостовляемого контента. Мы получаем эту часть отдельно от результата.
+Группы в скобках называются «скобочными группами», поскольку они «захватывают» часть сопостовляемого контента и мы получаем эту часть отдельно от результата.
 
 Можно исключить скобочную группу из запоминания, добавив в её начало `pattern:?:` -- `(?:...)`. Это используется, если необходимо применить квантификатор ко всей группе, но исключить попадание их содержимого в результат.

From be3de9604c097776d166b55542f5e43ce1cbd97d Mon Sep 17 00:00:00 2001
From: Anton Kolesnikov <achallenge@yandex.ru>
Date: Thu, 27 Jun 2019 11:31:13 +0300
Subject: [PATCH 34/34] Update article.md

---
 9-regular-expressions/09-regexp-groups/article.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/9-regular-expressions/09-regexp-groups/article.md b/9-regular-expressions/09-regexp-groups/article.md
index f541c04e41..051653e3eb 100644
--- a/9-regular-expressions/09-regexp-groups/article.md
+++ b/9-regular-expressions/09-regexp-groups/article.md
@@ -233,12 +233,12 @@ alert( result[1] ); // John
 
 ## Итого
 
-Круглые скобки объединяют часть регулярного выражения, так что квантификатор применяется к нему в целом.
+Круглые скобки группируют вместе часть регулярного выражения, так что квантификатор применяется к ним в целом.
 
-Группы в круглых скобках нумеруются слева направо и могут опционально именоваться с помощью `(?<name>...)`.
+Скобочные группы нумеруются слева направо и могут опционально именоваться с помощью `(?<name>...)`.
 
-На контент, сопоставляемый группой, можно ссылаться в строке замены через `$1`, `$2` и т.д. или по имени `$name`, если он именован.
+На текст совпадения, соответствующий скобочной группе, можно ссылаться в строке замены через `$1`, `$2` и т.д. или по имени `$name`, если она именована.
 
-Группы в скобках называются «скобочными группами», поскольку они «захватывают» часть сопостовляемого контента и мы получаем эту часть отдельно от результата.
+Часть совпадения, соответствующую скобочной группе, мы также получаем в результатах поиска, отдельным элементом массива (или в `.groups`, если группа именована).
 
 Можно исключить скобочную группу из запоминания, добавив в её начало `pattern:?:` -- `(?:...)`. Это используется, если необходимо применить квантификатор ко всей группе, но исключить попадание их содержимого в результат.