From ffbdc53e6ee9a5ce2ed85f16cc0343b3022e304d Mon Sep 17 00:00:00 2001 From: Aakodal <48600424+Aakodal@users.noreply.github.com> Date: Fri, 8 May 2020 20:03:08 +0000 Subject: [PATCH 1/3] Update article.md --- .../05-regexp-multiline-mode/article.md | 48 +++++++++---------- 1 file changed, 22 insertions(+), 26 deletions(-) diff --git a/9-regular-expressions/05-regexp-multiline-mode/article.md b/9-regular-expressions/05-regexp-multiline-mode/article.md index 539f9fa23..b4612b103 100644 --- a/9-regular-expressions/05-regexp-multiline-mode/article.md +++ b/9-regular-expressions/05-regexp-multiline-mode/article.md @@ -1,14 +1,14 @@ -# Multiline mode of anchors ^ $, flag "m" +# Mode multiligne des ancres ^ $, marqueur "m" -The multiline mode is enabled by the flag `pattern:m`. +Le mode multiligne est activé avec le marqueur `pattern:m`. -It only affects the behavior of `pattern:^` and `pattern:$`. +Il affecte seulement le fonctionnement des ancres `pattern:^` et `pattern:$`. -In the multiline mode they match not only at the beginning and the end of the string, but also at start/end of line. +Dans le mode multiligne, elles ne vérifient pas seulement le début et la fin d'une chaîne de caractères, mais également le début et la fin d'une ligne. -## Searching at line start ^ +## Recherche au début de ligne ^ -In the example below the text has multiple lines. The pattern `pattern:/^\d/gm` takes a digit from the beginning of each line: +Dans l'exemple ci-dessous, le texte comporte plusieurs lignes. Le paterne `pattern:/^\d/gm` prend un chiffre au début de chaque ligne: ```js run let str = `1st place: Winnie @@ -20,7 +20,7 @@ alert( str.match(/^\d/gm) ); // 1, 2, 3 */!* ``` -Without the flag `pattern:m` only the first digit is matched: +Sans le marqueur `pattern:m`, seul le premier chiffre est renvoyé : ```js run let str = `1st place: Winnie @@ -32,19 +32,17 @@ alert( str.match(/^\d/g) ); // 1 */!* ``` -That's because by default a caret `pattern:^` only matches at the beginning of the text, and in the multiline mode -- at the start of any line. +Cela est dû au fait que, par défaut, l'accent circonflexe `pattern:^` ne vérifie que le début d'un texte, et dans le mode multiligne -- le début de n'importe quelle ligne. ```smart -"Start of a line" formally means "immediately after a line break": the test `pattern:^` in multiline mode matches at all positions preceeded by a newline character `\n`. - -And at the text start. +"Début de ligne" désigne formellement "immédiatement après un saut à la ligne" : le test `pattern:^` en mode multiligne vérifie à toutes les positions suivant un caractère de retour à la ligne `\n`, en plus du début du texte. ``` -## Searching at line end $ +## Recherche en fin de ligne $ -The dollar sign `pattern:$` behaves similarly. +Le signe dollar `pattern:$` se comporte similairement. -The regular expression `pattern:\d$` finds the last digit in every line +L'expression régulière `pattern:\d$` prend le premier chiffre à la fin de chaque ligne. ```js run let str = `Winnie: 1 @@ -54,21 +52,19 @@ Eeyore: 3`; alert( str.match(/\d$/gm) ); // 1,2,3 ``` -Without the flag `m`, the dollar `pattern:$` would only match the end of the whole text, so only the very last digit would be found. +Sans le marqueur `pattern:m`, le signe dollar `pattern:$` vérifierait uniquement la fin de tout le texte, donc uniquement le tout dernier chiffre serait trouvé. ```smart -"End of a line" formally means "immediately before a line break": the test `pattern:$` in multiline mode matches at all positions succeeded by a newline character `\n`. - -And at the text end. +"Fin de ligne" désigne formellement "immédiatement avant un saut à la ligne" : le test `pattern:$` en mode multiligne vérifie à toutes les positions précédant un caractère de retour à la ligne `\n`, en plus de la fin du texte. ``` -## Searching for \n instead of ^ $ +## Recherche de \n au lieu de ^ $ -To find a newline, we can use not only anchors `pattern:^` and `pattern:$`, but also the newline character `\n`. +Pour chercher un retour à la ligne, nous pouvons non seulement utiliser les ancres `pattern:^` et `pattern:$`, mais également le caractère de retour à la ligne `\n`. -What's the difference? Let's see an example. +Quelle est la différence ? Regardons un exemple. -Here we search for `pattern:\d\n` instead of `pattern:\d$`: +Ici, nous cherchons `pattern:\d\n` au lieu de `pattern:\d$`: ```js run let str = `Winnie: 1 @@ -78,10 +74,10 @@ Eeyore: 3`; alert( str.match(/\d\n/gm) ); // 1\n,2\n ``` -As we can see, there are 2 matches instead of 3. +Comme nous pouvons le voir, il y a 2 correspondances au lieu de 3. -That's because there's no newline after `subject:3` (there's text end though, so it matches `pattern:$`). +C'est parce qu'il n'y a pas de retour à la ligne après `subject:3` (il y a la fin du texte cependant, donc ça correspond avec `pattern:$`). -Another difference: now every match includes a newline character `match:\n`. Unlike the anchors `pattern:^` `pattern:$`, that only test the condition (start/end of a line), `\n` is a character, so it becomes a part of the result. +Une autre différence : maintenant, chaque correspondance inclue un caractère de retour à la ligne `match:\n`. Contrairement aux ancres `pattern:^` `pattern:$`, qui ne testent qu'une condition (début/fin d'une ligne), `\n` est un caractère, donc il devient une partie du résultat. -So, a `\n` in the pattern is used when we need newline characters in the result, while anchors are used to find something at the beginning/end of a line. +Ainsi, un `\n` dans le paterne est utilisé quand nous avons besoin dudit caractère dans le résultat, tandis que les ancres sont utilisées pour chercher quelque chose au début/à la fin d'une ligne. From a3745300b0488cfb21688f56ccd144f4d0217adc Mon Sep 17 00:00:00 2001 From: Aakodal <48600424+Aakodal@users.noreply.github.com> Date: Sat, 9 May 2020 09:05:45 +0000 Subject: [PATCH 2/3] Update article.md --- .../12-regexp-backreferences/article.md | 44 +++++++++---------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/9-regular-expressions/12-regexp-backreferences/article.md b/9-regular-expressions/12-regexp-backreferences/article.md index 83beb803a..d531959db 100644 --- a/9-regular-expressions/12-regexp-backreferences/article.md +++ b/9-regular-expressions/12-regexp-backreferences/article.md @@ -1,33 +1,33 @@ -# Backreferences in pattern: \N and \k +# Rétro référence dans le paterne : \N et \k -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. +Nous pouvons utiliser le contenu des groupes de capture `pattern:(...)` non seulement dans le résultat ou dans la chaîne de caractères de remplacement, mais également dans le paterne en lui-même. -## Backreference by number: \N +## Rétro référence par un nombre : \N -A group can be referenced in the pattern using `pattern:\N`, where `N` is the group number. +Un groupe peut être référencé dans le paterne par `pattern:\N`, où `N` est le numéro du groupe. -To make clear why that's helpful, let's consider a task. +Pour rendre son utilité claire, considérons la tâche ci-dessous. -We need to find quoted strings: either single-quoted `subject:'...'` or a double-quoted `subject:"..."` -- both variants should match. +Nous devons trouver des chaînes citées : soit par des apostrophes `subject:'...'`, soit par des guillemets `subject:"..."` -- les deux variantes devraient correspondre. -How to find them? +Comment les trouver ? -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!"`: +Nous pouvons mettre les deux types entre crochets : `pattern:['"](.*?)['"]`, mais ce paterne pourrait correspondre avec des mélanges comme `match:"...'` ou `match:'..."`. Cela mènerait à des correspondances incorrectes lorsqu'une citation apparaît dans une autre, comme dans le texte `subject:"She's the one!"`: ```js run let str = `He said: "She's the one!".`; let regexp = /['"](.*?)['"]/g; -// The result is not what we'd like to have +// Le résultat n'est pas celui que nous aimerions avoir alert( str.match(regexp) ); // "She' ``` -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. +Comme nous pouvons le voir, le paterne trouve des guillemets ouvrant `match:"`, puis le texte est récupéré jusqu'au `match:'`, ce qui termine la correspondance. -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`. +Pour faire en sorte que le paterne vérifie que le caractère terminant la citation est précisément le même que celui qui l'ouvre, nous pouvons l'envelopper dans un groupe de capture et le rétro référencier : `pattern:(['"])(.*?)\1`. -Here's the correct code: +Voilà le code correct : ```js run let str = `He said: "She's the one!".`; @@ -39,27 +39,27 @@ let regexp = /(['"])(.*?)\1/g; alert( str.match(regexp) ); // "She's the one!" ``` -Now it works! The regular expression engine finds the first quote `pattern:(['"])` and memorizes its content. That's the first capturing group. +Maintenant, ça fonctionne ! Le moteur trouve le premier caractère de citation `pattern:(['"])` et mémorise son contenu. C'est le premier groupe de capture. -Further in the pattern `pattern:\1` means "find the same text as in the first group", exactly the same quote in our case. +Plus loin dans le paterne, `pattern:\1` signifie "cherche le même texte que dans le premier groupe de capture", le même caractère de citation dans notre cas. -Similar to that, `pattern:\2` would mean the contents of the second group, `pattern:\3` - the 3rd group, and so on. +Similairement, `pattern:\2` voudrait référencier le 2nd groupe, `pattern:\3` - le 3e groupe, et ainsi de suite. ```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. +Si nous utilisons `?:` dans le groupe, alors nous ne pouvons pas le référencer. Les groupes exclus de la capture `(?:...)` ne sont pas mémorisés par le moteur. ``` -```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`. +```warn header="Ne mélangez pas : dans le paterne, `pattern:\1`, dans le replacement : `pattern:$1`" +Dans la chaîne de remplacement, on utilise un signe dollar : `pattern:$1`, alors que dans un paterne - un antislash `pattern:\1`. ``` -## Backreference by name: `\k` +## Rétro référence par le nom: `\k` -If a regexp has many parentheses, it's convenient to give them names. +Si une expression régulière a beaucoup de groupes, il est pratique de leur attribuer un nom. -To reference a named group we can use `pattern:\k<имя>`. +Pour référencer un groupe nommé, on peut utiliser `pattern:\k<имя>`. -In the example below the group with quotes is named `pattern:?`, so the backreference is `pattern:\k`: +Dans l'exemple ci-dessous, le groupe du caractère de citation s'appelle `pattern:?`, donc la rétro référence est `pattern:\k`: ```js run let str = `He said: "She's the one!".`; From 82d1303ed5f45e52f02c74a10d2fb78331e2bca3 Mon Sep 17 00:00:00 2001 From: Aakodal <48600424+Aakodal@users.noreply.github.com> Date: Sat, 9 May 2020 10:29:19 +0000 Subject: [PATCH 3/3] Update article.md --- .../05-regexp-multiline-mode/article.md | 48 ++++++++++--------- 1 file changed, 26 insertions(+), 22 deletions(-) diff --git a/9-regular-expressions/05-regexp-multiline-mode/article.md b/9-regular-expressions/05-regexp-multiline-mode/article.md index b4612b103..539f9fa23 100644 --- a/9-regular-expressions/05-regexp-multiline-mode/article.md +++ b/9-regular-expressions/05-regexp-multiline-mode/article.md @@ -1,14 +1,14 @@ -# Mode multiligne des ancres ^ $, marqueur "m" +# Multiline mode of anchors ^ $, flag "m" -Le mode multiligne est activé avec le marqueur `pattern:m`. +The multiline mode is enabled by the flag `pattern:m`. -Il affecte seulement le fonctionnement des ancres `pattern:^` et `pattern:$`. +It only affects the behavior of `pattern:^` and `pattern:$`. -Dans le mode multiligne, elles ne vérifient pas seulement le début et la fin d'une chaîne de caractères, mais également le début et la fin d'une ligne. +In the multiline mode they match not only at the beginning and the end of the string, but also at start/end of line. -## Recherche au début de ligne ^ +## Searching at line start ^ -Dans l'exemple ci-dessous, le texte comporte plusieurs lignes. Le paterne `pattern:/^\d/gm` prend un chiffre au début de chaque ligne: +In the example below the text has multiple lines. The pattern `pattern:/^\d/gm` takes a digit from the beginning of each line: ```js run let str = `1st place: Winnie @@ -20,7 +20,7 @@ alert( str.match(/^\d/gm) ); // 1, 2, 3 */!* ``` -Sans le marqueur `pattern:m`, seul le premier chiffre est renvoyé : +Without the flag `pattern:m` only the first digit is matched: ```js run let str = `1st place: Winnie @@ -32,17 +32,19 @@ alert( str.match(/^\d/g) ); // 1 */!* ``` -Cela est dû au fait que, par défaut, l'accent circonflexe `pattern:^` ne vérifie que le début d'un texte, et dans le mode multiligne -- le début de n'importe quelle ligne. +That's because by default a caret `pattern:^` only matches at the beginning of the text, and in the multiline mode -- at the start of any line. ```smart -"Début de ligne" désigne formellement "immédiatement après un saut à la ligne" : le test `pattern:^` en mode multiligne vérifie à toutes les positions suivant un caractère de retour à la ligne `\n`, en plus du début du texte. +"Start of a line" formally means "immediately after a line break": the test `pattern:^` in multiline mode matches at all positions preceeded by a newline character `\n`. + +And at the text start. ``` -## Recherche en fin de ligne $ +## Searching at line end $ -Le signe dollar `pattern:$` se comporte similairement. +The dollar sign `pattern:$` behaves similarly. -L'expression régulière `pattern:\d$` prend le premier chiffre à la fin de chaque ligne. +The regular expression `pattern:\d$` finds the last digit in every line ```js run let str = `Winnie: 1 @@ -52,19 +54,21 @@ Eeyore: 3`; alert( str.match(/\d$/gm) ); // 1,2,3 ``` -Sans le marqueur `pattern:m`, le signe dollar `pattern:$` vérifierait uniquement la fin de tout le texte, donc uniquement le tout dernier chiffre serait trouvé. +Without the flag `m`, the dollar `pattern:$` would only match the end of the whole text, so only the very last digit would be found. ```smart -"Fin de ligne" désigne formellement "immédiatement avant un saut à la ligne" : le test `pattern:$` en mode multiligne vérifie à toutes les positions précédant un caractère de retour à la ligne `\n`, en plus de la fin du texte. +"End of a line" formally means "immediately before a line break": the test `pattern:$` in multiline mode matches at all positions succeeded by a newline character `\n`. + +And at the text end. ``` -## Recherche de \n au lieu de ^ $ +## Searching for \n instead of ^ $ -Pour chercher un retour à la ligne, nous pouvons non seulement utiliser les ancres `pattern:^` et `pattern:$`, mais également le caractère de retour à la ligne `\n`. +To find a newline, we can use not only anchors `pattern:^` and `pattern:$`, but also the newline character `\n`. -Quelle est la différence ? Regardons un exemple. +What's the difference? Let's see an example. -Ici, nous cherchons `pattern:\d\n` au lieu de `pattern:\d$`: +Here we search for `pattern:\d\n` instead of `pattern:\d$`: ```js run let str = `Winnie: 1 @@ -74,10 +78,10 @@ Eeyore: 3`; alert( str.match(/\d\n/gm) ); // 1\n,2\n ``` -Comme nous pouvons le voir, il y a 2 correspondances au lieu de 3. +As we can see, there are 2 matches instead of 3. -C'est parce qu'il n'y a pas de retour à la ligne après `subject:3` (il y a la fin du texte cependant, donc ça correspond avec `pattern:$`). +That's because there's no newline after `subject:3` (there's text end though, so it matches `pattern:$`). -Une autre différence : maintenant, chaque correspondance inclue un caractère de retour à la ligne `match:\n`. Contrairement aux ancres `pattern:^` `pattern:$`, qui ne testent qu'une condition (début/fin d'une ligne), `\n` est un caractère, donc il devient une partie du résultat. +Another difference: now every match includes a newline character `match:\n`. Unlike the anchors `pattern:^` `pattern:$`, that only test the condition (start/end of a line), `\n` is a character, so it becomes a part of the result. -Ainsi, un `\n` dans le paterne est utilisé quand nous avons besoin dudit caractère dans le résultat, tandis que les ancres sont utilisées pour chercher quelque chose au début/à la fin d'une ligne. +So, a `\n` in the pattern is used when we need newline characters in the result, while anchors are used to find something at the beginning/end of a line.