ok

Author: iliakan

10-regular-expressions-javascript/02-regexp-methods/article.md

@@ -48,7 +48,7 @@ alert( result.input ); // "Fame is the thirst of youth" (the string)
 
 The array may have more than one element.
 
-**If a part of the pattern is delimited by brackets `(...)`, then it becomes a separate element of the array.**
+**If a part of the pattern is delimited by parentheses `(...)`, then it becomes a separate element of the array.**
 
 For instance:
 
@@ -58,18 +58,18 @@ lar str = "JavaScript is a programming language";
 let result = str.match( *!*/JAVA(SCRIPT)/i*/!* );
 
 alert( result[0] ); // JavaScript (the whole match)
-alert( result[1] ); // script (the part of the match that corresponds to the brackets)
+alert( result[1] ); // script (the part of the match that corresponds to the parentheses)
 alert( result.index ); // 0
 alert( result.input ); // JavaScript is a programming language
 ```
 
 Due to the `i` flag the search is case-insensitive, so it finds `match:JavaScript`. The part of the match that corresponds to `pattern:SCRIPT` becomes a separate array item.
 
-We'll be back to brackets later in the chapter [todo]. They are great for search-and-replace.
+We'll be back to parentheses later in the chapter <info:regexp-groups>. They are great for search-and-replace.
 
 ## str.match(reg) with "g" flag
 
-When there's a `"g"` flag, then `str.match` returns an array of all matches. There are no additional properties in that array, and brackets do not create any elements.
+When there's a `"g"` flag, then `str.match` returns an array of all matches. There are no additional properties in that array, and parentheses do not create any elements.
 
 For instance:
 
@@ -81,9 +81,7 @@ let result = str.match( *!*/ho/ig*/!* );
 alert( result ); // HO, Ho, ho (all matches, case-insensitive)
 ```
 
-With brackets nothing changes, here we go:
-
-
+With parentheses nothing changes, here we go:
 
 ```js run
 let str = "HO-Ho-ho!";
@@ -95,7 +93,7 @@ alert( result ); // HO, Ho, ho
 
 So, with `g` flag the `result` is a simple array of matches. No additional properties.
 
-If we want to get information about match positions and use brackets then we should use  [RegExp#exec](mdn:js/RegExp/exec) method that we'll cover below.
+If we want to get information about match positions and use parentheses then we should use  [RegExp#exec](mdn:js/RegExp/exec) method that we'll cover below.
 
 ````warn header="If there are no matches, the call to `match` returns `null`"
 Please note, that's important. If there were no matches, the result is not an empty array, but `null`.
@@ -155,7 +153,7 @@ We can use special characters in it:
 |`$&`|the whole match|
 |<code>$&#096;</code>|a part of the string before the match|
 |`$'`|a part of the string after the match|
-|`$n`|if `n` is a 1-2 digit number, then it means the contents of n-th brackets counting fro left to right|
+|`$n`|if `n` is a 1-2 digit number, then it means the contents of n-th parentheses counting fro left to right|
 
 For instance let's use `$&` to replace all entries of `"John"` by `"Mr.John"`:
 
@@ -167,7 +165,7 @@ alert(str.replace(/John/g, 'Mr.$&'));
 // "Mr.John Doe, Mr.John Smith and Mr.John Bull.";
 ```
 
-Brackets are very often used together with `$1`, `$2`, like this:
+Parentheses are very often used together with `$1`, `$2`, like this:
 
 ```js run
 let str = "John Smith";
@@ -195,11 +193,11 @@ In the example above the function just returns the next number every time, but u
 The function is called with arguments `func(str, p1, p2, ..., pn, offset, s)`:
 
 1. `str` -- the match,
-2. `p1, p2, ..., pn` -- contents of brackets (if there are any),
+2. `p1, p2, ..., pn` -- contents of parentheses (if there are any),
 3. `offset` -- position of the match,
 4. `s` -- the source string.
 
-If there are no brackets in the regexp, then the function always has 3 arguments: `func(str, offset, s)`.
+If there are no parentheses in the regexp, then the function always has 3 arguments: `func(str, offset, s)`.
 
 Let's use it to show full information about matches:
 
@@ -219,11 +217,11 @@ alert( 'Result: ' + result ); // Result: ho-ho-ho
 // Found ho at position 6 in string HO-Ho-ho
 ```
 
-In the example below there are two brackets, so `replacer` is called with 5 arguments: `str` is the full match, then brackets, and then `offset` and `s`:
+In the example below there are two parentheses, so `replacer` is called with 5 arguments: `str` is the full match, then parentheses, and then `offset` and `s`:
 
 ```js run
 function replacer(str, name, surname, offset, s) {
-  // name is the first bracket, surname is the second one
+  // name is the first parentheses, surname is the second one
   return surname + ", " + name;
 }
 
@@ -264,10 +262,10 @@ alert( str.search(*!*/love/i*/!*) != -1 ); // false
 We've already seen these searching methods:
 
 - `search` -- looks for the position of the match,
-- `match` -- if there's no `g` flag, returns the first match with brackets,
-- `match` -- if there's a `g` flag -- returns all matches, without separating brackets.
+- `match` -- if there's no `g` flag, returns the first match with parentheses,
+- `match` -- if there's a `g` flag -- returns all matches, without separating parentheses.
 
-The `regexp.exec` method is a bit harder to use, but it allows to search all matches with brackets and positions.
+The `regexp.exec` method is a bit harder to use, but it allows to search all matches with parentheses and positions.
 
 It behaves differently depending on whether the regexp has the `g` flag.
 
@@ -276,7 +274,7 @@ It behaves differently depending on whether the regexp has the `g` flag.
 
 As we can see, the method gives us nothing new if we use it without the `g` flag, because `str.match` does exactly the same.
 
-But the `g` flag allows to get all matches with their positions and bracket groups.
+But the `g` flag allows to get all matches with their positions and parentheses groups.
 
 Here's the example how subsequent `regexp.exec` calls return matches one by one:
 
@@ -316,7 +314,7 @@ alert( matchThree ); // null (no match)
 alert( regexp.lastIndex ); // 0 (reset)
 ```
 
-As we can see, each `regexp.exec` call returns the match in a "full format": as an array with brackets, `index` and `input` properties.
+As we can see, each `regexp.exec` call returns the match in a "full format": as an array with parentheses, `index` and `input` properties.
 
 The main use case for `regexp.exec` is to find all matches in a loop:
 

10-regular-expressions-javascript/04-regexp-character-sets-and-ranges/2-find-time-2-formats/solution.md

@@ -1,5 +1,5 @@
 
-# Special characters
+# Escaping, special characters
 
 As we've seen, a backslash `"\"` is used to denote character classes. So it's a special character.
 
@@ -21,7 +21,7 @@ For instance, we need to find a dot `pattern:'.'`. In a regular expression a dot
 alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1
 ```
 
-Brackets are also special characters, so if we want them, we should use `pattern:\(`. The example below looks for a string `"g()"`:
+Parentheses are also special characters, so if we want them, we should use `pattern:\(`. The example below looks for a string `"g()"`:
 
 ```js run
 alert( "function g()".match(/g\(\)/) ); // "g()"
@@ -46,5 +46,46 @@ alert( "/".match(/\//) ); // '/'
 From the other hand, the alternative `new RegExp` syntaxes does not require escaping it:
 
 ```js run
-alert( "/".match(new RegExp()/\//) ); // '/'
+alert( "/".match(new RegExp("/")) ); // '/'
+```
+
+## new RegExp
+
+If we are creating a regular expression with `new RegExp`, then we need to do some more escaping.
+
+For instance, consider this:
+
+```js run
+let reg = new RegExp("\d\.\d");
+
+alert( "Chapter 5.1".match(reg) ); // null
+```
+
+It doesn't work, but why?
+
+The reason is string escaping rules. Look here:
+
+```js run
+alert("\d\.\d"); // d.d
+```
+
+Backslashes are used for escaping inside a string and string-specific special characters like `\n`. The quotes "consume" and interpret them, for instance:
+
+- `\n` -- becomes a newline character,
+- `\u1234` -- becomes the Unicode character with such code,
+- ...And when there's no special meaning: like `\d` or `\z`, then the backslash is simply removed.
+
+So the call to `new RegExp` gets a string without backslashes.
+
+To fix it, we need to double backslashes, because quotes turn `\\` into `\`:
+
+```js run
+*!*
+let regStr = "\\d\\.\\d";
+*/!*
+alert(regStr); // \d\.\d (correct now)
+
+let reg = new RegExp(regStr);
+
+alert( "Chapter 5.1".match(reg) ); // 5.1
 ```

10-regular-expressions-javascript/04-regexp-character-sets-and-ranges/2-find-time-2-formats/task.md

@@ -0,0 +1,8 @@
+Answer: `pattern:\d\d[-:]\d\d`.
+
+```js run
+let reg = /\d\d[-:]\d\d/g;
+alert( "Breakfast at 09:00. Dinner at 21-30".match(reg) ); // 09:00, 21-30
+```
+
+Please note that the dash `pattern:'-'` has a special meaning in square brackets, but only between other characters, not when it's in the beginning or at the end, so we don't need to escape it.

…avascript/035-regexp-escaping/article.md …javascript/04-regexp-escaping/article.md10-regular-expressions-javascript/035-regexp-escaping/article.md renamed to 10-regular-expressions-javascript/04-regexp-escaping/article.md 10-regular-expressions-javascript/035-regexp-escaping/article.md renamed to 10-regular-expressions-javascript/04-regexp-escaping/article.md

@@ -0,0 +1,12 @@
+# Find the time as hh:mm or hh-mm
+
+The time can be in the format `hours:minutes` or `hours-minutes`. Both hours and minutes have 2 digits:  `09:00` or `21-30`.
+
+Write a regexp to find time:
+
+```js
+let reg = /your regexp/g;
+alert( "Breakfast at 09:00. Dinner at 21-30".match(reg) ); // 09:00, 21-30
+```
+
+P.S. In this task we assume that the time is always correct, there's no need to filter out bad strings like "45:67". Later we'll deal with that too.

…ts-and-ranges/1-find-range-1/solution.md …ts-and-ranges/1-find-range-1/solution.md10-regular-expressions-javascript/04-regexp-character-sets-and-ranges/1-find-range-1/solution.md renamed to 10-regular-expressions-javascript/05-regexp-character-sets-and-ranges/1-find-range-1/solution.md 10-regular-expressions-javascript/04-regexp-character-sets-and-ranges/1-find-range-1/solution.md renamed to 10-regular-expressions-javascript/05-regexp-character-sets-and-ranges/1-find-range-1/solution.md

@@ -88,7 +88,7 @@ In square brackets the vast majority of special characters can be used without e
 
 - A dot `pattern:'.'`.
 - A plus `pattern:'+'`.
-- Brackets `pattern:'( )'`.
+- Parentheses `pattern:'( )'`.
 - Dash `pattern:'-'` in the beginning or the end (where it does not define a range).
 - A caret `pattern:'^'` if not in the beginning (where it means exclusion).
 - And the opening square bracket `pattern:'['`.