Skip to content

Commit a374530

Browse files
authored
Update article.md
1 parent c96c235 commit a374530

File tree

1 file changed

+22
-22
lines changed
  • 9-regular-expressions/12-regexp-backreferences

1 file changed

+22
-22
lines changed

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

Lines changed: 22 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1,33 +1,33 @@
1-
# Backreferences in pattern: \N and \k<name>
1+
# Rétro référence dans le paterne : \N et \k<name>
22

3-
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.
3+
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.
44

5-
## Backreference by number: \N
5+
## Rétro référence par un nombre : \N
66

7-
A group can be referenced in the pattern using `pattern:\N`, where `N` is the group number.
7+
Un groupe peut être référencé dans le paterne par `pattern:\N`, `N` est le numéro du groupe.
88

9-
To make clear why that's helpful, let's consider a task.
9+
Pour rendre son utilité claire, considérons la tâche ci-dessous.
1010

11-
We need to find quoted strings: either single-quoted `subject:'...'` or a double-quoted `subject:"..."` -- both variants should match.
11+
Nous devons trouver des chaînes citées : soit par des apostrophes `subject:'...'`, soit par des guillemets `subject:"..."` -- les deux variantes devraient correspondre.
1212

13-
How to find them?
13+
Comment les trouver ?
1414

15-
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!"`:
15+
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!"`:
1616

1717
```js run
1818
let str = `He said: "She's the one!".`;
1919

2020
let regexp = /['"](.*?)['"]/g;
2121

22-
// The result is not what we'd like to have
22+
// Le résultat n'est pas celui que nous aimerions avoir
2323
alert( str.match(regexp) ); // "She'
2424
```
2525

26-
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.
26+
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.
2727

28-
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`.
28+
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`.
2929

30-
Here's the correct code:
30+
Voilà le code correct :
3131

3232
```js run
3333
let str = `He said: "She's the one!".`;
@@ -39,27 +39,27 @@ let regexp = /(['"])(.*?)\1/g;
3939
alert( str.match(regexp) ); // "She's the one!"
4040
```
4141

42-
Now it works! The regular expression engine finds the first quote `pattern:(['"])` and memorizes its content. That's the first capturing group.
42+
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.
4343

44-
Further in the pattern `pattern:\1` means "find the same text as in the first group", exactly the same quote in our case.
44+
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.
4545

46-
Similar to that, `pattern:\2` would mean the contents of the second group, `pattern:\3` - the 3rd group, and so on.
46+
Similairement, `pattern:\2` voudrait référencier le 2nd groupe, `pattern:\3` - le 3e groupe, et ainsi de suite.
4747

4848
```smart
49-
If we use `?:` in the group, then we can't reference it. Groups that are excluded from capturing `(?:...)` are not memorized by the engine.
49+
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.
5050
```
5151

52-
```warn header="Don't mess up: in the pattern `pattern:\1`, in the replacement: `pattern:$1`"
53-
In the replacement string we use a dollar sign: `pattern:$1`, while in the pattern - a backslash `pattern:\1`.
52+
```warn header="Ne mélangez pas : dans le paterne, `pattern:\1`, dans le replacement : `pattern:$1`"
53+
Dans la chaîne de remplacement, on utilise un signe dollar : `pattern:$1`, alors que dans un paterne - un antislash `pattern:\1`.
5454
```
5555
56-
## Backreference by name: `\k<name>`
56+
## Rétro référence par le nom: `\k<name>`
5757
58-
If a regexp has many parentheses, it's convenient to give them names.
58+
Si une expression régulière a beaucoup de groupes, il est pratique de leur attribuer un nom.
5959
60-
To reference a named group we can use `pattern:\k<имя>`.
60+
Pour référencer un groupe nommé, on peut utiliser `pattern:\k<имя>`.
6161
62-
In the example below the group with quotes is named `pattern:?<quote>`, so the backreference is `pattern:\k<quote>`:
62+
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>`:
6363
6464
```js run
6565
let str = `He said: "She's the one!".`;

0 commit comments

Comments
 (0)