regexp

Author: iliakan

9-regular-expressions/11-regexp-groups/01-test-mac/solution.md

@@ -0,0 +1,21 @@
+A two-digit hex number is `pattern:[0-9a-f]{2}` (assuming the flag `pattern:i` is set).
+
+We need that number `NN`, and then `:NN` repeated 5 times (more numbers);
+
+The regexp is: `pattern:[0-9a-f]{2}(:[0-9a-f]{2}){5}`
+
+Now let's show that the match should capture all the text: start at the beginning and end at the end. That's done by wrapping the pattern in `pattern:^...$`.
+
+Finally:
+
+```js run
+let reg = /^[0-9a-fA-F]{2}(:[0-9a-fA-F]{2}){5}$/i;
+
+alert( reg.test('01:32:54:67:89:AB') ); // true
+
+alert( reg.test('0132546789AB') ); // false (no colons)
+
+alert( reg.test('01:32:54:67:89') ); // false (5 numbers, need 6)
+
+alert( reg.test('01:32:54:67:89:ZZ') ) // false (ZZ in the end)
+```

9-regular-expressions/11-regexp-groups/01-test-mac/task.md

@@ -0,0 +1,20 @@
+# Check MAC-address
+
+[MAC-address](https://en.wikipedia.org/wiki/MAC_address) of a network interface consists of 6 two-digit hex numbers separated by a colon.
+
+For instance: `subject:'01:32:54:67:89:AB'`.
+
+Write a regexp that checks whether a string is MAC-address.
+
+Usage:
+```js
+let reg = /your regexp/;
+
+alert( reg.test('01:32:54:67:89:AB') ); // true
+
+alert( reg.test('0132546789AB') ); // false (no colons)
+
+alert( reg.test('01:32:54:67:89') ); // false (5 numbers, must be 6)
+
+alert( reg.test('01:32:54:67:89:ZZ') ) // false (ZZ ad the end)
+```

…roups/1-find-webcolor-3-or-6/solution.md …oups/02-find-webcolor-3-or-6/solution.md9-regular-expressions/11-regexp-groups/1-find-webcolor-3-or-6/solution.md renamed to 9-regular-expressions/11-regexp-groups/02-find-webcolor-3-or-6/solution.md 9-regular-expressions/11-regexp-groups/1-find-webcolor-3-or-6/solution.md renamed to 9-regular-expressions/11-regexp-groups/02-find-webcolor-3-or-6/solution.md

@@ -65,7 +65,7 @@ That regexp is not perfect, but mostly works and helps to fix accidental mistype
 
 ## Parentheses contents in the match
 
-Parentheses are numbered from left to right. The search engine remembers the content matched by each of them and allows to get it in the result.
+Parentheses are numbered from left to right. The search engine memorizes the content matched by each of them and allows to get it in the result.
 
 The method `str.match(regexp)`, if `regexp` has no flag `g`, looks for the first match and returns it as an array:
 
@@ -347,4 +347,4 @@ If the parentheses have no name, then their contents is available in the match a
 
 We can also use parentheses contents in the replacement string in `str.replace`: by the number `$n` or the name `$<name>`.
 
-A group may be excluded from remembering by adding `pattern:?:` in its start. That's used when we need to apply a quantifier to the whole group, but don't remember it as a separate item in the results array. We also can't reference such parentheses in the replacement string.
+A group may be excluded from numbering by adding `pattern:?:` in its start. That's used when we need to apply a quantifier to the whole group, but don't want it as a separate item in the results array. We also can't reference such parentheses in the replacement string.

…xp-groups/1-find-webcolor-3-or-6/task.md …p-groups/02-find-webcolor-3-or-6/task.md9-regular-expressions/11-regexp-groups/1-find-webcolor-3-or-6/task.md renamed to 9-regular-expressions/11-regexp-groups/02-find-webcolor-3-or-6/task.md 9-regular-expressions/11-regexp-groups/1-find-webcolor-3-or-6/task.md renamed to 9-regular-expressions/11-regexp-groups/02-find-webcolor-3-or-6/task.md

@@ -1,31 +1,31 @@
-# Backreferences in pattern: \n and \k
+# Backreferences in pattern: \N and \k<name>
 
-We can use the contents of capturing groups `(...)` not only in the result or in the replacement string, but also in the pattern itself.
+We can use the contents of capturing groups `pattern:(...)` not only in the result or in the replacement string, but also in the pattern itself.
 
-## Backreference by number: \n
+## Backreference by number: \N
 
-A group can be referenced in the pattern using `\n`, where `n` is the group number.
+A group can be referenced in the pattern using `pattern:\N`, where `N` is the group number.
 
-To make things clear let's consider a task.
+To make clear why that's helpful, let's consider a task.
 
-We need to find a quoted string: either a single-quoted `subject:'...'` or a double-quoted `subject:"..."` -- both variants need to match.
+We need to find quoted strings: either single-quoted `subject:'...'` or a double-quoted `subject:"..."` -- both variants should match.
 
-How to look for them?
+How to find them?
 
-We can put both kinds of quotes in the square brackets: `pattern:['"](.*?)['"]`, but it would find strings with mixed quotes, like `match:"...'` and `match:'..."`. That would lead to incorrect matches when one quote appears inside other ones, like the string `subject:"She's the one!"`:
+We can put both kinds of quotes in the square brackets: `pattern:['"](.*?)['"]`, but it would find strings with mixed quotes, like `match:"...'` and `match:'..."`. That would lead to incorrect matches when one quote appears inside other ones, like in the string `subject:"She's the one!"`:
 
 ```js run
 let str = `He said: "She's the one!".`;
 
 let reg = /['"](.*?)['"]/g;
 
-// The result is not what we expect
+// The result is not what we'd like to have
 alert( str.match(reg) ); // "She'
 ```
 
-As we can see, the pattern found an opening quote `match:"`, then the text is consumed lazily till the other quote `match:'`, that closes the match.
+As we can see, the pattern found an opening quote `match:"`, then the text is consumed till the other quote `match:'`, that closes the match.
 
-To make sure that the pattern looks for the closing quote exactly the same as the opening one, we can wrap it into a capturing group and use the backreference.
+To make sure that the pattern looks for the closing quote exactly the same as the opening one, we can wrap it into a capturing group and backreference it: `pattern:(['"])(.*?)\1`.
 
 Here's the correct code:
 
@@ -39,20 +39,27 @@ let reg = /(['"])(.*?)\1/g;
 alert( str.match(reg) ); // "She's the one!"
 ```
 
-Now it works! The regular expression engine finds the first quote `pattern:(['"])` and remembers the content of `pattern:(...)`, that's the first capturing group.
+Now it works! The regular expression engine finds the first quote `pattern:(['"])` and memorizes its content. That's the first capturing group.
 
 Further in the pattern `pattern:\1` means "find the same text as in the first group", exactly the same quote in our case.
 
-Please note:
+Similar to that, `pattern:\2` would mean the contents of the second group, `pattern:\3` - the 3rd group, and so on.
 
-- To reference a group inside a replacement string -- we use `$1`, while in the pattern -- a backslash `\1`.
-- If we use `?:` in the group, then we can't reference it. Groups that are excluded from capturing `(?:...)` are not remembered by the engine.
+```smart
+If we use `?:` in the group, then we can't reference it. Groups that are excluded from capturing `(?:...)` are not memorized by the engine.
+```
+
+```warn header="Don't mess up: in the pattern `pattern:\1`, in the replacement: `pattern:$1`"
+In the replacement string we use a dollar sign: `pattern:$1`, while in the pattern - a backslash `pattern:\1`.
+```
 
 ## Backreference by name: `\k<name>`
 
-For named groups, we can backreference by `\k<name>`.
+If a regexp has many parentheses, it's convenient to give them names.
+
+To reference a named group we can use `pattern:\k<имя>`.
 
-The same example with the named group:
+In the example below the group with quotes is named `pattern:?<quote>`, so the backreference is `pattern:\k<quote>`:
 
 ```js run
 let str = `He said: "She's the one!".`;