You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
We need to look for `#` followed by 6 hexadimal characters.
1
+
Нам нужно найти символ `#`, за которым следуют 6 шестнадцатеричных символов.
2
2
3
-
A hexadimal character can be described as `pattern:[0-9a-fA-F]`. Or if we use the `i` flag, then just `pattern:[0-9a-f]`.
3
+
Шестнадцатеричный символ может быть описан с помощью регулярного выражения как `pattern:[0-9a-fA-F]`. Или же как `pattern:[0-9a-f]`, если мы используем модификатор `i`.
4
4
5
-
Then we can look for 6 of them using the quantifier `pattern:{6}`.
5
+
Затем мы можем добавить квантификатор `pattern:{6}`, так как нам нужно 6 таких символов.
6
6
7
-
As a result, we have the regexp: `pattern:/#[a-f0-9]{6}/gi`.
7
+
В результате наше регулярное выражение получилось таким: `pattern:/#[a-f0-9]{6}/gi`.
Let's say we have a string like `+7(903)-123-45-67`and want to find all numbers in it. But unlike before, we are interested not in single digits, but full numbers: `7, 903, 123, 45, 67`.
3
+
Давайте возьмём строку вида `+7(903)-123-45-67`и найдём все числа в ней. Но теперь нас интересуют не цифры по отдельности, а именно числа: `7, 903, 123, 45, 67`.
4
4
5
-
A number is a sequence of 1 or more digits`\d`. To mark how many we need, we need to append a *quantifier*.
5
+
Число — это последовательность из 1 или более цифр`\d`. Чтобы отметить количество повторений, нам нужно указать *квантификатор*.
6
6
7
-
## Quantity {n}
7
+
## Количество {n}
8
8
9
-
The simplest quantifier is a number in curly braces: `pattern:{n}`.
9
+
Самый простой квантификатор — это число в фигурных скобках: `pattern:{n}`.
10
10
11
-
A quantifier is appended to a character (or a character class, or a`[...]`set etc) and specifies how many we need.
11
+
Он добавляется к символу (или символьному классу, или набору`[...]`и т.д.) и указывает, сколько их нам нужно.
12
12
13
-
It has a few advanced forms, let's see examples:
13
+
У него есть несколько вариантов, давайте посмотрим примеры:
14
14
15
-
The exact count: `{5}`
16
-
: `pattern:\d{5}`denotes exactly 5 digits, the same as`pattern:\d\d\d\d\d`.
15
+
Точное количество: `{5}`
16
+
: Шаблон `pattern:\d{5}`обозначает ровно 5 цифр, он эквивалентен`pattern:\d\d\d\d\d`.
17
17
18
-
The example below looks for a 5-digit number:
18
+
Следующий пример находит пятизначное число:
19
19
20
20
```js run
21
-
alert( "I'm 12345 years old".match(/\d{5}/) ); // "12345"
We can add `\b` to exclude longer numbers: `pattern:\b\d{5}\b`.
24
+
Мы можем добавить `\b`, чтобы исключить числа длиннее: `pattern:\b\d{5}\b`.
25
25
26
-
The range: `{3,5}`, match 3-5 times
27
-
: To find numbers from 3 to 5 digits we can put the limits into curly braces: `pattern:\d{3,5}`
26
+
Диапазон: `{3,5}`, от 3 до 5
27
+
: Для того, чтобы найти числа c разрядностью от 3 до 5 цифр, мы можем указать границы в фигурных скобках: `pattern:\d{3,5}`
28
28
29
29
```js run
30
-
alert( "I'm not 12, but 1234 years old".match(/\d{3,5}/) ); // "1234"
30
+
alert( "Мне не 12, а 1234 года".match(/\d{3,5}/) ); // "1234"
31
31
```
32
32
33
-
We can omit the upper limit.
33
+
Верхнюю границу можно не указывать.
34
34
35
-
Then a regexp `pattern:\d{3,}` looks for sequences of digits of length `3` or more:
35
+
Тогда шаблон `pattern:\d{3,}` найдет последовательность чисел длиной `3` и более цифр:
36
36
37
37
```js run
38
-
alert( "I'm not 12, but 345678 years old".match(/\d{3,}/) ); // "345678"
38
+
alert( "Мне не 12, а 345678 лет".match(/\d{3,}/) ); // "345678"
39
39
```
40
40
41
-
Let's return to the string`+7(903)-123-45-67`.
41
+
Давайте вернёмся к строке`+7(903)-123-45-67`.
42
42
43
-
A number is a sequence of one or more digits in a row. So the regexp is`pattern:\d{1,}`:
43
+
Число - это последовательность из одной или более цифр. Поэтому шаблон будет`pattern:\d{1,}`:
44
44
45
45
```js run
46
46
let str ="+7(903)-123-45-67";
@@ -50,14 +50,14 @@ let numbers = str.match(/\d{1,}/g);
50
50
alert(numbers); // 7,903,123,45,67
51
51
```
52
52
53
-
## Shorthands
53
+
## Короткие обозначения
54
54
55
-
There are shorthands for most used quantifiers:
55
+
Для самых востребованных квантификаторов есть сокращённые формы записи:
56
56
57
57
`+`
58
-
: Means "one or more", the same as`{1,}`.
58
+
: Означает "один или более". То же самое, что и`{1,}`.
59
59
60
-
For instance, `pattern:\d+` looks for numbers:
60
+
Например, `pattern:\d+` находит числа:
61
61
62
62
```js run
63
63
let str = "+7(903)-123-45-67";
@@ -66,75 +66,76 @@ There are shorthands for most used quantifiers:
66
66
```
67
67
68
68
`?`
69
-
: Means "zero or one", the same as `{0,1}`. In other words, it makes the symbol optional.
69
+
: Означает "ноль или один". То же самое, что и `{0,1}`. По сути, делает символ необязательным.
70
70
71
-
For instance, the pattern `pattern:ou?r` looks for `match:o` followed by zero or one `match:u`, and then `match:r`.
71
+
Например, шаблон `pattern:ou?r` найдёт `match:o` после которого, возможно, следует `match:u`, а затем `match:r`.
72
72
73
-
So, `pattern:colou?r` finds both `match:color` and `match:colour`:
73
+
Поэтому шаблон `pattern:colou?r` найдёт оба: `match:color` и `match:colour`:
74
74
75
75
```js run
76
-
let str = "Should I write color or colour?";
76
+
let str = "Следует писать color или colour?";
77
77
78
78
alert( str.match(/colou?r/g) ); // color, colour
79
79
```
80
80
81
81
`*`
82
-
: Means "zero or more", the same as `{0,}`. That is, the character may repeat any times or be absent.
82
+
: Означает "ноль или более". То же самое, что и `{0,}`. То есть символ может повторяться много раз или вообще отсутствовать.
83
83
84
-
For example, `pattern:\d0*` looks for a digit followed by any number of zeroes:
84
+
Например, шаблон `pattern:\d0*` находит цифру вместе со всеми нулями, которые идут за ней (но могут и не идти):
85
85
86
86
```js run
87
87
alert( "100 10 1".match(/\d0*/g) ); // 100, 10, 1
88
88
```
89
89
90
-
Compare it with `'+'` (one or more):
90
+
Сравните это с `'+'` (один или более):
91
91
92
92
```js run
93
93
alert( "100 10 1".match(/\d0+/g) ); // 100, 10
94
-
// 1 not matched, as 0+ requires at least one zero
94
+
// 1 не подходит, т.к 0+ требует как минимум один ноль
95
95
```
96
96
97
-
## More examples
97
+
## Ещё примеры
98
98
99
-
Quantifiers are used very often. They serve as the main "building block" of complex regular expressions, so let's see more examples.
99
+
Квантификаторы используются очень часто. Они служат основными "строительными блоками" сложных регулярных выражений, поэтому давайте рассмотрим ещё примеры.
100
100
101
-
Regexp "decimal fraction" (a number with a floating point): `pattern:\d+\.\d+`
102
-
: In action:
101
+
Регулярное выражение для поиска десятичных дробей (чисел с плавающей точкой): `pattern:\d+\.\d+`
We look for character `pattern:'<'` followed by one or more English letters, and then `pattern:'>'`.
114
+
Это регулярное выражение ищет символ `pattern:'<'`, за которым идут одна или более букв английского алфавита, а затем `pattern:'>'`.
115
115
116
-
Regexp "open HTML-tag without attributes" (improved): `pattern:/<[a-z][a-z0-9]*>/i`
117
-
: Better regexp: according to the standard, HTML tag name may have a digit at any position except the first one, like`<h1>`.
116
+
Регулярное выражение для поиска "открывающего HTML-тега без атрибутов" (улучшенный вариант): `pattern:/<[a-z][a-z0-9]*>/i`
117
+
: Здесь регулярное выражение расширено: в соответствие со стандартом, в названии HTML-тега цифра может быть на любой позиции, кроме первой, например`<h1>`.
Regexp "opening or closing HTML-tag without attributes": `pattern:/<\/?[a-z][a-z0-9]*>/i`
124
-
: We added an optional slash `pattern:/?` before the tag. Had to escape it with a backslash, otherwise JavaScript would think it is the pattern end.
123
+
Регулярное выражение для поиска "открывающего или закрывающего HTML-тега без атрибутов": `pattern:/<\/?[a-z][a-z0-9]*>/i`
124
+
: В предыдущий шаблон мы добавили необязательный слеш `pattern:/?`. Этот символ понадобилось заэкранировать, чтобы JavaScript не принял его за конец шаблона.
```smart header="To make a regexp more precise, we often need make it more complex"
131
-
We can see one common rule in these examples: the more precise is the regular expression -- the longer and more complex it is.
130
+
```smart header="Чтобы регулярное выражение было точнее, нам часто приходится делать его сложнее"
132
131
133
-
For instance, for HTML tags we could use a simpler regexp: `pattern:<\w+>`.
132
+
В этих примерах мы видим общее правило: чем точнее регулярное выражение -- тем оно длиннее и сложнее.
134
133
135
-
...But because `pattern:\w` means any English letter or a digit or `'_'`, the regexp also matches non-tags, for instance `match:<_>`. So it's much simpler than `pattern:<[a-z][a-z0-9]*>`, but less reliable.
134
+
Например, для HTML-тегов, скорее всего, подошло бы и более простое регулярное выражение: `pattern:<\w+>`.
136
135
137
-
Are we ok with `pattern:<\w+>` or we need `pattern:<[a-z][a-z0-9]*>`?
136
+
...Но так как класс `pattern:\w` означает любую английскую букву или цифру, или `'_'`, то для такого регулярного выражения подойдут и не теги, например `match:<_>`. То есть оно гораздо проще, чем шаблон `pattern:<[a-z][a-z0-9]*>`, но вместе с тем и менее точное.
138
137
139
-
In real life both variants are acceptable. Depends on how tolerant we can be to "extra" matches and whether it's difficult or not to filter them out by other means.
138
+
Подойдёт ли нам `pattern:<\w+>` или нужно использовать `pattern:<[a-z][a-z0-9]*>`?
139
+
140
+
В реальной жизни допустимы оба варианта. Ответ на подобные вопросы зависит от того, насколько реально важна точность и насколько потом будет сложно или несложно отфильтровать лишние совпадения.
0 commit comments