Merge pull request #200 from Aakodal/9.12-regexp-backreferences

Backreferences in pattern: \N and \k

Author: HachemiH

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.

9-regular-expressions/12-regexp-backreferences/article.md

@@ -1,33 +1,33 @@
-# Backreferences in pattern: \N and \k<name>
+# Rétro référence dans le paterne : \N et \k<name>
 
-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<name>`
+## Rétro référence par le nom: `\k<name>`
 
-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:?<quote>`, so the backreference is `pattern:\k<quote>`:
+Dans l'exemple ci-dessous, le groupe du caractère de citation s'appelle `pattern:?<quote>`, donc la rétro référence est `pattern:\k<quote>`:
 
 ```js run
 let str = `He said: "She's the one!".`;