From 1ae063311d8b7809c563dd37ad0cc1b95be3c864 Mon Sep 17 00:00:00 2001 From: MrsMelnychenko <110090508+MrsMelnychenko@users.noreply.github.com> Date: Thu, 24 Nov 2022 14:31:12 +0200 Subject: [PATCH 1/3] Update article.md --- .../09-regexp-quantifiers/article.md | 105 +++++++++--------- 1 file changed, 52 insertions(+), 53 deletions(-) diff --git a/9-regular-expressions/09-regexp-quantifiers/article.md b/9-regular-expressions/09-regexp-quantifiers/article.md index 1a7eecfeb..46175f558 100644 --- a/9-regular-expressions/09-regexp-quantifiers/article.md +++ b/9-regular-expressions/09-regexp-quantifiers/article.md @@ -1,142 +1,141 @@ -# Quantifiers +, *, ? and {n} +# Квантифікатори +, *, ? та {n} -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`. +Припустимо, у нас є рядок `+38(067)-123-45-67` і нам потрібно знайти всі числа в ньому. Але цього разу, на відміну від попередніх, нас цікавлять не поодинокі цифри, а саме числа : `38, 067, 123, 45, 67`. -A number is a sequence of 1 or more digits `pattern:\d`. To mark how many we need, we can append a *quantifier*. +Число це послідовність з 1, або більше цифр `pattern:\d` і щоб позначити потрібну нам кількість, ми можемо застосувати *квантифікатор*. -## Quantity {n} +## Кількість {n} -The simplest quantifier is a number in curly braces: `pattern:{n}`. +Найпростішим квантифікатором є число у фігурних дужках: `pattern:{n}`. -A quantifier is appended to a character (or a character class, or a `[...]` set etc) and specifies how many we need. +Квантифікатор додається до символу(або класу символів, набору `[...]`, тощо) і позначає яка їх кількість нам потрібна. +Існує декілька способів використання квантифікатора, розглянемо на прикладах: -It has a few advanced forms, let's see examples: +Точна кількість: `pattern:{5}` +: `pattern:\d{5}` означає точно 5 цифр, так само як і `pattern:\d\d\d\d\d`. -The exact count: `pattern:{5}` -: `pattern:\d{5}` denotes exactly 5 digits, the same as `pattern:\d\d\d\d\d`. - - The example below looks for a 5-digit number: + Нижченаведений приклад шукатиме число, яке складається з 5-ти цифр: ```js run - alert( "I'm 12345 years old".match(/\d{5}/) ); // "12345" + alert( "Мені 12345 років".match(/\d{5}/) ); // "12345" ``` - We can add `\b` to exclude longer numbers: `pattern:\b\d{5}\b`. + Ми могли б додати `\b` і таким чином вилучити з пошуку числа довші за наш шаблон: `pattern:\b\d{5}\b`. -The range: `pattern:{3,5}`, match 3-5 times -: To find numbers from 3 to 5 digits we can put the limits into curly braces: `pattern:\d{3,5}` +Діапазон: `pattern:{3,5}`, від 3 до 5 +: Щоб знайти числа, які складаються з мінімум 3 і максимум 5 чисел, ми можемо вказати потрібні обмеження у фігурних дужках: `pattern:\d{3,5}` ```js run - alert( "I'm not 12, but 1234 years old".match(/\d{3,5}/) ); // "1234" + alert( "Мені не 12 років, а 1234".match(/\d{3,5}/) ); // "1234" ``` - We can omit the upper limit. + Ми можемо не вказувати верхню межу. - Then a regexp `pattern:\d{3,}` looks for sequences of digits of length `3` or more: + В такому випадку, регулярний вираз `pattern:\d{3,}` шукатиме послідовність цифр довжиною від `3` і/або більше: ```js run - alert( "I'm not 12, but 345678 years old".match(/\d{3,}/) ); // "345678" + alert( "Мені не 12, а 345678 років".match(/\d{3,}/) ); // "345678" ``` -Let's return to the string `+7(903)-123-45-67`. +Давайте повернемось до рядка `+38(067)-123-45-67`. -A number is a sequence of one or more digits in a row. So the regexp is `pattern:\d{1,}`: +Число це послідовність з однієї або більше цифр підряд. Таким чином, регулярний вираз виглядатиме `pattern:\d{1,}`: ```js run -let str = "+7(903)-123-45-67"; +let str = "+38(067)-123-45-67"; let numbers = str.match(/\d{1,}/g); -alert(numbers); // 7,903,123,45,67 +alert(numbers); // 38,067,123,45,67 ``` -## Shorthands +## Скорочення -There are shorthands for most used quantifiers: +Існують способи скорочено записати більшу частину часто вживаних квантифікаторів: `pattern:+` -: Means "one or more", the same as `pattern:{1,}`. +: Означає "один, або більше", так само як і `pattern:{1,}`. - For instance, `pattern:\d+` looks for numbers: + До прикладу, `pattern:\d+` шукає числа, які складаються з однієї, або більше цифр: ```js run - let str = "+7(903)-123-45-67"; + let str = "+38(067)-123-45-67"; - alert( str.match(/\d+/g) ); // 7,903,123,45,67 + alert( str.match(/\d+/g) ); // 38,067,123,45,67 ``` `pattern:?` -: Means "zero or one", the same as `pattern:{0,1}`. In other words, it makes the symbol optional. +: Означає "нуль, або один", так само як і `pattern:{0,1}`. Інакше кажучи, в такий спосіб ми робимо символ необов'язковим. - For instance, the pattern `pattern:ou?r` looks for `match:o` followed by zero or one `match:u`, and then `match:r`. + До прикладу, шаблон `pattern:ou?r` шукатиме літеру `match:o` після якої, можливо, йтиме літера `match:u`, і потім літера `match:r`. - So, `pattern:colou?r` finds both `match:color` and `match:colour`: + І таким чином, `pattern:colou?r` знайде обидва слова `match:color` та `match:colour`: ```js run - let str = "Should I write color or colour?"; + let str = "Англійською слово колір пишеться як color чи colour?"; alert( str.match(/colou?r/g) ); // color, colour ``` `pattern:*` -: Means "zero or more", the same as `pattern:{0,}`. That is, the character may repeat any times or be absent. +: Означає "нуль, або більше", так само, як і `pattern:{0,}`. Це означає, що символ може бути відсутнім, або повторюватись безліч разів. - For example, `pattern:\d0*` looks for a digit followed by any number of zeroes (may be many or none): + До прикладу, `pattern:\d0*` шукає цифру, після якої йде будь-яка кількість нулів (може бути багато, або жодного): ```js run alert( "100 10 1".match(/\d0*/g) ); // 100, 10, 1 ``` - Compare it with `pattern:+` (one or more): + Порівняйте з `pattern:+` (один, або більше): ```js run alert( "100 10 1".match(/\d0+/g) ); // 100, 10 - // 1 not matched, as 0+ requires at least one zero + // Регулярний вираз не знайшов 1, оскільки 0+ вимагає наявності щонайменше одного нуля ``` -## More examples +## Більше прикладів -Quantifiers are used very often. They serve as the main "building block" of complex regular expressions, so let's see more examples. +Квантифікатори використовують дуже часто. Вони основні "будівельні блоки" складних регулярних виразів, тож розглянемо ще декілька прикладів. -**Regexp for decimal fractions (a number with a floating point): `pattern:\d+\.\d+`** +**Регулярний вираз для десяткових дробів (чисел з плаваючою комою): `pattern:\d+\.\d+`** -In action: +В дії: ```js run alert( "0 1 12.345 7890".match(/\d+\.\d+/g) ); // 12.345 ``` -**Regexp for an "opening HTML-tag without attributes", such as `` or `

`.** +**Регулярний вираз для "відкриваючого HTML-тегу без атрибутів", наприклад, ``, або `

`.** -1. The simplest one: `pattern:/<[a-z]+>/i` +1. Найпростіший варіант: `pattern:/<[a-z]+>/i` ```js run alert( " ... ".match(/<[a-z]+>/gi) ); // ``` - The regexp looks for character `pattern:'<'` followed by one or more Latin letters, and then `pattern:'>'`. + Регулярний вираз шукає символ `pattern:'<'` після якого йдуть одна, або більше літер латиницею, а потім `pattern:'>'`. -2. Improved: `pattern:/<[a-z][a-z0-9]*>/i` +2. Покращений варіант: `pattern:/<[a-z][a-z0-9]*>/i` - According to the standard, HTML tag name may have a digit at any position except the first one, like `

`. + Згідно стандарту, назва HTML-тегу може містити в собі і цифру на будь-якій позиції окрім першої, як наприклад `

`. ```js run alert( "

Hi!

".match(/<[a-z][a-z0-9]*>/gi) ); //

``` -**Regexp "opening or closing HTML-tag without attributes": `pattern:/<\/?[a-z][a-z0-9]*>/i`** +**Регулярний вираз "відкриваючого, або закриваючого HTML-тегу без атрибутів": `pattern:/<\/?[a-z][a-z0-9]*>/i`** -We added an optional slash `pattern:/?` near the beginning of the pattern. Had to escape it with a backslash, otherwise JavaScript would think it is the pattern end. +Ми додали необов'язковий слеш `pattern:/?` на початку шаблону і для того, щоб JavaScript не сприйняв його як кінець регулярного виразу, нам довелось його екранувати. ```js run alert( "

Hi!

".match(/<\/?[a-z][a-z0-9]*>/gi) ); //

,

``` -```smart header="To make a regexp more precise, we often need make it more complex" -We can see one common rule in these examples: the more precise is the regular expression -- the longer and more complex it is. +```smart header="Щоб зробити регулярний вираз більш точний, нам часто доводиться його ускладнювати" +На прикладах ми побачили, що більш точним є регулярний вираз, тим довшим і складнішим є його реалізація. -For instance, for HTML tags we could use a simpler regexp: `pattern:<\w+>`. But as HTML has stricter restrictions for a tag name, `pattern:<[a-z][a-z0-9]*>` is more reliable. +До прикладу, для HTML-тегів без атрибутів ми могли б використати простіший регулярний вираз: `pattern:<\w+>`. Але так як HTML має більш жорсткі вимоги до назв тегів, то шаблон `pattern:<[a-z][a-z0-9]*>` буде більш точним. -Can we use `pattern:<\w+>` or we need `pattern:<[a-z][a-z0-9]*>`? +Чи можемо ми використовувати `pattern:<\w+>` чи краще писати `pattern:<[a-z][a-z0-9]*>`? -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 remove them from the result by other means. +в реальному життя обидва варіанти мають право на існування. Все залежить від того, чи готові ми допустити "зайві" співпадіння з нашим регулярний виразом і наскілльки важко, або легко буде відфільтрувати їх і отримати перелік потрібних нам співпадінь. ``` From 85eebbc17f44b11202fff3aa03193f44598f4b28 Mon Sep 17 00:00:00 2001 From: MrsMelnychenko <110090508+MrsMelnychenko@users.noreply.github.com> Date: Thu, 24 Nov 2022 17:07:37 +0200 Subject: [PATCH 2/3] Update article.md --- .../article.md | 170 +++++++++--------- 1 file changed, 85 insertions(+), 85 deletions(-) diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md index a1b8f896d..f295c37fe 100644 --- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md +++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md @@ -1,169 +1,169 @@ -# Sets and ranges [...] +# Набори та діапазони [...] -Several characters or character classes inside square brackets `[…]` mean to "search for any character among given". +Декільки символів, або класи символів всередині квадратних дужок `[…]` означають "шукати будь-який символ з-поміж заданих". -## Sets +## Набори -For instance, `pattern:[eao]` means any of the 3 characters: `'a'`, `'e'`, or `'o'`. +До прикладу, `pattern:[eao]` означає будь-який з трьох символів: `'a'`, `'e'`, or `'o'`. -That's called a *set*. Sets can be used in a regexp along with regular characters: +У такий спосіб записується так званий *набір*. Набір може використовуватись в регулярних виразах разом зі звичайними символами: ```js run -// find [t or m], and then "op" +// знайти [t або m], а потім "op" alert( "Mop top".match(/[tm]op/gi) ); // "Mop", "top" ``` -Please note that although there are multiple characters in the set, they correspond to exactly one character in the match. +Зверніть увагу, що незважаючи на те, що в сеті вказано два символи, в результаті є співпадіння лише по одному з них. -So the example below gives no matches: +Тож нижченаведений приклад не знайде співпадінь: ```js run -// find "V", then [o or i], then "la" +// знайти "V", потім [o чи i], потім "la" alert( "Voila".match(/V[oi]la/) ); // null, no matches ``` -The pattern searches for: +Шаблон шукає: - `pattern:V`, -- then *one* of the letters `pattern:[oi]`, -- then `pattern:la`. +- потім *одна* з літер набору `pattern:[oi]`, +- потім `pattern:la`. -So there would be a match for `match:Vola` or `match:Vila`. +Тож результатом такого пошуку могли б стати варіанти `match:Vola` або `match:Vila`. -## Ranges +## Діапазони -Square brackets may also contain *character ranges*. +Квадратні дужки також можуть містити *діапазони символів*. -For instance, `pattern:[a-z]` is a character in range from `a` to `z`, and `pattern:[0-5]` is a digit from `0` to `5`. +До прикладу, `pattern:[a-z]` шукатиме символу в діапазоні від `a` до `z`, а `pattern:[0-5]` дорівнює цифрам в діапазоні від `0` до `5`. -In the example below we're searching for `"x"` followed by two digits or letters from `A` to `F`: +В нижченаведеному прикладі ми шукатимемо літеру `"x"` за якою слідують дві цифри, або літери від `A` до `F`: ```js run alert( "Exception 0xAF".match(/x[0-9A-F][0-9A-F]/g) ); // xAF ``` -Here `pattern:[0-9A-F]` has two ranges: it searches for a character that is either a digit from `0` to `9` or a letter from `A` to `F`. +Тут `pattern:[0-9A-F]` має в собі одразу два діапазони: він шукає на символ, який є або цифрою від `0` до `9` , або літерою від `A` до `F`. -If we'd like to look for lowercase letters as well, we can add the range `a-f`: `pattern:[0-9A-Fa-f]`. Or add the flag `pattern:i`. +Якби ми захотіли шукати літери не тільки верхнього, а й нижнього регістру, ми могли б додати діапазон `a-f`: `pattern:[0-9A-Fa-f]`. Або додати флаг `pattern:i`. -We can also use character classes inside `[…]`. +Крім того, всередині `[…]` ми можемо використовувати символьні класи. -For instance, if we'd like to look for a wordly character `pattern:\w` or a hyphen `pattern:-`, then the set is `pattern:[\w-]`. +До прикладу, якщо ми захочемо шукати "символ слова" `pattern:\w` , або дефіс `pattern:-`, в такому випадку набір виглядатиме наступним чином `pattern:[\w-]`. -Combining multiple classes is also possible, e.g. `pattern:[\s\d]` means "a space character or a digit". +Комбінувати декілька класів теж можливо, наприклад `pattern:[\s\d]` означає "пробіл, або цифра". -```smart header="Character classes are shorthands for certain character sets" -For instance: +```smart header="Символьні класи це всього лише скорочення для деяких наборів символів" +До прикладу: -- **\d** -- is the same as `pattern:[0-9]`, -- **\w** -- is the same as `pattern:[a-zA-Z0-9_]`, -- **\s** -- is the same as `pattern:[\t\n\v\f\r ]`, plus few other rare Unicode space characters. +- **\d** -- це те саме, що `pattern:[0-9]`, +- **\w** -- це те саме, що `pattern:[a-zA-Z0-9_]`, +- **\s** -- це те саме, що `pattern:[\t\n\v\f\r ]`, плюс деякілька інших рідких пробільних символів Unicode. ``` -### Example: multi-language \w +### Приклад: \w в інших мовах світу -As the character class `pattern:\w` is a shorthand for `pattern:[a-zA-Z0-9_]`, it can't find Chinese hieroglyphs, Cyrillic letters, etc. +Оскільки символьний клас `pattern:\w` це лише скорочений запис `pattern:[a-zA-Z0-9_]`, він не зможе знайти китайські ієрогліфи, літери кирилицею і т.д. -We can write a more universal pattern, that looks for wordly characters in any language. That's easy with Unicode properties: `pattern:[\p{Alpha}\p{M}\p{Nd}\p{Pc}\p{Join_C}]`. +Існує спосіб написати більш універсальний шаблон, що включатиме в себе буквенні символи будь-якої мови світу. Це легко реалізувати завдяки властивостям Unicode: `pattern:[\p{Alpha}\p{M}\p{Nd}\p{Pc}\p{Join_C}]`. -Let's decipher it. Similar to `pattern:\w`, we're making a set of our own that includes characters with following Unicode properties: +Давайте розшифруємо цей шаблон. Подібно до `pattern:\w`, ми створюємо свій діапазон, який включає в себе символи з наступними властивостями Unicode: -- `Alphabetic` (`Alpha`) - for letters, -- `Mark` (`M`) - for accents, -- `Decimal_Number` (`Nd`) - for digits, -- `Connector_Punctuation` (`Pc`) - for the underscore `'_'` and similar characters, -- `Join_Control` (`Join_C`) - two special codes `200c` and `200d`, used in ligatures, e.g. in Arabic. +- `Alphabetic` (`Alpha`) - для літер, +- `Mark` (`M`) - для акцентів, +- `Decimal_Number` (`Nd`) - для цифр, +- `Connector_Punctuation` (`Pc`) - для нижнього підкреслення `'_'` і тому подібних символів, +- `Join_Control` (`Join_C`) - два спеціальних коди `200c` та `200d`, які використовуються у лігатурах, зокрема в арабській мові. -An example of use: +Шаблон в дії: ```js run let regexp = /[\p{Alpha}\p{M}\p{Nd}\p{Pc}\p{Join_C}]/gu; let str = `Hi 你好 12`; -// finds all letters and digits: +// знайти всі літери та цифри: alert( str.match(regexp) ); // H,i,你,好,1,2 ``` -Of course, we can edit this pattern: add Unicode properties or remove them. Unicode properties are covered in more details in the article . +Звичайно, ми можемо редагувати вищенаведений шаблон: додавати Unicode властивості, або видаляти їх. Дізнатись більше про Unicode властивості можна за посиланням . -```warn header="Unicode properties aren't supported in IE" -Unicode properties `pattern:p{…}` are not implemented in IE. If we really need them, we can use library [XRegExp](http://xregexp.com/). +```warn header="Internet Explorer не підтримує Unicode властивості" +Unicode властивості `pattern:p{…}` недоступні у Internet Explorer. ЯВтім, якщо вони нам все ж потрібні, ми можемо скористатись бібліотекою [XRegExp](http://xregexp.com/). -Or just use ranges of characters in a language that interests us, e.g. `pattern:[а-я]` for Cyrillic letters. +або просто вказати діапазон потрібних нам символів певною мовою, наприклад `pattern:[а-я]` для літер кирилицею. ``` -## Excluding ranges +## Діапазони виключень -Besides normal ranges, there are "excluding" ranges that look like `pattern:[^…]`. +Окрім звичайни діапазонів, існують діапазони "виключень" які виглядають наступним чином: `pattern:[^…]`. -They are denoted by a caret character `^` at the start and match any character *except the given ones*. +Вони відрізняються символом каретки `^` на початку і знаходять будь-який символ *окрім вказаних в діапазоні*. -For instance: +До прикладу: -- `pattern:[^aeyo]` -- any character except `'a'`, `'e'`, `'y'` or `'o'`. -- `pattern:[^0-9]` -- any character except a digit, the same as `pattern:\D`. -- `pattern:[^\s]` -- any non-space character, same as `\S`. +- `pattern:[^aeyo]` -- будь-який символ окрім `'a'`, `'e'`, `'y'` or `'o'`. +- `pattern:[^0-9]` -- будь-який символ окрім цифр, так само як і `pattern:\D`. +- `pattern:[^\s]` -- будь-який не пробільний символ `\S`. -The example below looks for any characters except letters, digits and spaces: +Нижченаведений приклад шукає будь-який символ окрім літер латиницею, цифр та пробільних символів: ```js run -alert( "alice15@gmail.com".match(/[^\d\sA-Z]/gi) ); // @ and . +alert( "alice15@gmail.com".match(/[^\d\sA-Z]/gi) ); // @ та . ``` -## Escaping in […] +## Екранування всередині […] -Usually when we want to find exactly a special character, we need to escape it like `pattern:\.`. And if we need a backslash, then we use `pattern:\\`, and so on. +Зазвичай, коли ми хочемо знайти один зі спец символів, нам потрібно екранувати його наступним чином `pattern:\.`. Тобто, якщо нам потрібна зворотня коса риска, ми маємо писати `pattern:\\`, і так далі. -In square brackets we can use the vast majority of special characters without escaping: +В квадратних дужках ми можемо використовувати велику кількість спец символів без екранування: -- Symbols `pattern:. + ( )` never need escaping. -- A hyphen `pattern:-` is not escaped in the beginning or the end (where it does not define a range). -- A caret `pattern:^` is only escaped in the beginning (where it means exclusion). -- The closing square bracket `pattern:]` is always escaped (if we need to look for that symbol). +- Символ `pattern:. + ( )` не потребує екранування. +- Дефіс `pattern:-` не потребує екранування на початку, або в кінці (тобто коли не може означати діапазон). +- Каретка `pattern:^` екранується лише на початку (без екранування означає набір символів-виключень). +- Закриваюча квадратна дужка `pattern:]` завжди потребує екранування (у випадках, коли нам потрібно знайти цей символ). -In other words, all special characters are allowed without escaping, except when they mean something for square brackets. +Інакше кажучи, всі спец символи можна використовувати без екранування тоді, коли вони не мають додаткового значення в квадратних дужках. -A dot `.` inside square brackets means just a dot. The pattern `pattern:[.,]` would look for one of characters: either a dot or a comma. +Крапка `.` всередині квадратних дужок означає просто крапку. Шаблон `pattern:[.,]` шукатиме на один з двох символів, або крапку, або кому. -In the example below the regexp `pattern:[-().^+]` looks for one of the characters `-().^+`: +В нижченаведеному прикладі регулярний вираз `pattern:[-().^+]` шукає один з вказаних символів `-().^+`: ```js run -// No need to escape +// Не потрібно екранувати let regexp = /[-().^+]/g; -alert( "1 + 2 - 3".match(regexp) ); // Matches +, - +alert( "1 + 2 - 3".match(regexp) ); // Знаходить +, - ``` -...But if you decide to escape them "just in case", then there would be no harm: +...Але якщо ви вирішите все ж таки екранувати їх, "про всяк випадок", гірше від того не буде: ```js run -// Escaped everything +// Всі символи екрановані let regexp = /[\-\(\)\.\^\+]/g; -alert( "1 + 2 - 3".match(regexp) ); // also works: +, - +alert( "1 + 2 - 3".match(regexp) ); // так само находить: +, - ``` -## Ranges and flag "u" +## Діапазони і прапор "u" -If there are surrogate pairs in the set, flag `pattern:u` is required for them to work correctly. +Якщо в діапазоні є сурогатні пари, для коректної роботи регулярного виразу, прапор `pattern:u` є обов'язковим. -For instance, let's look for `pattern:[𝒳𝒴]` in the string `subject:𝒳`: +До прикладу, давайте знайдемо `pattern:[𝒳𝒴]` у рядку `subject:𝒳`: ```js run -alert( '𝒳'.match(/[𝒳𝒴]/) ); // shows a strange character, like [?] -// (the search was performed incorrectly, half-character returned) +alert( '𝒳'.match(/[𝒳𝒴]/) ); // виводить дивний символ, схожий на [?] +// (пошук було виконано некореткно, повернуто тільки половину символу) ``` -The result is incorrect, because by default regular expressions "don't know" about surrogate pairs. +Результат є некоректним, оскільки за замовчуванням регулярні вирази "не знають" про сурогатні пари. -The regular expression engine thinks that `[𝒳𝒴]` -- are not two, but four characters: -1. left half of `𝒳` `(1)`, -2. right half of `𝒳` `(2)`, -3. left half of `𝒴` `(3)`, -4. right half of `𝒴` `(4)`. +Регулярний вираз сприймає `[𝒳𝒴]` -- не як два, а як чотири символи: +1. ліва половина `𝒳` `(1)`, +2. права половина `𝒳` `(2)`, +3. ліва половина `𝒴` `(3)`, +4. права половина `𝒴` `(4)`. -We can see their codes like this: +Якщо вивести їх кодове значення ми побачимо наступне: ```js run for(let i=0; i<'𝒳𝒴'.length; i++) { @@ -171,27 +171,27 @@ for(let i=0; i<'𝒳𝒴'.length; i++) { }; ``` -So, the example above finds and shows the left half of `𝒳`. +Отже, вищенаведений приклад знайшов і вивів ліву половину `𝒳`. -If we add flag `pattern:u`, then the behavior will be correct: +Якщо ми додамо прапор `pattern:u`, то поведінка буде коректною: ```js run alert( '𝒳'.match(/[𝒳𝒴]/u) ); // 𝒳 ``` -The similar situation occurs when looking for a range, such as `[𝒳-𝒴]`. +Подібна ситуація складається коли ми шукаємо в діапазоні, наприклад `[𝒳-𝒴]`. -If we forget to add flag `pattern:u`, there will be an error: +Якщо ми забудемо додати прапор `pattern:u`, то отримаємо помилку: ```js run '𝒳'.match(/[𝒳-𝒴]/); // Error: Invalid regular expression ``` -The reason is that without flag `pattern:u` surrogate pairs are perceived as two characters, so `[𝒳-𝒴]` is interpreted as `[<55349><56499>-<55349><56500>]` (every surrogate pair is replaced with its codes). Now it's easy to see that the range `56499-55349` is invalid: its starting code `56499` is greater than the end `55349`. That's the formal reason for the error. +Причина в тому, що без прапору `pattern:u` сурогатні пари сприймаються як два окремих символи, тобто `[𝒳-𝒴]` оброблюються як `[<55349><56499>-<55349><56500>]` (кожна сурогатна пара замінюється на набір кодів). Таким чином, ми бачимо, що діапазон `56499-55349` є некоректним: його початковий номер `56499` більший за останній `55349`. Це і є причиною помилки. -With the flag `pattern:u` the pattern works correctly: +З прапором `pattern:u` шаблон працює коректно: ```js run -// look for characters from 𝒳 to 𝒵 +// шукає символи від 𝒳 до 𝒵 alert( '𝒴'.match(/[𝒳-𝒵]/u) ); // 𝒴 ``` From 2b07c13500d5ff0d44666c4a076d05815dd1dbbe Mon Sep 17 00:00:00 2001 From: MrsMelnychenko <110090508+MrsMelnychenko@users.noreply.github.com> Date: Thu, 24 Nov 2022 17:09:45 +0200 Subject: [PATCH 3/3] Update article.md --- .../08-regexp-character-sets-and-ranges/article.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md index f295c37fe..f99f83713 100644 --- a/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md +++ b/9-regular-expressions/08-regexp-character-sets-and-ranges/article.md @@ -13,7 +13,7 @@ alert( "Mop top".match(/[tm]op/gi) ); // "Mop", "top" ``` -Зверніть увагу, що незважаючи на те, що в сеті вказано два символи, в результаті є співпадіння лише по одному з них. +Зверніть увагу, що незважаючи на те, що в наборі вказано два символи, в результаті є співпадіння лише по одному з них. Тож нижченаведений приклад не знайде співпадінь: @@ -28,7 +28,7 @@ alert( "Voila".match(/V[oi]la/) ); // null, no matches - потім *одна* з літер набору `pattern:[oi]`, - потім `pattern:la`. -Тож результатом такого пошуку могли б стати варіанти `match:Vola` або `match:Vila`. +Результатом такого пошуку могли б стати варіанти `match:Vola` або `match:Vila`. ## Діапазони @@ -48,7 +48,7 @@ alert( "Exception 0xAF".match(/x[0-9A-F][0-9A-F]/g) ); // xAF Крім того, всередині `[…]` ми можемо використовувати символьні класи. -До прикладу, якщо ми захочемо шукати "символ слова" `pattern:\w` , або дефіс `pattern:-`, в такому випадку набір виглядатиме наступним чином `pattern:[\w-]`. +До прикладу, якщо ми захочемо знайти "символ слова" `pattern:\w` , або дефіс `pattern:-`, набір виглядатиме наступним чином `pattern:[\w-]`. Комбінувати декілька класів теж можливо, наприклад `pattern:[\s\d]` означає "пробіл, або цифра".