diff --git a/1-js/02-first-steps/07-operators/4-fix-prompt/solution.md b/1-js/02-first-steps/07-operators/4-fix-prompt/solution.md new file mode 100644 index 000000000..4bd775012 --- /dev/null +++ b/1-js/02-first-steps/07-operators/4-fix-prompt/solution.md @@ -0,0 +1,32 @@ +La raison en est que l'invite renvoie l'entrée utilisateur sous forme de chaîne. + +Les variables ont donc respectivement les valeurs `"1"` et `"2"`. + +```js run +let a = "1"; // prompt("First number?", 1); +let b = "2"; // prompt("Second number?", 2); + +alert(a + b); // 12 +``` + +Ce que nous devons faire est de convertir les chaînes en nombres avant `+`. Par exemple, en utilisant `Number ()` ou en les ajoutant au début avec `+`. + +Par exemple, juste avant `prompt`: + +```js run +let a = +prompt("First number?", 1); +let b = +prompt("Second number?", 2); + +alert(a + b); // 3 +``` + +Ou dans l'`alert`: + +```js run +let a = prompt("First number?", 1); +let b = prompt("Second number?", 2); + +alert(+a + +b); // 3 +``` + +Nous utilisons à la fois unaire et binaire `+` dans le dernier code. Ça a l'air drôle, non? \ No newline at end of file diff --git a/1-js/02-first-steps/07-operators/4-fix-prompt/task.md b/1-js/02-first-steps/07-operators/4-fix-prompt/task.md new file mode 100644 index 000000000..8759e1692 --- /dev/null +++ b/1-js/02-first-steps/07-operators/4-fix-prompt/task.md @@ -0,0 +1,18 @@ +importance: 5 + +--- + +# Corrigez l'addition + +Voici un code qui demande à l'utilisateur deux nombres et montre leur somme. + +Cela ne fonctionne pas correctement. La sortie dans l'exemple ci-dessous est `12` (pour les valeurs d'invite par défaut). + +Pourquoi ? Réparez-le. Le résultat doit être `3`. + +```js run +let a = prompt("First number?", 1); +let b = prompt("Second number?", 2); + +alert(a + b); // 12 +``` diff --git a/1-js/02-first-steps/07-operators/article.md b/1-js/02-first-steps/07-operators/article.md index 4212803ed..779e7a3ef 100644 --- a/1-js/02-first-steps/07-operators/article.md +++ b/1-js/02-first-steps/07-operators/article.md @@ -1,6 +1,6 @@ # Opérateurs -De nombreux opérateurs nous sont connus de l'école. Ce sont les additions `+`, multiplications `*`, soustractions `-` et ainsi de suite. +De nombreux opérateurs nous sont connus de l'école. Ce sont les additions `+`, multiplications `*`, soustractions `-` et ainsi de suite. Dans ce chapitre, nous nous concentrons sur les aspects qui ne sont pas couverts par l'arithmétique scolaire. @@ -19,7 +19,7 @@ Avant de continuer, saisissons la terminologie commune. */!* alert( x ); // -1, le moins unaire a été appliqué ``` -- Un opérateur est `binaire` s'il a deux opérandes. La même négation existe également dans la forme binaire : +- Un opérateur est *binaire* s'il a deux opérandes. La même négation existe également dans la forme binaire : ```js run no-beautify let x = 1, y = 3; @@ -28,6 +28,52 @@ Avant de continuer, saisissons la terminologie commune. D'un point de vue formel, dans les exemples ci-dessus, nous avons deux opérateurs différents qui partagent le même symbole : l'opérateur de négation, un opérateur unaire qui inverse le signe, et l'opérateur de soustraction, un opérateur binaire qui soustrait un nombre d'un autre. +## Opérations mathématiques + +Les opérations mathématiques suivantes sont supportées : + +- Addition `+`, +- Soustraction `-`, +- Multiplication `*`, +- Division `/`, +- Reste `%`, +- Exponentiation `**`. + +Les quatre premières sont assez simples, tandis que `%` et `**` nécéssitent quelques explications. + +### Reste % (Modulo) + +L'opérateur reste `%`, malgré son apparence, n'est pas lié aux pourcentages. + +Le résultat de `a % b` est le [reste](https://fr.wikipedia.org/wiki/Reste) de la division entière de `a` par `b`. + +Par exemple: + +```js run +alert( 5 % 2 ); // 1, le reste de 5 divisé par 2 +alert( 8 % 3 ); // 2, le reste de 8 divisé par 3 +``` + +### Exponentiation ** + +L'opérateur d'exponentiation `a ** b` multiplie `a` par lui-même `b` fois. + +Par exemple: + +```js run +alert( 2 ** 2 ); // 4 (2 multiplié par lui-même 2 fois) +alert( 2 ** 3 ); // 8 (2 * 2 * 2, 3 fois) +alert( 2 ** 4 ); // 16 (2 * 2 * 2 * 2, 4 fois) +``` + +Mathématiquement, l'exponentiation est également définie pour les nombres non entiers. Par exemple, une racine carrée est une exponentiation de `1/2`: + +```js run +alert( 4 ** (1/2) ); // 2 (la puissance de 1/2 équivaut à une racine carrée) +alert( 8 ** (1/3) ); // 2 (la puissance de 1/3 équivaut à une racine cubique) +``` + + ## Concaténation de chaînes de caractères, binaire `+` Voyons maintenant les caractéristiques spéciales des opérateurs JavaScript qui sont au-delà de l’arithmétique scolaire. @@ -56,23 +102,24 @@ Cependant, notez que les opérations se déroulent de gauche à droite. S'il y a ```js run -alert(2 + 2 + '1' ); // "41" and not "221" +alert(2 + 2 + '1' ); // "41" et non "221" ``` -La concaténation et la conversion en chaînes de caractères sont une caractéristique particulière du binaire plus `+`. Les autres opérateurs arithmétiques ne travaillent qu'avec des nombres. Ils convertissent toujours leurs opérandes en nombres. +Ici, les opérateurs travaillent les uns après les autres. Le premier `+` additionne deux nombres, donc il renvoie `4`, puis le `+` suivant ajoute la chaîne `1`, donc c'est comme `4 + '1' = 41`. -Par exemple, soustraction et division : +Le binaire `+` est le seul opérateur qui prend en charge les chaînes de cette manière. D'autres opérateurs arithmétiques ne fonctionnent qu'avec des nombres et convertissent toujours leurs opérandes en nombres. +Voici l'exemple pour la soustraction et la division: ```js run -alert( 2 - '1' ); // 1 -alert( '6' / '2' ); // 3 +alert( 6 - '2' ); // 4, convertit '2' en nombre +alert( '6' / '2' ); // 3, convertit les deux opérandes en nombres ``` ## Conversion numérique, unaire + Le plus `+` existe sous deux formes. La forme binaire que nous avons utilisée ci-dessus et la forme unaire. -L’unaire plus ou, en d’autres termes, l’opérateur plus `+` appliqué à une seule valeur, ne fait rien avec les nombres, mais si l’opérande n’est pas un nombre, alors il est converti en nombre. +L’unaire plus ou, en d’autres termes, l’opérateur plus `+` appliqué à une seule valeur, ne fait rien avec les nombres, mais si l’opérande n’est pas un nombre, alors il est convertit en nombre. Par exemple : @@ -95,7 +142,6 @@ En fait, il fait la même chose que `Number(...)`, mais il est plus court. La nécessité de convertir des chaînes de caractères en nombres est très fréquente. Par exemple, si nous obtenons des valeurs à partir de champs de formulaire HTML, il s’agit généralement de chaînes de caractères. Et si on veut les additionner ? - Le binaire plus les ajouterait comme des chaînes de caractères : ```js run @@ -141,6 +187,7 @@ Un extrait du [tableau de précédence](https://developer.mozilla.org/fr/docs/We | ... | ... | ... | | 17 | plus unaire | `+` | | 17 | négation unaire | `-` | +| 16 | exponentiation | `**` | | 15 | multiplication | `*` | | 15 | division | `/` | | 13 | addition | `+` | @@ -163,28 +210,15 @@ let x = 2 * 2 + 1; alert( x ); // 5 ``` -Il est possible de chaîner des affectations : - -```js run -let a, b, c; - -*!* -a = b = c = 2 + 2; -*/!* - -alert( a ); // 4 -alert( b ); // 4 -alert( c ); // 4 -``` +### Assignment = retourne une valeur -Les affectations en chaîne sont évaluées de droite à gauche. D'abord, l'expression la plus à droite `2 + 2` est évaluée puis assignée aux variables de gauche: `c`, `b` et `a`. À la fin, toutes les variables partagent une seule valeur. +Le fait que `=` soit un opérateur, pas une construction de langage "magique" a une implication intéressante. -````smart header="L'opérateur d'affectation `\"=\"` renvoie une valeur" -Un opérateur retourne toujours une valeur. C’est évident pour la plupart d’entre eux, comme une addition `+` ou une multiplication `*`. Mais l'opérateur d'affectation suit également cette règle. +La plupart des opérateurs en JavaScript renvoient une valeur. C'est évident pour `+` et `-`, mais aussi vrai pour `=`. -L'appel `x = valeur` écrit la valeur dans `x` puis `la retourne`. +L'appel `x = valeur` écrit la` valeur` dans `x` *puis la renvoie*. -Voici un exemple qui utilise une affectation dans le cadre d'une expression plus complexe : +Voici un exemple qui utilise une affectation dans le cadre d'une expression plus complexe: ```js run let a = 1; @@ -198,46 +232,71 @@ alert( a ); // 3 alert( c ); // 0 ``` -Dans l'exemple ci-dessus, le résultat de `(a = b + 1)` est la valeur attribuée à `a` (c'est-à-dire `3`). Il est ensuite utilisé pour d'autres évaluations. - -Code drôle, n'est-ce pas ? Nous devrions comprendre comment cela fonctionne, car parfois nous pouvons le voir dans des bibliothèques tierces, mais nous ne devrions pas écrire quoi que ce soit de similaire nous-mêmes. De telles astuces ne permettent pas de rendre le code plus clair et lisible. -```` +Dans l'exemple ci-dessus, le résultat de l'expression`(a = b + 1)` est la valeur qui a été affectée à `a` (c'est-à-dire `3`). Il est ensuite utilisé pour d'autres évaluations. -## Reste % (Modulo) +Drôle de code, n'est-ce pas? Nous devons comprendre comment cela fonctionne, car parfois nous le voyons dans les bibliothèques JavaScript. -L'opérateur reste `%` malgré son apparence n'a pas de relation avec les pourcentages. +Cependant, n'écrivez pas le code comme ça. De telles astuces ne rendent certainement pas le code plus clair ou lisible. -Le résultat de `a % b` est le reste de la division entière de `a` par `b`. +### Affectations chaînées -Par exemple : +Une autre caractéristique intéressante est la possibilité de chaîner des affectations : ```js run -alert( 5 % 2 ); // 1 est le reste de 5 divisé par 2 -alert( 8 % 3 ); // 2 est le reste de 8 divisé par 3 -alert( 6 % 3 ); // 0 est le reste de 6 divisé par 3 +let a, b, c; + +*!* +a = b = c = 2 + 2; +*/!* + +alert( a ); // 4 +alert( b ); // 4 +alert( c ); // 4 ``` -## Exponentiation ** +Les affectations en chaîne sont évaluées de droite à gauche. D'abord, l'expression la plus à droite `2 + 2` est évaluée puis assignée aux variables de gauche: `c`, `b` et `a`. À la fin, toutes les variables partagent une seule valeur. -L'opérateur d'exponentiation `**` est un ajout récent au langage. +Encore une fois, pour des raisons de lisibilité, il est préférable de diviser ce code en quelques lignes: -Pour un entier naturel `b`, le résultat de `a ** b` est `a` multiplié par lui-même `b`fois. +```js +c = 2 + 2; +b = c; +a = c; +``` +C'est plus facile à lire, en particulier lors de la numérisation rapide du code. + +## Modification sur place + +Nous avons souvent besoin d'appliquer un opérateur à une variable et d'y stocker le nouveau résultat. Par exemple : +```js +let n = 2; +n = n + 5; +n = n * 2; +``` + +Cette notation peut être raccourcie en utilisant les opérateurs `+=` et `*=` : + ```js run -alert( 2 ** 2 ); // 4 (2 * 2) -alert( 2 ** 3 ); // 8 (2 * 2 * 2) -alert( 2 ** 4 ); // 16 (2 * 2 * 2 * 2) +let n = 2; +n += 5; // maintenant n = 7 (identique à n = n + 5) +n *= 2; // maintenant n = 14 (identique à n = n * 2) + +alert( n ); // 14 ``` -L'opérateur travaille également pour les nombres non entiers. +Il existe de opérateurs de "modification et assignation" courts pour tous les opérateurs arithmétiques et binaires: `/=`, `-=` etc. -Par exemple : +Ces opérateurs ont la même précédence qu'une affectation normale. Ils s'exécutent donc après la plupart des autres calculs : ```js run -alert( 4 ** (1/2) ); // 2 (puissance de 1/2 est la même chose qu'une racine carrée, c'est des maths) -alert( 8 ** (1/3) ); // 2 (la puissance de 1/3 est la même que celle d'une racine cubique) +let n = 2; + +n *= 3 + 5; + +alert( n ); // 16 (partie droite évaluée en premier, identique à n *= 8) ``` ## Incrémentation / décrémentation @@ -287,7 +346,7 @@ let a = ++counter; // (*) alert(a); // *!*2*/!* ``` -Ici, dans la ligne `(*)`, l'appel du préfixe `++counter` incrémente le compteur et retourne la nouvelle valeur qui est 2. Ainsi, l'alerte affiche 2. +Ici, dans la ligne `(*)`, l'appel du *préfixe* `++counter` incrémente le compteur et retourne la nouvelle valeur qui est `2`. Ainsi, l'`alert` affiche `2`. Maintenant, utilisons la forme postfixe : @@ -298,7 +357,7 @@ let a = counter++; // (*) changé ++counter pour counter++ alert(a); // *!*1*/!* ``` -Dans la ligne `(*)`, la forme postfixe `counter++` incrémente également `counter`, mais renvoie l'**ancienne** valeur (avant l'incrémentation). Donc, l'`alert` montre 1. +Dans la ligne `(*)`, la forme postfixe `counter++` incrémente également `counter`, mais renvoie l'*ancienne* valeur (avant l'incrémentation). Donc, l'`alert` montre `1`. Pour résumer : @@ -371,40 +430,6 @@ La liste des opérateurs : Ces opérateurs sont très rarement utilisés. Pour les comprendre, nous devrions nous intéresser à la représentation numérique de bas niveau, et il ne serait pas optimal de le faire dès maintenant. Surtout parce que nous n’en aurons pas besoin de sitôt. Si vous êtes curieux, vous pouvez lire l'article [Opérateurs binaires](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires) sur MDN. Il serait plus pratique de le faire quand un besoin réel se fait sentir. -## Modification sur place - -Nous avons souvent besoin d'appliquer un opérateur à une variable et d'y stocker le nouveau résultat. - -Par exemple : - -```js -let n = 2; -n = n + 5; -n = n * 2; -``` - -Cette notation peut être raccourcie en utilisant les opérateurs `+=` et `*=` : - -```js run -let n = 2; -n += 5; // maintenant n = 7 (identique à n = n + 5) -n *= 2; // maintenant n = 14 (identique à n = n * 2) - -alert( n ); // 14 -``` - -Il existe de opérateurs de "modification et assignation" courts pour tous les opérateurs arithmétiques et binaires: `/=`, `-=` etc. - -Ces opérateurs ont la même précédence qu'une affectation normale. Ils s'exécutent donc après la plupart des autres calculs : - -```js run -let n = 2; - -n *= 3 + 5; - -alert( n ); // 16 (partie droite évaluée en premier, identique à n *= 8) -``` - ## Virgule L'opérateur virgule `,` est l'un des opérateurs les plus rares et les plus inhabituels. Parfois, il faut écrire un code plus court, il faut donc le connaître pour comprendre ce qui se passe. diff --git a/9-regular-expressions/03-regexp-unicode/article.md b/9-regular-expressions/03-regexp-unicode/article.md index fb8fed470..98d12546a 100644 --- a/9-regular-expressions/03-regexp-unicode/article.md +++ b/9-regular-expressions/03-regexp-unicode/article.md @@ -1,121 +1,121 @@ -# Unicode: flag "u" and class \p{...} +# Unicode: indicateur "u" et classe \p{...} -JavaScript uses [Unicode encoding](https://en.wikipedia.org/wiki/Unicode) for strings. Most characters are encoded with 2 bytes, but that allows to represent at most 65536 characters. +JavaScript utilise [l'encodage Unicode](https://fr.wikipedia.org/wiki/Unicode) pour les chaînes de cractères. La plupart des caractères sont codés sur 2 octets, mais cela permet de représenter au plus 65536 caractères. -That range is not big enough to encode all possible characters, that's why some rare characters are encoded with 4 bytes, for instance like `𝒳` (mathematical X) or `😄` (a smile), some hieroglyphs and so on. +Cette plage n'est pas assez grande pour encoder tous les caractères possibles, c'est pourquoi certains caractères rares sont encodés sur 4 octets, par exemple comme `𝒳` (X mathématique) ou `😄` (un sourire), certains hiéroglyphes et ainsi de suite. -Here are the unicode values of some characters: +Voici les valeurs unicode de certains caractères : -| Character | Unicode | Bytes count in unicode | -|------------|---------|--------| -| a | `0x0061` | 2 | -| ≈ | `0x2248` | 2 | -|𝒳| `0x1d4b3` | 4 | -|𝒴| `0x1d4b4` | 4 | -|😄| `0x1f604` | 4 | +| Caractère | Unicode | Nombre d'octets en unicode | +|-----------|---------|----------| +| a | `0x0061` | 2 | +| ≈ | `0x2248` | 2 | +| 𝒳 | `0x1d4b3` | 4 | +| 𝒴 | `0x1d4b4` | 4 | +| 😄 | `0x1f604` | 4 | -So characters like `a` and `≈` occupy 2 bytes, while codes for `𝒳`, `𝒴` and `😄` are longer, they have 4 bytes. +Ainsi, les caractères comme `a` et `≈` occupent 2 octets, tandis que les codes pour `𝒳`, `𝒴` et `😄` sont plus longs, ils ont 4 octets. -Long time ago, when JavaScript language was created, Unicode encoding was simpler: there were no 4-byte characters. So, some language features still handle them incorrectly. +Il y a longtemps, lorsque le langage JavaScript a été créé, l'encodage Unicode était plus simple : il n'y avait pas de caractères à 4 octets. Ainsi, certaines fonctionnalités du langage les gèrent toujours de manière incorrecte. -For instance, `length` thinks that here are two characters: +Par exemple, la propriété `length` pense qu'il y a deux caractères : ```js run alert('😄'.length); // 2 alert('𝒳'.length); // 2 ``` -...But we can see that there's only one, right? The point is that `length` treats 4 bytes as two 2-byte characters. That's incorrect, because they must be considered only together (so-called "surrogate pair", you can read about them in the article ). +... Mais nous pouvons voir qu'il n'y en a qu'un, n'est-ce pas? Le fait est que la propriété `length` traite 4 octets comme deux caractères de 2 octets. C'est incorrect, car ils doivent être considérés uniquement ensemble (aussi appelé "paire de substitution", vous pouvez en lire plus dans l'article ). -By default, regular expressions also treat 4-byte "long characters" as a pair of 2-byte ones. And, as it happens with strings, that may lead to odd results. We'll see that a bit later, in the article . +Par défaut, les expressions régulières traitent également les "caractères longs" de 4 octets comme une paire de caractères de 2 octets. Et, comme cela arrive avec les chaînes, cela peut conduire à des résultats étranges. Nous verrons cela un peu plus tard, dans l'article . -Unlike strings, regular expressions have flag `pattern:u` that fixes such problems. With such flag, a regexp handles 4-byte characters correctly. And also Unicode property search becomes available, we'll get to it next. +Contrairement aux chaînes de caractères, les expressions régulières ont l'indicateur `pattern:u` qui résout ces problèmes. Avec un tel indicateur, une expression rationnelle gère correctement les caractères de 4 octets. Et ainsi la recherche de propriétés Unicode devient également disponible, nous y reviendrons ensuite. -## Unicode properties \p{...} +## Propriétés Unicode \p{...} -```warn header="Not supported in Firefox and Edge" -Despite being a part of the standard since 2018, unicode properties are not supported in Firefox ([bug](https://bugzilla.mozilla.org/show_bug.cgi?id=1361876)) and Edge ([bug](https://github.com/Microsoft/ChakraCore/issues/2969)). +```warn header =" Non pris en charge par Firefox et Edge " +Bien qu'elles fassent partie de la norme depuis 2018, les propriétés unicode ne sont pas prises en charge dans Firefox ([bug](https://bugzilla.mozilla.org/show_bug.cgi?id=1361876)) et Edge ([bug](https://github.com/Microsoft/ChakraCore/issues/2969)). -There's [XRegExp](http://xregexp.com) library that provides "extended" regular expressions with cross-browser support for unicode properties. +Il existe une bibliothèque logicielle [XRegExp](http://xregexp.com) qui fournit des expressions régulières "étendues" avec prise en charge multi-navigateur pour les propriétés unicode. ``` -Every character in Unicode has a lot of properties. They describe what "category" the character belongs to, contain miscellaneous information about it. +Chaque caractère dans Unicode a beaucoup de propriétés. Ils décrivent à quelle "catégorie" le caractère appartient, et contiennent diverses informations à son sujet. -For instance, if a character has `Letter` property, it means that the character belongs to an alphabet (of any language). And `Number` property means that it's a digit: maybe Arabic or Chinese, and so on. +Par exemple, si un caractère a la propriété `Letter` (Lettre), cela signifie que le caractère appartient à un alphabet (de n'importe quelle langue). Et la propriété `Number` (Nombre) signifie que c'est un chiffre : peut-être l'arabe ou le chinois, et ainsi de suite. -We can search for characters with a property, written as `pattern:\p{…}`. To use `pattern:\p{…}`, a regular expression must have flag `pattern:u`. +Nous pouvons rechercher des caractères avec une propriété, écrite sous la forme `pattern:\p{…}`. Pour utiliser `pattern:\p{…}`, une expression régulière doit avoir l'indicateur `pattern:u`. -For instance, `\p{Letter}` denotes a letter in any of language. We can also use `\p{L}`, as `L` is an alias of `Letter`. There are shorter aliases for almost every property. +Par exemple, `\p{Letter}` désigne une lettre dans n'importe quelle langue. Nous pouvons également utiliser `\p{L}`, car `L` est un alias de `Letter` (Lettre). Il existe des alias plus courts pour presque toutes les propriétés. -In the example below three kinds of letters will be found: English, Georgean and Korean. +Dans l'exemple ci-dessous, on trouvera trois types de lettres : Anglais, Géorgien et Coréen. ```js run let str = "A ბ ㄱ"; alert( str.match(/\p{L}/gu) ); // A,ბ,ㄱ -alert( str.match(/\p{L}/g) ); // null (no matches, as there's no flag "u") +alert( str.match(/\p{L}/g) ); // null (aucune correspondance, puisqu'il n'y a pas l'indicateur "u") ``` -Here's the main character categories and their subcategories: - -- Letter `L`: - - lowercase `Ll` - - modifier `Lm`, - - titlecase `Lt`, - - uppercase `Lu`, - - other `Lo`. -- Number `N`: - - decimal digit `Nd`, - - letter number `Nl`, - - other `No`. -- Punctuation `P`: - - connector `Pc`, - - dash `Pd`, - - initial quote `Pi`, - - final quote `Pf`, - - open `Ps`, - - close `Pe`, - - other `Po`. -- Mark `M` (accents etc): - - spacing combining `Mc`, - - enclosing `Me`, - - non-spacing `Mn`. -- Symbol `S`: - - currency `Sc`, - - modifier `Sk`, - - math `Sm`, - - other `So`. -- Separator `Z`: - - line `Zl`, - - paragraph `Zp`, - - space `Zs`. -- Other `C`: - - control `Cc`, +Voici les principales catégories de caractères et leurs sous-catégories : + +- Lettre `L` : + - minuscules `Ll`, + - modificateur `Lm`, + - titre `Lt`, + - majuscule `Lu`, + - autres `Lo`. +- Nombre `N` : + - chiffre décimal `Nd`, + - numéro de lettre `Nl`, + - autre `No`. +- Ponctuation `P` : + - connecteur `Pc`, + - tiret `Pd`, + - citation initiale `Pi`, + - citation finale `Pf`, + - ponctuation ouvrante `Ps`, + - ponctuation fermante `Pe`, + - autre `Po`. +- Marqueur `M` (accents, etc.) : + - espacement combinant `Mc`, + - contenant `Me`, + - sans espacement `Mn`. +- Symbole `S` : + - devise `Sc`, + - modificateur `Sk`, + - mathématique `Sm`, + - autre `So`. +- Séparateur `Z` : + - ligne `Zl`, + - paragraphe `Zp`, + - espace `Zs`. +- Autre `C` : + - contrôle `Cc`, - format `Cf`, - - not assigned `Cn`, - -- private use `Co`, - - surrogate `Cs`. + - non affecté `Cn`, + - usage privé `Co`, + - substitut `Cs`. -So, e.g. if we need letters in lower case, we can write `pattern:\p{Ll}`, punctuation signs: `pattern:\p{P}` and so on. +Ainsi, par exemple si nous avons besoin de lettres en minuscules, nous pouvons écrire `pattern:\p{Ll}`, de signes de ponctuation : `pattern:\p{P}` et ainsi de suite. -There are also other derived categories, like: -- `Alphabetic` (`Alpha`), includes Letters `L`, plus letter numbers `Nl` (e.g. Ⅻ - a character for the roman number 12), plus some other symbols `Other_Alphabetic` (`OAlpha`). -- `Hex_Digit` includes hexadecimal digits: `0-9`, `a-f`. -- ...And so on. +Il existe également d'autres catégories dérivées, comme : +- `Alphabetic` (Alphabétique)(`Alpha`), qui comprend les lettres `L`, plus les numéros de lettre `Nl` (par exemple Ⅻ - un caractère pour le chiffre romain 12), plus quelques autres symboles `Other_Alphabetic` (Autre alphabétiques)(`OAlpha`). +- `Hex_Digit` comprend des chiffres hexadécimaux : `0-9`, `a-f`. +- ...Et ainsi de suite. -Unicode supports many different properties, their full list would require a lot of space, so here are the references: +Unicode prend en charge de nombreuses propriétés différentes, leur liste complète nécessiterait beaucoup d'espace, voici donc les références : -- List all properties by a character: . -- List all characters by a property: . -- Short aliases for properties: . -- A full base of Unicode characters in text format, with all properties, is here: . +- Liste de toutes les propriétés par caractère : . +- Liste de tous les caractères par propriété : . +- Alias ​​courts pour les propriétés : . +- Une base complète de caractères Unicode au format texte, avec toutes les propriétés, se trouve ici: . -### Example: hexadecimal numbers +### Exemple : nombres hexadécimaux -For instance, let's look for hexadecimal numbers, written as `xFF`, where `F` is a hex digit (0..1 or A..F). +Par exemple, recherchons des nombres hexadécimaux, écrits sous la forme `xFF`, où `F` est un chiffre hexadécimal (0..1 ou A..F). -A hex digit can be denoted as `pattern:\p{Hex_Digit}`: +Un chiffre hexadécimal peut être désigné par `pattern:\p{Hex_Digit}` : ```js run let regexp = /x\p{Hex_Digit}\p{Hex_Digit}/u; @@ -123,27 +123,27 @@ let regexp = /x\p{Hex_Digit}\p{Hex_Digit}/u; alert("number: xAF".match(regexp)); // xAF ``` -### Example: Chinese hieroglyphs +### Exemple : Hiéroglyphes Chinois -Let's look for Chinese hieroglyphs. +Cherchons des hiéroglyphes Chinois. -There's a unicode property `Script` (a writing system), that may have a value: `Cyrillic`, `Greek`, `Arabic`, `Han` (Chinese) and so on, [here's the full list]("https://en.wikipedia.org/wiki/Script_(Unicode)"). +Il y a une propriété unicode `Script` (un système d'écriture), qui peut avoir une valeur : `Cyrillic` (Cyrillique), `Greek` (Grec),`Arabic` (Arabe), `Han` (Chinois) et ainsi de suite, [voici la liste complète]("https://en.wikipedia.org/wiki/Script_(Unicode)"). -To look for characters in a given writing system we should use `pattern:Script=`, e.g. for Cyrillic letters: `pattern:\p{sc=Cyrillic}`, for Chinese hieroglyphs: `pattern:\p{sc=Han}`, and so on: +Pour rechercher des caractères dans un système d'écriture donné, nous devons utiliser `pattern:Script=`, par exemple pour les lettres cyrilliques : `pattern:\p{sc=Cyrillic}`, pour les hiéroglyphes chinois : `pattern:\p{sc=Han}`, et ainsi de suite : ```js run -let regexp = /\p{sc=Han}/gu; // returns Chinese hieroglyphs +let regexp = /\p{sc=Han}/gu; // renvoie des hiéroglyphes Chinois let str = `Hello Привет 你好 123_456`; alert( str.match(regexp) ); // 你,好 ``` -### Example: currency +### Exemple: devise -Characters that denote a currency, such as `$`, `€`, `¥`, have unicode property `pattern:\p{Currency_Symbol}`, the short alias: `pattern:\p{Sc}`. +Les caractères qui désignent une devise, tels que `$`, `€`, `¥`, ont la propriété unicode `pattern:\p{Currency_Symbol}`, l'alias court : `pattern:\p{Sc}`. -Let's use it to look for prices in the format "currency, followed by a digit": +Utilisons-le pour rechercher des prix au format "devise, suivi d'un chiffre" : ```js run let regexp = /\p{Sc}\d/gu; @@ -153,15 +153,15 @@ let str = `Prices: $2, €1, ¥9`; alert( str.match(regexp) ); // $2,€1,¥9 ``` -Later, in the article we'll see how to look for numbers that contain many digits. +Plus loin, dans l'article , nous verrons comment rechercher des nombres contenant de nombreux chiffres. -## Summary +## Résumé -Flag `pattern:u` enables the support of Unicode in regular expressions. +L'indicateur `pattern:u` permet la prise en charge d'Unicode dans les expressions régulières. -That means two things: +Cela signifie deux choses : -1. Characters of 4 bytes are handled correctly: as a single character, not two 2-byte characters. -2. Unicode properties can be used in the search: `\p{…}`. +1. Les caractères de 4 octets sont traités correctement : comme un seul caractère, pas comme deux caractères de 2 octets. +2. Les propriétés Unicode peuvent être utilisées dans la recherche : `\p{…}`. -With Unicode properties we can look for words in given languages, special characters (quotes, currencies) and so on. +Avec les propriétés Unicode, nous pouvons rechercher des mots dans des langues données, des caractères spéciaux (guillemets, devises) et ainsi de suite. \ No newline at end of file