Merge pull request #220 from NancyT33333/11-regexp-alternation

9-regular-expressions/11-regexp-alternation/

Author: javascript-translate-bot

9-regular-expressions/11-regexp-alternation/01-find-programming-language/solution.md

@@ -1,7 +1,7 @@
 
-The first idea can be to list the languages with `|` in-between.
+Первая идея, которая может прийти в голову -- перечислить языки, разделив их `|`.
 
-But that doesn't work right:
+Но это не сработает, как надо:
 
 ```js run
 let reg = /Java|JavaScript|PHP|C|C\+\+/g;
@@ -11,18 +11,18 @@ let str = "Java, JavaScript, PHP, C, C++";
 alert( str.match(reg) ); // Java,Java,PHP,C,C
 ```
 
-The regular expression engine looks for alternations one-by-one. That is: first it checks if we have  `match:Java`, otherwise -- looks for `match:JavaScript` and so on.
+Движок регулярных выражений ищет альтернации в порядке их перечисления. То есть, он сначала смотрит, есть ли  `match:Java`, а если нет -- ищет  `match:JavaScript` и так далее.
 
-As a result, `match:JavaScript` can never be found, just because `match:Java` is checked first.
+В результате `match:JavaScript` не будет найден никогда, только потому что `match:Java` проверяется первым.
 
-The same with `match:C` and `match:C++`.
+То же самое -- с языками `match:C` и `match:C++`.
 
-There are two solutions for that problem:
+Есть два решения проблемы:
 
-1. Change the order to check the longer match first: `pattern:JavaScript|Java|C\+\+|C|PHP`.
-2. Merge variants with the same start: `pattern:Java(Script)?|C(\+\+)?|PHP`.
+1. Поменять порядок, чтобы более длинное совпадение проверялось первым:  `pattern:JavaScript|Java|C\+\+|C|PHP`.
+2. Соединить одинаково начинающиеся варианты: `pattern:Java(Script)?|C(\+\+)?|PHP`.
 
-In action:
+В действии:
 
 ```js run
 let reg = /Java(Script)?|C(\+\+)?|PHP/g;

9-regular-expressions/11-regexp-alternation/01-find-programming-language/task.md

@@ -1,11 +1,11 @@
-# Find programming languages
+# Найдите языки программирования
 
-There are many programming languages, for instance Java, JavaScript, PHP, C, C++.
+Существует много языков программирования, например, Java, JavaScript, PHP, C, C++.
 
-Create a regexp that finds them in the string `subject:Java JavaScript PHP C++ C`:
+Напишите регулярное выражение, которое найдёт их все в строке `subject:Java JavaScript PHP C++ C`:
 
 ```js
-let reg = /your regexp/g;
+let reg = /ваше регулярное выражение/флаги;
 
 alert("Java JavaScript PHP C++ C".match(reg)); // Java JavaScript PHP C++ C
 ```

9-regular-expressions/11-regexp-alternation/02-find-matching-bbtags/solution.md

@@ -1,23 +1,23 @@
 
-Opening tag is `pattern:\[(b|url|quote)\]`.
+Открывающий тег -- это `pattern:\[(b|url|quote)\]`.
 
-Then to find everything till the closing tag -- let's use the pattern `pattern:.*?` with flag `s` to match any character including the newline and then add a backreference to the closing tag.
+Затем, чтобы найти всё до закрывающего тега -- используем выражение `pattern:.*?` с флагом `s`: оно найдет любые символы, включая новую строку, и затем добавим обратную ссылку на открывающий тег.
 
-The full pattern: `pattern:\[(b|url|quote)\].*?\[/\1\]`.
+Полное выражение: `pattern:\[(b|url|quote)\].*?\[/\1\]`.
 
-In action:
+В действии:
 
 ```js run
-let reg = /\[(b|url|quote)\].*?\[\/\1\]/gs;
+let reg = /[(b|url|quote)].*?[/\1]/gs;
 
 let str = `
-  [b]hello![/b]
+  [b]привет![/b]
   [quote]
-    [url]http://google.com[/url]
+    [url]http://ya.ru[/url]
   [/quote]
 `;
 
-alert( str.match(reg) ); // [b]hello![/b],[quote][url]http://google.com[/url][/quote]
+alert( str.match(reg) ); // [b]привет![/b],[quote][url]http://ya.ru[/url][/quote]
 ```
 
-Please note that we had to escape a slash for the closing tag `pattern:[/\1]`, because normally the slash closes the pattern.
+Обратите внимание, что необходимо экранировать слеш `pattern:[/\1]`, потому что обычно слеш завершает паттерн.

9-regular-expressions/11-regexp-alternation/02-find-matching-bbtags/task.md

@@ -1,48 +1,48 @@
-# Find bbtag pairs
+# Найдите пары BB-кодов
 
-A "bb-tag" looks like `[tag]...[/tag]`, where `tag` is one of: `b`, `url` or `quote`.
+[BB-код](https://ru.wikipedia.org/wiki/BBCode) имеет вид `[tag]...[/tag]`, где `tag`-- это один из: `b`, `url` или `quote`.
 
-For instance:
+Например:
 ```
-[b]text[/b]
-[url]http://google.com[/url]
+[b]текст[/b]
+[url]http://ya.ru[/url]
 ```
 
-BB-tags can be nested. But a tag can't be nested into itself, for instance:
+BB-коды могут быть вложенными. Но сам в себя тег быть вложен не может, например:
 
 ```
-Normal:
-[url] [b]http://google.com[/b] [/url]
-[quote] [b]text[/b] [/quote]
+Допустимо:
+[url] [b]http://ya.ru[/b] [/url]
+[quote] [b]текст[/b] [/quote]
 
-Impossible:
-[b][b]text[/b][/b]
+Нельзя:
+[b][b]текст[/b][/b]
 ```
 
-Tags can contain line breaks, that's normal:
+Теги могут содержать переносы строк, это допустимо:
 
 ```
 [quote]
-  [b]text[/b]
+  [b]текст[/b]
 [/quote]
 ```
 
-Create a regexp to find all BB-tags with their contents.
+Создайте регулярное выражение для поиска всех BB-кодов и их содержимого.
 
-For instance:
+Например:
 
 ```js
-let reg = /your regexp/flags;
+let reg = /ваше регулярное выражение/флаги;
 
-let str = "..[url]http://google.com[/url]..";
-alert( str.match(reg) ); // [url]http://google.com[/url]
+let str = "..[url]http://ya.ru[/url]..";
+alert( str.match(reg) ); // [url]http://ya.ru[/url]
 ```
 
-If tags are nested, then we need the outer tag (if we want we can continue the search in its content):
+Если теги вложены, то нужно искать самый внешний тег (при желании можно продолжить поиск в его содержимом):
 
 ```js
-let reg = /your regexp/flags;
+let reg = /ваше регулярное выражение/флаги;
 
-let str = "..[url][b]http://google.com[/b][/url]..";
-alert( str.match(reg) ); // [url][b]http://google.com[/b][/url]
+let str = "..[url][b]http://ya.ru[/b][/url]..";
+alert( str.match(reg) ); // [url][b]http://ya.ru[/b][/url]
 ```

9-regular-expressions/11-regexp-alternation/03-match-quoted-string/solution.md

@@ -1,17 +1,17 @@
-The solution: `pattern:/"(\\.|[^"\\])*"/g`.
+Решение: `pattern:/"(\\.|[^"\\])*"/g`.
 
-Step by step:
+Шаг за шагом:
 
-- First we look for an opening quote `pattern:"`
-- Then if we have a backslash `pattern:\\` (we technically have to double it in the pattern, because it is a special character, so that's a single backslash in fact), then any character is fine after it (a dot).
-- Otherwise we take any character except a quote (that would mean the end of the string) and a backslash (to prevent lonely backslashes, the backslash is only used with some other symbol after it): `pattern:[^"\\]`
-- ...And so on till the closing quote.
+- Сначала ищем открывающую кавычку `pattern:"`
+- Затем, если есть обратный слеш `pattern:\\` (удвоение обратного слеша – техническое, потому что это спец.символ, на самом деле там один обратный слеш), то после него также подойдёт любой символ (точка).
+- Иначе берём любой символ, кроме кавычек (которые будут означать конец строки) и обратного слеша (чтобы предотвратить одинокие обратные слеши, сам по себе единственный обратный слеш не нужен, он должен экранировать какой-то символ) `pattern:[^"\\]`
+- ...И так далее, до закрывающей кавычки.
 
-In action:
+В действии:
 
 ```js run
 let reg = /"(\\.|[^"\\])*"/g;
-let str = ' .. "test me" .. "Say \\"Hello\\"!" .. "\\\\ \\"" .. ';
+let str = ' .. "test me" .. "Скажи \\"Привет\\"!" .. "\\\\ \\"" .. ';
 
-alert( str.match(reg) ); // "test me","Say \"Hello\"!","\\ \""
+alert( str.match(reg) ); // "test me","Скажи \"Привет\"!","\\ \""
 ```

9-regular-expressions/11-regexp-alternation/03-match-quoted-string/task.md

@@ -1,32 +1,32 @@
-# Find quoted strings
+# Найдите строки в кавычках
 
-Create a regexp to find strings in double quotes `subject:"..."`.
+Создайте регулярное выражение для поиска строк в двойных кавычках `subject:"..."`.
 
-The strings should support escaping, the same way as JavaScript strings do. For instance, quotes can be inserted as `subject:\"` a newline as `subject:\n`, and the slash itself as `subject:\\`.
+Важно, что строки должны поддерживать экранирование с помощью обратного слеша, по аналогии со строками JavaScript. Например, кавычки могут быть вставлены как `subject:\"`, новая строка как `subject:\n`, а сам обратный слеш как `subject:\\`.
 
 ```js
-let str = "Just like \"here\".";
+let str = "Как вот \"здесь\".";
 ```
 
-Please note, in particular, that an escaped quote `subject:\"` does not end a string.
+В частности, обратите внимание: двойная кавычка после обратного слеша `subject:\"` не оканчивает строку.
 
-So we should search from one quote to the other ignoring escaped quotes on the way.
+Поэтому мы должны искать от одной кавычки до другой, игнорируя встречающиеся экранированные кавычки. 
 
-That's the essential part of the task, otherwise it would be trivial.
+В этом и состоит основная сложность задачи, которая без этого условия была бы элементарной.
 
-Examples of strings to match:
+Примеры подходящих строк:
 ```js
 .. *!*"test me"*/!* ..  
-.. *!*"Say \"Hello\"!"*/!* ... (escaped quotes inside)
-.. *!*"\\"*/!* ..  (double slash inside)
-.. *!*"\\ \""*/!* ..  (double slash and an escaped quote inside)
+.. *!*"Скажи \"Привет\"!"*/!* ... (строка с экранированными кавычками)
+.. *!*"\\"*/!* ..  (внутри двойной слеш)
+.. *!*"\\ \""*/!* ..  (внутри двойной слеш и экранированная кавычка)
 ```
 
-In JavaScript we need to double the slashes to pass them right into the string, like this:
+В JavaScript приходится удваивать обратные слеши, чтобы добавлять их в строку, как здесь:
 
 ```js run
-let str = ' .. "test me" .. "Say \\"Hello\\"!" .. "\\\\ \\"" .. ';
+let str = ' .. "test me" .. "Скажи \\"Привет\\"!" .. "\\\\ \\"" .. ';
 
-// the in-memory string
-alert(str); //  .. "test me" .. "Say \"Hello\"!" .. "\\ \"" ..
+// эта строка в памяти:
+alert(str); //  .. "test me" .. "Скажи \"Привет\"!" .. "\\ \"" ..
 ```

9-regular-expressions/11-regexp-alternation/04-match-exact-tag/solution.md

@@ -1,13 +1,13 @@
 
-The pattern start is obvious: `pattern:<style`.
+Начало шаблона очевидно: `pattern:<style`.
 
-...But then we can't simply write `pattern:<style.*?>`, because `match:<styler>` would match it.
+...А вот дальше… Мы не можем написать просто `pattern:<style.*?>`, потому что `match:<styler>` удовлетворяет этому выражению.
 
-We need either a space after `match:<style` and then optionally something else or the ending `match:>`.
+После `match:<style` должен быть либо пробел, после которого может быть что-то ещё, либо закрытие тега `match:>`.
 
-In the regexp language: `pattern:<style(>|\s.*?>)`.
+На языке регулярных выражений: `pattern:<style(>|\s.*?>)`.
 
-In action:
+В действии:
 
 ```js run
 let reg = /<style(>|\s.*?>)/g;

9-regular-expressions/11-regexp-alternation/04-match-exact-tag/task.md

@@ -1,13 +1,13 @@
-# Find the full tag
+# Найдите весь тег
 
-Write a regexp to find the tag `<style...>`. It should match the full tag: it may have no attributes  `<style>` or have several of them `<style type="..." id="...">`.
+Напишите регулярное выражение, которое ищет тег `<style...>`. Оно должно искать весь тег: он может как не иметь атрибутов  `<style>`, так и иметь несколько `<style type="..." id="...">`.
 
-...But the regexp should not match `<styler>`!
+...Но регулярное выражение не должно находить `<styler>`!
 
-For instance:
+Например:
 
 ```js
-let reg = /your regexp/g;
+let reg = /ваше регулярное выражение/g;
 
 alert( '<style> <styler> <style test="...">'.match(reg) ); // <style>, <style test="...">
 ```

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

@@ -1,56 +1,56 @@
-# Alternation (OR) |
+# Альтернация (или) |
 
-Alternation is the term in regular expression that is actually a simple "OR".
+Альтернация – термин в регулярных выражениях, которому в русском языке соответствует слово «ИЛИ». 
 
-In a regular expression it is denoted with a vertical line character `pattern:|`.
+В регулярных выражениях она обозначается символом вертикальной черты `pattern:|`.
 
-For instance, we need to find programming languages: HTML, PHP, Java or JavaScript.
+Например, нам нужно найти языки программирования: HTML, PHP, Java и JavaScript.
 
-The corresponding regexp: `pattern:html|php|java(script)?`.
+Соответствующее регулярное выражение: `pattern:html|php|java(script)?`.
 
-A usage example:
+Пример использования:
 
 ```js run
 let reg = /html|php|css|java(script)?/gi;
 
-let str = "First HTML appeared, then CSS, then JavaScript";
+let str = "Сначала появился HTML, затем CSS, потом JavaScript";
 
 alert( str.match(reg) ); // 'HTML', 'CSS', 'JavaScript'
 ```
 
-We already know a similar thing -- square brackets. They allow to choose between multiple character, for instance `pattern:gr[ae]y` matches `match:gray` or `match:grey`.
+Мы уже знакомы с подобным -- квадратные скобки. Они позволяют выбирать между несколькими символами, например  `pattern:gr[ae]y` найдёт `match:gray`, либо `match:grey`.
 
-Square brackets allow only characters or character sets. Alternation allows any expressions. A regexp `pattern:A|B|C` means one of expressions `A`, `B` or `C`.
+Квадратные скобки работают только с символами или наборами символов. Альтернация работает с любыми выражениями. Регулярное выражение `pattern:A|B|C` обозначает поиск одного из выражений: `A`, `B` или `C`.
 
-For instance:
+Например:
 
-- `pattern:gr(a|e)y` means exactly the same as `pattern:gr[ae]y`.
-- `pattern:gra|ey` means `match:gra` or `match:ey`.
+- `pattern:gr(a|e)y` означает точно то же, что и `pattern:gr[ae]y`.
+- `pattern:gra|ey` означает `match:gra` или `match:ey`.
 
-To separate a part of the pattern for alternation we usually enclose it in parentheses, like this: `pattern:before(XXX|YYY)after`.
+Для отделения части паттерна с альтернацией мы обычно заключаем её в скобки, как здесь: `pattern:before(XXX|YYY)after`.
 
-## Regexp for time
+## Регулярное выражение для времени
 
-In previous chapters there was a task to build a regexp for searching time in the form `hh:mm`, for instance `12:00`. But a simple `pattern:\d\d:\d\d` is too vague. It accepts `25:99` as the time (as 99 seconds match the pattern).
+В предыдущих главах было задание написать регулярное выражение для поиска времени в формате  `чч:мм`, например `12:00`. Но паттерн `pattern:\d\d:\d\d` слишком неопределённый. Он принимает `25:99` за время (99 секунд подходят под паттерн, но так не должно быть).
 
-How can we make a better one?
+Как сделать лучшее выражение?
 
-We can apply more careful matching. First, the hours:
+Мы можем применить более тщательное сравнение. Во-первых, часы: 
 
-- If the first digit is `0` or `1`, then the next digit can by anything.
-- Or, if the first digit is `2`, then the next must be `pattern:[0-3]`.
+- Если первая цифра `0` или `1`, тогда следующая цифра может быть любой.
+- Или если первая цифра `2`, тогда следующая должна быть `pattern:[0-3]`.
 
-As a regexp: `pattern:[01]\d|2[0-3]`.
+В виде регулярного выражения: `pattern:[01]\d|2[0-3]`.
 
-Next, the minutes must be from `0` to `59`. In the regexp language that means `pattern:[0-5]\d`: the first digit `0-5`, and then any digit.
+Затем, минуты должны быть от `0` до `59`. На языке регулярных выражений это означает `pattern:[0-5]\d`: первая цифра `0-5`, а за ней любая.
 
-Let's glue them together into the pattern: `pattern:[01]\d|2[0-3]:[0-5]\d`.
+Давайте соединим их в одно выражение: `pattern:[01]\d|2[0-3]:[0-5]\d`.
 
-We're almost done, but there's a problem. The alternation `pattern:|` now happens to be between `pattern:[01]\d` and `pattern:2[0-3]:[0-5]\d`.
+Почти готово, но есть проблема. Сейчас альтернация `pattern:|` выбирает между `pattern:[01]\d` и `pattern:2[0-3]:[0-5]\d`.
 
-That's wrong, as it should be applied only to hours `[01]\d` OR `2[0-3]`. That's a common mistake when starting to work with regular expressions.
+Это неправильно, так как она должна примениться только к часам `[01]\d` ИЛИ `2[0-3]`. Это частая ошибка в начале работы с регулярными выражениями. 
 
-The correct variant:
+Правильный вариант:
 
 ```js run
 let reg = /([01]\d|2[0-3]):[0-5]\d/g;