From f7d99eaa1741f7d5b501c55a6ed61b8ccf74855b Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 03:39:52 +0100 Subject: [PATCH 01/30] Conflict fixed on "An Introduction to JavaScript" page in french language --- 1-js/01-getting-started/1-intro/article.md | 5 ----- 1 file changed, 5 deletions(-) diff --git a/1-js/01-getting-started/1-intro/article.md b/1-js/01-getting-started/1-intro/article.md index b87a7a94c..f0c78bc32 100644 --- a/1-js/01-getting-started/1-intro/article.md +++ b/1-js/01-getting-started/1-intro/article.md @@ -67,12 +67,7 @@ Les exemples de telles restrictions sont: Les navigateurs modernes lui permettent de fonctionner avec des fichiers, mais l'accès est limité et n'est fourni que si l'utilisateur effectue certaines actions, comme «déposer» un fichier dans une fenêtre de navigateur ou le sélectionner via une balise ``. -<<<<<<< HEAD Il existe des moyens d’interagir avec une webcam/microphone et d’autres appareils, mais ils nécessitent une autorisation explicite de l’utilisateur. Ainsi, une page compatible avec JavaScript ne permet pas d'activer une caméra Web, d'observer l'environnement et d'envoyer les informations à la [NSA](https://fr.wikipedia.org/wiki/National_Security_Agency). -======= - There are ways to interact with camera/microphone and other devices, but they require a user's explicit permission. So a JavaScript-enabled page may not sneakily enable a web-camera, observe the surroundings and send the information to the [NSA](https://en.wikipedia.org/wiki/National_Security_Agency). -- Different tabs/windows generally do not know about each other. Sometimes they do, for example when one window uses JavaScript to open the other one. But even in this case, JavaScript from one page may not access the other if they come from different sites (from a different domain, protocol or port). ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 - Différents onglets / fenêtres ne se connaissent généralement pas. Parfois, ils se croisent, par exemple lorsqu'une fenêtre utilise JavaScript pour ouvrir l'autre. Mais même dans ce cas, le JavaScript d'une page ne peut pas accéder à l'autre si elle provient de sites différents (provenant d'un autre domaine, protocole ou port). From ca6912a33aaf30d48bbd69ce0e6f8d3b08fbb182 Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 03:43:13 +0100 Subject: [PATCH 02/30] Conflict fixed "Developer console" page in french language --- 1-js/01-getting-started/4-devtools/article.md | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/1-js/01-getting-started/4-devtools/article.md b/1-js/01-getting-started/4-devtools/article.md index 3845d65db..1b61d16db 100644 --- a/1-js/01-getting-started/4-devtools/article.md +++ b/1-js/01-getting-started/4-devtools/article.md @@ -8,11 +8,7 @@ Pour voir les erreurs et obtenir beaucoup d’informations utiles sur les script Le plus souvent, les développeurs se tournent vers Chrome ou Firefox pour le développement, car ces navigateurs disposent des meilleurs outils de développement. D'autres navigateurs fournissent également des outils de développement, parfois dotés de fonctions spéciales, mais jouent généralement le rôle de "rattrapage" pour Chrome ou Firefox. Donc, la plupart des gens ont un navigateur "favori" et passent à d'autres si un problème est spécifique au navigateur. -<<<<<<< HEAD -Les outils de développement sont très puissants, il existe de nombreuses fonctionnalités. Pour commencer, nous allons apprendre à les ouvrir, à examiner les erreurs et à exécuter des commandes JavaScript. -======= -Developer tools are potent, they have many features. To start, we'll learn how to open them, look at errors, and run JavaScript commands. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Les outils de développement sont très puissants, ils possèdent de nombreuses fonctionnalités. Pour commencer, nous allons apprendre à les ouvrir, à examiner les erreurs et à exécuter des commandes JavaScript. ## Google Chrome From c3efba810c7215cc43d4ecb0b9eddeef16c62cd4 Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 03:47:39 +0100 Subject: [PATCH 03/30] Conflict fixed on Polyfills page in french language --- 1-js/03-code-quality/06-polyfills/article.md | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/1-js/03-code-quality/06-polyfills/article.md b/1-js/03-code-quality/06-polyfills/article.md index f4b7a9461..da963aa8f 100644 --- a/1-js/03-code-quality/06-polyfills/article.md +++ b/1-js/03-code-quality/06-polyfills/article.md @@ -23,12 +23,8 @@ Actuellement, Babel comporte deux parties : 2. Ensuite, le polyfill. -<<<<<<< HEAD -Les nouvelles fonctionnalités du langage peuvent inclure de nouvelles fonctions intégrées et de nouvelles constructions de syntaxe. Le transpiler réécrit le code en transformant les nouvelles constructions de syntaxe en anciennes. Mais en ce qui concerne les nouvelles fonctions intégrées, nous devons les implémenter. JavaScript est un langage très dynamique, les scripts peuvent ajouter / modifier n’importe quelle fonction, afin qu’ils se comportent conformément au standard moderne. -======= - New language features may include not only syntax constructs, but also built-in functions. - The transpiler rewrites the code, transforming syntax constructs into older ones. But as for new built-in functions, we need to implement them. JavaScript is a highly dynamic language, scripts may add/modify any functions, so that they behave according to the modern standard. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 + Les nouvelles fonctionnalités du langage peuvent inclure de nouvelles fonctions intégrées et de nouvelles constructions de syntaxe. + Le transpiler réécrit le code en transformant les nouvelles constructions de syntaxe en anciennes. Mais en ce qui concerne les nouvelles fonctions intégrées, nous devons les implémenter. JavaScript est un langage très dynamique, les scripts peuvent ajouter / modifier n’importe quelle fonction, afin qu’ils se comportent conformément au standard moderne. Un script qui met à jour / ajoute de nouvelles fonctions s'appelle "polyfill". Il "comble" le vide et ajoute les implémentations manquantes. From cd64cb2f0a6ba4c32762b9eb41552d9320240901 Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 03:49:47 +0100 Subject: [PATCH 04/30] Conflict fixed on "Garbage collection" page in french language --- 1-js/04-object-basics/03-garbage-collection/article.md | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/1-js/04-object-basics/03-garbage-collection/article.md b/1-js/04-object-basics/03-garbage-collection/article.md index cc3df4e65..ee0732ddb 100644 --- a/1-js/04-object-basics/03-garbage-collection/article.md +++ b/1-js/04-object-basics/03-garbage-collection/article.md @@ -23,11 +23,7 @@ En termes simples, les valeurs "accessibles" sont celles qui sont accessibles ou 2. Toute autre valeur est considérée comme accessible si elle est accessible depuis une racine par une référence ou par une chaîne de références. -<<<<<<< HEAD - Par exemple, s’il existe un objet dans une variable globale et que cet objet a une propriété référençant un autre objet, cet objet est considéré comme accessible. Et ceux auxquels il fait référence sont également accessibles. Des exemples détaillés à suivre. -======= - For instance, if there's an object in a global variable, and that object has a property referencing another object, *that* object is considered reachable. And those that it references are also reachable. Detailed examples to follow. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 + Par exemple, s’il existe un objet dans une variable globale et que cet objet a une propriété référençant un autre objet, *cet* objet est considéré comme accessible. Et ceux auxquels il fait référence sont également accessibles. Des exemples détaillés à suivre. Il existe un processus d’arrière-plan dans le moteur JavaScript appelé [Ramasse-miettes (Garbage Collector)](https://fr.wikipedia.org/wiki/Ramasse-miettes_(informatique)). Il surveille tous les objets et supprime ceux qui sont devenus inaccessibles. From c2082d4f4497786de0ae03d178c1fa356dd5eda9 Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 04:19:37 +0100 Subject: [PATCH 05/30] Conflicts fixed on "Optional chaining '?.'" page in french language --- .../07-optional-chaining/article.md | 121 +++------ = | 238 ++++++++++++++++++ 2 files changed, 269 insertions(+), 90 deletions(-) create mode 100644 = diff --git a/1-js/04-object-basics/07-optional-chaining/article.md b/1-js/04-object-basics/07-optional-chaining/article.md index 3d8541ae5..bb9adc8e5 100644 --- a/1-js/04-object-basics/07-optional-chaining/article.md +++ b/1-js/04-object-basics/07-optional-chaining/article.md @@ -12,60 +12,36 @@ Le chaînage optionnel `?.` Est un moyen sécurisé d'accéder aux propriétés Si vous venez de commencer à lire le tutoriel et à apprendre JavaScript, peut-être que le problème ne vous a pas encore touché, mais c'est assez courant. -<<<<<<< HEAD -À titre d'exemple, considérons les objets pour les données utilisateur. La plupart de nos utilisateurs ont des adresses dans la propriété `user.address`, avec la rue `user.address.street`, mais certains ne les ont pas fournies. -Dans ce cas, lorsque nous tentons d'obtenir `user.address.street`, nous obtenons une erreur : +À titre d'exemple, disons que nous avons des objets `user` qui contiennent les informations sur nos utilisateurs. -```js run -let user = {}; // l'utilisateur sans propriété "address" - -======= -As an example, let's say we have `user` objects that hold the information about our users. - -Most of our users have addresses in `user.address` property, with the street `user.address.street`, but some did not provide them. +La plupart de nos utilisateurs ont des adresses dans la propriété `user.address`, avec la rue `user.address.street`, mais certains ne les ont pas fournies. -In such case, when we attempt to get `user.address.street`, and the user happens to be without an address, we get an error: +Dans ce cas, lorsque nous essayons d'obtenir `user.address.street`, et que l'utilisateur se trouve sans adresse, nous obtenons une erreur : ```js run -let user = {}; // a user without "address" property ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +let user = {}; // un utilisateur sans propriété "address" + alert(user.address.street); // Error! ``` -<<<<<<< HEAD - -C'est le résultat attendu, JavaScript fonctionne comme ça, mais dans de nombreux cas pratiques, nous préférerions obtenir `undefined` au lieu d'une erreur (signifiant "pas de rue"). +C'est le résultat attendu. JavaScript fonctionne comme ça. Comme `user.address` est `undefined`, une tentative d'obtention de `user.address.street` échoue avec une erreur. -... Et un autre exemple. Dans le développement Web, nous pouvons avoir besoin d'obtenir une information sur un élément de la page, qui n'existe parfois pas: +Dans de nombreux cas pratiques, nous préférerions obtenir `undefined` au lieu d'une erreur ici (signifiant "pas de rue"). +... Et un autre exemple. Dans le développement Web, nous pouvons obtenir un objet qui correspond à un élément de page Web à l'aide d'un appel de méthode spécial, tel que `document.querySelector('.elem')`, et il renvoie `null` lorsqu'il n'y a pas ce type d'élément. ```js run -// Erreur si le résultat de querySelector(...) est null -let html = document.querySelector('.my-element').innerHTML; -``` - -Avant l'apparition de `?.` Dans le langage, l'opérateur `&&` était utilisé pour contourner ce problème. - -Par exemple : -======= -That's the expected result. JavaScript works like this. As `user.address` is `undefined`, an attempt to get `user.address.street` fails with an error. - -In many practical cases we'd prefer to get `undefined` instead of an error here (meaning "no street"). - -...And another example. In the web development, we can get an object that corresponds to a web page element using a special method call, such as `document.querySelector('.elem')`, and it returns `null` when there's no such element. - -```js run -// document.querySelector('.elem') is null if there's no element +// document.querySelector('.elem') est nul s'il n'y a pas d'élément let html = document.querySelector('.elem').innerHTML; // error if it's null ``` -Once again, if the element doesn't exist, we'll get an error accessing `.innerHTML` of `null`. And in some cases, when the absence of the element is normal, we'd like to avoid the error and just accept `html = null` as the result. +Encore une fois, si l'élément n'existe pas, nous obtiendrons une erreur lors de l'accès à `.innerHTML` de` null`. Et dans certains cas, lorsque l'absence de l'élément est normale, nous aimerions éviter l'erreur et accepter simplement `html = null` comme résultat. -How can we do this? +Comment peut-on le faire ? -The obvious solution would be to check the value using `if` or the conditional operator `?`, before accessing its property, like this: +La solution évidente serait de vérifier la valeur en utilisant `if` ou l'opérateur conditionnel `?`, Avant d'accéder à sa propriété, comme ceci : ```js let user = {}; @@ -73,22 +49,21 @@ let user = {}; alert(user.address ? user.address.street : undefined); ``` -It works, there's no error... But it's quite inelegant. As you can see, the `"user.address"` appears twice in the code. For more deeply nested properties, that becomes a problem as more repetitions are required. +Cela fonctionne, il n'y a pas d'erreur ... Mais c'est assez inélégant. Comme vous pouvez le voir, `"user.address"` apparaît deux fois dans le code. Pour des propriétés plus profondément imbriquées, cela devient un problème car plus de répétitions sont nécessaires. -E.g. let's try getting `user.address.street.name`. +Par exemple. essayons d'obtenir `user.address.street.name`. -We need to check both `user.address` and `user.address.street`: +Nous devons vérifier à la fois `user.address` et `user.address.street` : ```js -let user = {}; // user has no address +let user = {}; // l'utilisateur n'a pas d'adresse alert(user.address ? user.address.street ? user.address.street.name : null : null); ``` -That's just awful, one may even have problems understanding such code. +C'est juste horrible, on peut même avoir des problèmes pour comprendre un tel code. -Don't even care to, as there's a better way to write it, using the `&&` operator: ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Ne vous en souciez même pas, car il existe une meilleure façon de l'écrire, en utilisant l'opérateur `&&` : ```js run let user = {}; // l'utilisateur n'a pas d'adresse @@ -96,37 +71,26 @@ let user = {}; // l'utilisateur n'a pas d'adresse alert( user.address && user.address.street && user.address.street.name ); // undefined (no error) ``` -<<<<<<< HEAD -======= -AND'ing the whole path to the property ensures that all components exist (if not, the evaluation stops), but also isn't ideal. +Et le chemin complet vers la propriété garantit que tous les composants existent (sinon, l'évaluation s'arrête), mais n'est pas non plus idéal. -As you can see, property names are still duplicated in the code. E.g. in the code above, `user.address` appears three times. +Comme vous pouvez le voir, les noms de propriétés sont toujours dupliqués dans le code. Par exemple. dans le code ci-dessus, `user.address` apparaît trois fois. -That's why the optional chaining `?.` was added to the language. To solve this problem once and for all! ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +C'est pourquoi le chaînage facultatif `?.` A été ajouté au langage. Pour résoudre ce problème une fois pour toutes ! ET l'ensemble du chemin d'accès à la propriété garantit que tous les composants existent (sinon, l'évaluation s'arrête), mais est difficile à écrire. ## Chaînage optionnel -<<<<<<< HEAD -Le chaînage facultatif `?.` Arrête l'évaluation et renvoie `undefined` si la partie avant `?.` est `undefined` ou `null`. -======= -The optional chaining `?.` stops the evaluation if the part before `?.` is `undefined` or `null` and returns that part. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Le chaînage facultatif `?.` arrête l'évaluation et renvoie `undefined` si la partie avant `?.` est `undefined` ou `null` et renvoie cette partie. **Plus loin dans cet article, par souci de brièveté, nous dirons que quelque chose "existe" si ce n'est pas "null" et non "undefined".** -<<<<<<< HEAD -Voici le moyen sûr d'accéder `user.address.street` : -======= -In other words, `value?.prop`: -- is the same as `value.prop` if `value` exists, -- otherwise (when `value` is `undefined/null`) it returns `undefined`. +En d'autres termes, `value?.prop` : +- est identique à `value.prop` si `value` existe, +- sinon (lorsque `value` est `undefined/nul`), il renvoie `undefined`. -Here's the safe way to access `user.address.street` using `?.`: ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Voici le moyen sûr d'accéder à `user.address.street` en utilisant `?.` : ```js run let user = {}; // l'utilisateur n'a pas d'adresse @@ -134,13 +98,9 @@ let user = {}; // l'utilisateur n'a pas d'adresse alert( user?.address?.street ); // undefined (no error) ``` -<<<<<<< HEAD -La lecture de l'adresse avec `user?.address` fonctionne même si l'objet `user` n'existe pas : -======= -The code is short and clean, there's no duplication at all. +Le code est court et propre, il n'y a aucune duplication. -Reading the address with `user?.address` works even if `user` object doesn't exist: ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +La lecture de l'adresse avec `user?.address` fonctionne même si l'objet `user` n'existe pas : ```js run let user = null; @@ -151,25 +111,12 @@ alert( user?.address.street ); // undefined Remarque: la syntaxe `?.` Rend facultative la valeur qui la précède, mais pas plus. -<<<<<<< HEAD -Dans l'exemple ci-dessus, `user?.` Permet uniquement à `user` d'être `null/undefined`. - -D'un autre côté, si `user` existe, alors il doit avoir la propriété `user.address`, sinon `user?.address.street` donne une erreur au deuxième point. -======= -E.g. in `user?.address.street.name` the `?.` allows `user` to be `null/undefined`, but it's all it does. Further properties are accessed in a regular way. If we want some of them to be optional, then we'll need to replace more `.` with `?.`. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Par exemple. dans `user?.address.street.name` le `?.` permet à `user` d'être `null/undefined`, mais c'est tout ce qu'il fait. D'autres propriétés sont accessibles de manière régulière. Si nous voulons que certains d'entre eux soient optionnels, alors nous devrons remplacer plus de `.` par `?.`. ```warn header="N'abusez pas du chaînage optionnel" Nous ne devrions utiliser `?.` que là où il est normal que quelque chose n'existe pas. -<<<<<<< HEAD -Par exemple, si selon notre logique de codage, l'objet `user` doit être là, mais que `address` est facultatif, alors `user.address?.street` serait mieux. - - -Donc, si `user` n'est pas défini en raison d'une erreur, nous verrons une erreur de programmation à ce sujet et la corrigerons. Sinon, les erreurs de codage peuvent être réduites au silence lorsqu'elles ne sont pas appropriées et devenir plus difficiles à déboguer. -======= -For example, if according to our coding logic `user` object must exist, but `address` is optional, then we should write `user.address?.street`, but not `user?.address?.street`. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Par exemple, si selon notre logique de codage, l'objet `user` doit exister, mais que `address` est facultatif, alors nous devrions écrire `user.address?.street`, mais pas `user?.address?.street`. ``` @@ -180,13 +127,7 @@ S'il n'y a pas du tout de variable `user`, alors `user?.anything` déclenche une // ReferenceError: user is not defined user?.address; ``` -<<<<<<< HEAD - -Il doit y avoir une déclaration (par exemple `let/const/var user`). Le chaînage optionnel ne fonctionne que pour les variables déclarées. - -======= -The variable must be declared (e.g. `let/const/var user` or as a function parameter). The optional chaining works only for declared variables. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +La variable doit être déclarée (par exemple `let/const/var user` ou en tant que paramètre de fonction). Le chaînage facultatif ne fonctionne que pour les variables déclarées. ```` ## Court-circuit diff --git a/= b/= new file mode 100644 index 000000000..bb9adc8e5 --- /dev/null +++ b/= @@ -0,0 +1,238 @@ + + +# Chaînage optionnel '?.' + +[recent browser="new"] + + +Le chaînage optionnel `?.` Est un moyen sécurisé d'accéder aux propriétés d'objet imbriquées, même si une propriété intermédiaire n'existe pas. + +## Le problème de la "propriété non existante" + + +Si vous venez de commencer à lire le tutoriel et à apprendre JavaScript, peut-être que le problème ne vous a pas encore touché, mais c'est assez courant. + + +À titre d'exemple, disons que nous avons des objets `user` qui contiennent les informations sur nos utilisateurs. + +La plupart de nos utilisateurs ont des adresses dans la propriété `user.address`, avec la rue `user.address.street`, mais certains ne les ont pas fournies. + +Dans ce cas, lorsque nous essayons d'obtenir `user.address.street`, et que l'utilisateur se trouve sans adresse, nous obtenons une erreur : + +```js run +let user = {}; // un utilisateur sans propriété "address" + + +alert(user.address.street); // Error! +``` + +C'est le résultat attendu. JavaScript fonctionne comme ça. Comme `user.address` est `undefined`, une tentative d'obtention de `user.address.street` échoue avec une erreur. + +Dans de nombreux cas pratiques, nous préférerions obtenir `undefined` au lieu d'une erreur ici (signifiant "pas de rue"). + +... Et un autre exemple. Dans le développement Web, nous pouvons obtenir un objet qui correspond à un élément de page Web à l'aide d'un appel de méthode spécial, tel que `document.querySelector('.elem')`, et il renvoie `null` lorsqu'il n'y a pas ce type d'élément. + +```js run +// document.querySelector('.elem') est nul s'il n'y a pas d'élément +let html = document.querySelector('.elem').innerHTML; // error if it's null +``` + +Encore une fois, si l'élément n'existe pas, nous obtiendrons une erreur lors de l'accès à `.innerHTML` de` null`. Et dans certains cas, lorsque l'absence de l'élément est normale, nous aimerions éviter l'erreur et accepter simplement `html = null` comme résultat. + +Comment peut-on le faire ? + +La solution évidente serait de vérifier la valeur en utilisant `if` ou l'opérateur conditionnel `?`, Avant d'accéder à sa propriété, comme ceci : + +```js +let user = {}; + +alert(user.address ? user.address.street : undefined); +``` + +Cela fonctionne, il n'y a pas d'erreur ... Mais c'est assez inélégant. Comme vous pouvez le voir, `"user.address"` apparaît deux fois dans le code. Pour des propriétés plus profondément imbriquées, cela devient un problème car plus de répétitions sont nécessaires. + +Par exemple. essayons d'obtenir `user.address.street.name`. + +Nous devons vérifier à la fois `user.address` et `user.address.street` : + +```js +let user = {}; // l'utilisateur n'a pas d'adresse + +alert(user.address ? user.address.street ? user.address.street.name : null : null); +``` + +C'est juste horrible, on peut même avoir des problèmes pour comprendre un tel code. + +Ne vous en souciez même pas, car il existe une meilleure façon de l'écrire, en utilisant l'opérateur `&&` : + +```js run +let user = {}; // l'utilisateur n'a pas d'adresse + +alert( user.address && user.address.street && user.address.street.name ); // undefined (no error) +``` + +Et le chemin complet vers la propriété garantit que tous les composants existent (sinon, l'évaluation s'arrête), mais n'est pas non plus idéal. + +Comme vous pouvez le voir, les noms de propriétés sont toujours dupliqués dans le code. Par exemple. dans le code ci-dessus, `user.address` apparaît trois fois. + +C'est pourquoi le chaînage facultatif `?.` A été ajouté au langage. Pour résoudre ce problème une fois pour toutes ! + +ET l'ensemble du chemin d'accès à la propriété garantit que tous les composants existent (sinon, l'évaluation s'arrête), mais est difficile à écrire. + + +## Chaînage optionnel + +Le chaînage facultatif `?.` arrête l'évaluation et renvoie `undefined` si la partie avant `?.` est `undefined` ou `null` et renvoie cette partie. + +**Plus loin dans cet article, par souci de brièveté, nous dirons que quelque chose "existe" si ce n'est pas "null" et non "undefined".** + +En d'autres termes, `value?.prop` : +- est identique à `value.prop` si `value` existe, +- sinon (lorsque `value` est `undefined/nul`), il renvoie `undefined`. + +Voici le moyen sûr d'accéder à `user.address.street` en utilisant `?.` : + +```js run +let user = {}; // l'utilisateur n'a pas d'adresse + +alert( user?.address?.street ); // undefined (no error) +``` + +Le code est court et propre, il n'y a aucune duplication. + +La lecture de l'adresse avec `user?.address` fonctionne même si l'objet `user` n'existe pas : + +```js run +let user = null; + +alert( user?.address ); // undefined +alert( user?.address.street ); // undefined +``` + +Remarque: la syntaxe `?.` Rend facultative la valeur qui la précède, mais pas plus. + +Par exemple. dans `user?.address.street.name` le `?.` permet à `user` d'être `null/undefined`, mais c'est tout ce qu'il fait. D'autres propriétés sont accessibles de manière régulière. Si nous voulons que certains d'entre eux soient optionnels, alors nous devrons remplacer plus de `.` par `?.`. + +```warn header="N'abusez pas du chaînage optionnel" +Nous ne devrions utiliser `?.` que là où il est normal que quelque chose n'existe pas. + +Par exemple, si selon notre logique de codage, l'objet `user` doit exister, mais que `address` est facultatif, alors nous devrions écrire `user.address?.street`, mais pas `user?.address?.street`. + +``` + +````warn header="La variable avant `?.` doit être déclarée" +S'il n'y a pas du tout de variable `user`, alors `user?.anything` déclenche une erreur : + +```js run +// ReferenceError: user is not defined +user?.address; +``` +La variable doit être déclarée (par exemple `let/const/var user` ou en tant que paramètre de fonction). Le chaînage facultatif ne fonctionne que pour les variables déclarées. +```` + +## Court-circuit + +Comme il a été dit précédemment, le `?.` arrête immédiatement ("court-circuite") l'évaluation si la partie gauche n'existe pas. + + +Donc, s'il y a d'autres appels de fonction ou effets secondaires, ils ne se produisent pas : + +Par exemple : + +```js run +let user = null; +let x = 0; + + +user?.sayHi(x++); // pas de "sayHi", donc l'exécution n'atteint pas x++ + + +alert(x); // 0, la valeur n'est pas incrémenté +``` + + +## Autres variantes : ?.(), ?.[] + +`?.` n'est pas un opérateur, mais une construction syntaxique particulière qui fonctionne aussi avec les appels de fonction et les crochets. + +Par exemple, `?.()` est utilisé pour exécuter une fonction seulement si elle existe. + +Ainsi dans cet exemple la méthode `admin` n'existe pas pour tout le monde : + +```js run +let userAdmin = { + admin() { + alert("I am admin"); + } +}; + +let userGuest = {}; + +*!* +userAdmin.admin?.(); // I am admin +*/!* + +*!* +userGuest.admin?.(); // nothing (no such method) +*/!* +``` + + +Ici, dans les deux lignes, nous utilisons d'abord le point (`user1.admin`) pour obtenir la propriété `admin`, car l'objet utilisateur doit exister, donc il peut être lu en toute sécurité. +Puis `?.()` Vérifie la partie gauche : si la fonction admin existe, alors elle s'exécute (c'est le cas pour `user1`). Sinon (pour `user2`) l'évaluation s'arrête sans erreur. + + +La syntaxe `?.[]` Fonctionne également, si nous voulons utiliser des crochets `[]` pour accéder aux propriétés au lieu du point `.`. Similaire aux cas précédents, il permet de lire en toute sécurité une propriété à partir d'un objet qui peut ne pas exister. + +```js run +let user1 = { + firstName: "John" +}; + +let user2 = null; // Imaginez, nous ne pouvons pas autoriser l'utilisateur + +let key = "firstName"; + +alert( user1?.[key] ); // John +alert( user2?.[key] ); // undefined + +alert( user1?.[key]?.something?.not?.existing); // undefined +``` + +Nous pouvons également utiliser `?.` avec `delete` : + +```js run +delete user?.name; // supprime user.name si user existe +``` + + +```warn header="Nous pouvons utiliser `?.` pour lire et supprimer en toute sécurité, mais pas pour écrire" +Le chaînage optionnel `?.` n'a aucune utilité sur le côté gauche d'une affectation : + + +For example: +```js run + +let user = null; + +user?.name = "John"; // Erreur, ne fonctionne pas +// car il évalue à undefined = "John" +``` +Ce n'est tout simplement pas si intelligent. + +## Résumé + +Le chaînage optionnel '?.' A trois formes : + +1. `obj?.prop` -- retourne `obj.prop` si `obj` existe, sinon `undefined`. +2. `obj?.[prop]` -- retourne `obj[prop]` si `obj` existe, sinon `undefined`. +3. `obj?.method()` -- appel `obj.method()` si `obj.method` existe, sinon retourne `undefined`. + + +Comme nous pouvons le voir, tous sont simples et simples à utiliser. Le `?.` vérifie la partie gauche pour `nul/undefined` et permet à l'évaluation de se poursuivre si ce n'est pas le cas. + +Une chaîne de `?.` permet d'accéder en toute sécurité aux propriétés imbriquées. + + +Néanmoins, nous devons appliquer «?.» Avec soin, uniquement s'il est acceptable que la partie gauche n'existe pas. Pour ne pas nous cacher les erreurs de programmation, si elles se produisent. + From d68e05dd9c591b4a127070b3f291d2c47f640570 Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 04:32:54 +0100 Subject: [PATCH 06/30] Conflict fixed on Numbers page in french language --- 1-js/05-data-types/02-number/article.md | 4 ---- 1 file changed, 4 deletions(-) diff --git a/1-js/05-data-types/02-number/article.md b/1-js/05-data-types/02-number/article.md index fb75d36cc..484df69db 100644 --- a/1-js/05-data-types/02-number/article.md +++ b/1-js/05-data-types/02-number/article.md @@ -408,13 +408,9 @@ Quelques exemples: alert( Math.pow(2, 10) ); // 2 puissance 10 = 1024 ``` -<<<<<<< HEAD Il y a plus de fonctions et de constantes dans l'objet Math, y compris la trigonométrie, que vous pouvez trouver dans la [documentation de l'objet Math](https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Math). ## Résumé -======= -There are more functions and constants in `Math` object, including trigonometry, which you can find in the [docs for the Math object](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Math). ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 Pour écrire de nombres avec beaucoup de zéros : From 71c01f4bbcc1fa97e71e8f1195674308c2a78964 Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 04:39:47 +0100 Subject: [PATCH 07/30] Conflicts fixed on "Array methods" and task page in french langugage --- .../05-data-types/05-array-methods/2-filter-range/task.md | 6 +----- 1-js/05-data-types/05-array-methods/article.md | 8 ++------ 2 files changed, 3 insertions(+), 11 deletions(-) diff --git a/1-js/05-data-types/05-array-methods/2-filter-range/task.md b/1-js/05-data-types/05-array-methods/2-filter-range/task.md index 0088bf403..37d97e588 100644 --- a/1-js/05-data-types/05-array-methods/2-filter-range/task.md +++ b/1-js/05-data-types/05-array-methods/2-filter-range/task.md @@ -4,11 +4,7 @@ importance: 4 # Filter range -<<<<<<< HEAD -Ecrivez une fonction `filterRange(arr, a, b)` qui obtient un tableau `arr`, recherche les éléments compris entre `a` et `b` et retourne un tableau. -======= -Write a function `filterRange(arr, a, b)` that gets an array `arr`, looks for elements with values higher or equal to `a` and lower or equal to `b` and return a result as an array. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Ecrivez une fonction `filterRange(arr,a,b)` qui obtient un tableau `arr`, recherche les éléments avec des valeurs supérieures ou égales à `a` et inférieures ou égales à `b` et retourne un résultat sous forme de tableau. La fonction ne doit pas modifier le tableau. Elle doit juste retourner le nouveau tableau. diff --git a/1-js/05-data-types/05-array-methods/article.md b/1-js/05-data-types/05-array-methods/article.md index 3472c6d47..738fb4e78 100755 --- a/1-js/05-data-types/05-array-methods/article.md +++ b/1-js/05-data-types/05-array-methods/article.md @@ -749,13 +749,9 @@ Ces méthodes sont les plus utilisées, elles couvrent 99% des cas d'utilisation La fonction `fn` est appelée sur chaque élément du tableau comme pour `map`. Si n'importe quel/tous les résultats sont `true`, il retourne vrai, sinon il retourne `false`. -<<<<<<< HEAD -Ces méthodes se comportent en quelque sorte comme les opérateurs `||` et `&&` : si `fn` renvoie une valeur vraie, `arr.some()` retourne immédiatement `true` et arrête d'itérer sur les autres éléments ; si `fn` renvoie une valeur fausse, `arr.every()` retourne immédiatement `false` et arrête également d'itérer sur les autres éléments. -======= - The function `fn` is called on each element of the array similar to `map`. If any/all results are `true`, returns `true`, otherwise `false`. + La fonction `fn` est appelée sur chaque élément du tableau similaire à `map`. Si un/tous les résultats sont `true`, renvoie `true`, sinon `false`. - These methods behave sort of like `||` and `&&` operators: if `fn` returns a truthy value, `arr.some()` immediately returns `true` and stops iterating over the rest items; if `fn` returns a falsy value, `arr.every()` immediately returns `false` and stops iterating over the rest items as well. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 + Ces méthodes se comportent en quelque sorte comme les opérateurs `||` et `&&` : si `fn` renvoie une valeur de vérité, `arr.some()` renvoie immédiatement `true` et arrête de parcourir les autres éléments ; si `fn` renvoie une valeur falsifiée, `arr.every()`retourne immédiatement `false` et arrête également d'itérer sur les autres éléments. On peut utiliser `every` pour compaere les tableaux : ```js run From aac58dd23bbddd1985f88e747af103ff0999e359 Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 04:43:09 +0100 Subject: [PATCH 08/30] Conflict fixed on "WeakMap and WeakSet" page in french language --- 1-js/05-data-types/08-weakmap-weakset/article.md | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/1-js/05-data-types/08-weakmap-weakset/article.md b/1-js/05-data-types/08-weakmap-weakset/article.md index 3873ce2cc..55178af82 100644 --- a/1-js/05-data-types/08-weakmap-weakset/article.md +++ b/1-js/05-data-types/08-weakmap-weakset/article.md @@ -30,14 +30,9 @@ let array = [ john ]; john = null; // écraser la référence *!* -<<<<<<< HEAD -// John est stocké à l'intérieur du tableau, donc il ne sera pas nettoyé (garbage-collected) -// nous pouvons l'atteindre avec array[0] -======= -// the object previously referenced by john is stored inside the array -// therefore it won't be garbage-collected -// we can get it as array[0] ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +// l'objet précédemment référencé par john est stocké dans le tableau +// donc il ne sera pas nettoyé +// nous pouvons l'obtenir sous forme de array[0] */!* ``` From 23c26ffceee908a0fe4f4dd36ed15873a033db18 Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 04:46:10 +0100 Subject: [PATCH 09/30] Conflicts fixed on "Recursion and stack" page and task in french language --- .../01-recursion/02-factorial/solution.md | 4 ---- 1-js/06-advanced-functions/01-recursion/article.md | 10 +--------- 2 files changed, 1 insertion(+), 13 deletions(-) diff --git a/1-js/06-advanced-functions/01-recursion/02-factorial/solution.md b/1-js/06-advanced-functions/01-recursion/02-factorial/solution.md index e1be3701b..50ede5993 100644 --- a/1-js/06-advanced-functions/01-recursion/02-factorial/solution.md +++ b/1-js/06-advanced-functions/01-recursion/02-factorial/solution.md @@ -1,8 +1,4 @@ -<<<<<<< HEAD Par définition, une factorielle est `n!` peut être écrit `n * (n-1)!`. -======= -By definition, a factorial `n!` can be written as `n * (n-1)!`. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 En d'autres termes, le résultat de `factorial(n)` peut être calculé comme `n` multiplié par le résultat de `factorial(n-1)`. Et l'appel de `n-1` peut récursivement descendre plus bas, et plus bas, jusqu'à `1`. diff --git a/1-js/06-advanced-functions/01-recursion/article.md b/1-js/06-advanced-functions/01-recursion/article.md index 873c53a37..9af424522 100644 --- a/1-js/06-advanced-functions/01-recursion/article.md +++ b/1-js/06-advanced-functions/01-recursion/article.md @@ -132,11 +132,7 @@ Nous pouvons l'esquisser comme: -<<<<<<< HEAD C'est à ce moment que la fonction commence à s'exécuter. La condition`n == 1` est faux, donc le flux continue dans la deuxième branche de `if`: -======= -That's when the function starts to execute. The condition `n == 1` is falsy, so the flow continues into the second branch of `if`: ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 ```js run function pow(x, n) { @@ -192,11 +188,7 @@ Le nouveau contexte d'exécution actuel est en haut (et en gras) et les contexte Quand on termine le sous-appel -- il est facile de reprendre le contexte précédent, car il conserve les deux variables et l'emplacement exact du code où il s'est arrêté. ```smart -<<<<<<< HEAD -Ici, dans l'image, nous utilisons le mot "ligne", comme dans notre exemple, il n'y a qu'un seul sous-appel en ligne, mais généralement une seule ligne de code peut contenir plusieurs sous-appels, comme `pow(…) + pow(…) + somethingElse(…)`. -======= -Here in the picture we use the word "line", as in our example there's only one subcall in line, but generally a single line of code may contain multiple subcalls, like `pow(…) + pow(…) + somethingElse(…)`. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Ici, dans l'image, nous utilisons le mot "line", comme dans notre exemple, il n'y a qu'un seul sous-appel en ligne, mais généralement une seule ligne de code peut contenir plusieurs sous-appels, comme `pow(…) + pow(…) + somethingElse(…)`. Il serait donc plus précis de dire que l'exécution reprend "immédiatement après le sous-appel". ``` From 4d44f351cddba0fbb1c929eeb29d4d9a5d88f100 Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 04:48:17 +0100 Subject: [PATCH 10/30] Conflict fixed on The old "var" page in french language --- 1-js/06-advanced-functions/04-var/article.md | 13 ++----------- 1 file changed, 2 insertions(+), 11 deletions(-) diff --git a/1-js/06-advanced-functions/04-var/article.md b/1-js/06-advanced-functions/04-var/article.md index e2c0decda..71f6876e2 100644 --- a/1-js/06-advanced-functions/04-var/article.md +++ b/1-js/06-advanced-functions/04-var/article.md @@ -82,11 +82,7 @@ function sayHi() { } sayHi(); -<<<<<<< HEAD -alert(phrase); // Erreur : phrase n'est pas définie (vérifiez la console développeur) -======= -alert(phrase); // Error: phrase is not defined ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +alert(phrase); // Erreur : phrase n'est pas définie ``` Comme nous pouvons le constater, `var` pénètre à travers `if`, `for` ou les autres blocs de code. C'est parce que, il y a longtemps, les blocs de JavaScript n'avaient pas d'environnements lexicaux, et `var` est un vestige de ce dernier. @@ -283,13 +279,8 @@ Dans tous les cas ci-dessus, nous déclarons une fonction expression et l'exécu Il y a deux différences majeures entre `var` et `let/const`: -<<<<<<< HEAD -1. Les variables `var` n'ont pas de portée de bloc ; leur visibilité est étendue à la fonction actuelle, ou globale, si elle est déclarée hors fonction. +1. Les variables `var` n'ont pas de portée de bloc, leur visibilité est étendue à la fonction actuelle, ou globale, si elle est déclarée hors fonction. 2. Les déclarations `var` sont traitées au début de la fonction (ou au début du script pour le cas global). -======= -1. `var` variables have no block scope, their visibility is scoped to current function, or global, if declared outside function. -2. `var` declarations are processed at function start (script start for globals). ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 Il y a une autre différence mineure associée à l'objet global, mais nous traiterons ce point dans le prochain chapitre. From 171d7cbb6eb2391c9159c9d51da64a6d1e88bd2c Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 05:04:22 +0100 Subject: [PATCH 11/30] Conflicts fixed on "Global object" page in french language --- .../05-global-object/article.md | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/1-js/06-advanced-functions/05-global-object/article.md b/1-js/06-advanced-functions/05-global-object/article.md index f9701de06..c1629fc21 100644 --- a/1-js/06-advanced-functions/05-global-object/article.md +++ b/1-js/06-advanced-functions/05-global-object/article.md @@ -5,11 +5,7 @@ L'objet global fournit des variables et des fonctions qui sont disponibles parto Dans un navigateur, c'est appelé `window`, pour Node.js c'est `global`, et pour les autres environnements, il peut porter un autre nom. -<<<<<<< HEAD Récemment, `globalThis` a été ajouté au langage comme un nom standardisé pour l'objet global et devrait être supporté à travers tous les environnements. Il est pris en charge dans tous les principaux navigateurs. -======= -Recently, `globalThis` was added to the language, as a standardized name for a global object, that should be supported across all environments. It's supported in all major browsers. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 Nous allons utiliser `window` ici, en supposant que notre environnement est un navigateur. Si votre script peut s'exécuter dans d'autres environnements, il est préférable d'utiliser `globalThis` à la place. @@ -29,13 +25,9 @@ var gVar = 5; alert(window.gVar); // 5 (var est devenue une propriété de l'objet global) ``` -<<<<<<< HEAD -S'il vous plaît ne comptez pas sur cela! Ce comportement existe pour des raisons de compatibilité. Les scripts modernes utilisent les [modules JavaScript](info:modules) où une telle chose ne se produit pas. -======= -The same effect have function declarations (statements with `function` keyword in the main code flow, not function expressions). +Le même effet a des déclarations de fonction (instructions avec le mot-clé `function` dans le flux de code principal, pas des expressions de fonction). -Please don't rely on that! This behavior exists for compatibility reasons. Modern scripts use [JavaScript modules](info:modules) where such thing doesn't happen. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Ne comptez pas là-dessus! Ce comportement existe pour des raisons de compatibilité. Les scripts modernes utilisent les [modules JavaScript](info:modules) où une telle chose ne se produit pas. Si nous utilisions `let` la place, une telle chose ne se produirait pas : From 3922962f9033ba4c70e1020222ba5bac3d67f6d8 Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 05:08:52 +0100 Subject: [PATCH 12/30] Conflict fixed on "Function object, NFE" page in french language --- 1-js/06-advanced-functions/06-function-object/article.md | 5 ----- 1 file changed, 5 deletions(-) diff --git a/1-js/06-advanced-functions/06-function-object/article.md b/1-js/06-advanced-functions/06-function-object/article.md index 897d6338c..4034321f7 100644 --- a/1-js/06-advanced-functions/06-function-object/article.md +++ b/1-js/06-advanced-functions/06-function-object/article.md @@ -345,11 +345,6 @@ Ici nous avons couvert leurs propriétés: Si la fonction est déclarée en tant qu'expression de fonction (et non dans le flux du code principal) et qu'elle porte `name`, elle est appelée expression de fonction nommée. Le nom peut être utilisé à l'intérieur pour se référencer, pour des appels récursifs ou autres. -<<<<<<< HEAD -De plus, les fonctions peuvent avoir des propriétés supplémentaires. De nombreuses bibliothèques JavaScript bien connues font bon usage de cette fonctionnalité. -======= -They create a "main" function and attach many other "helper" functions to it. For instance, the [jQuery](https://jquery.com) library creates a function named `$`. The [lodash](https://lodash.com) library creates a function `_`, and then adds `_.clone`, `_.keyBy` and other properties to it (see the [docs](https://lodash.com/docs) when you want to learn more about them). Actually, they do it to lessen their pollution of the global space, so that a single library gives only one global variable. That reduces the possibility of naming conflicts. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 Ils créent une fonction "principale" et y attachent de nombreuses autres fonctions "d'assistance". Par exemple, la bibliothèque [jquery](https://jquery.com) crée une fonction nommée `$`. La bibliothèque [lodash](https://lodash.com) crée une fonction `_`. Et ajoute ensuite `_.clone`,` _.keyBy` et d'autres propriétés (voir la [doc](https://lodash.com/docs) lorsque vous souhaitez en savoir plus à leur sujet). En fait, elles le font pour réduire leur pollution de l'espace global, de sorte qu'une seule bibliothèque ne donne qu'une seule variable globale. Cela réduit la possibilité de conflits de noms. From 6b508fbd44a1e29883047d71200ecbb817b453ba Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 05:15:14 +0100 Subject: [PATCH 13/30] Conflicts fixed on "The "new Function" syntax" page in french language --- 1-js/06-advanced-functions/07-new-function/article.md | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/1-js/06-advanced-functions/07-new-function/article.md b/1-js/06-advanced-functions/07-new-function/article.md index d8159e143..d9eabca37 100644 --- a/1-js/06-advanced-functions/07-new-function/article.md +++ b/1-js/06-advanced-functions/07-new-function/article.md @@ -92,11 +92,7 @@ Et si il pouvait accéder aux variables externes? Le problème est qu'avant la publication de JavaScript en production, JavaScript est compressé à l'aide d'un *minifier*, un programme spécial qui rétrécit le code en supprimant les commentaires, espaces supplémentaires et, plus particuliarement, renomme les variables locales pour quelles soient plus courtes. -<<<<<<< HEAD -Par exemple, si une fonction a `let userName`, *minifier* la remplace par `let a` (ou une autre lettre si celle-ci est deja prise), et le fait partout. C’est généralement une chose sûre à faire, car la variable est locale, rien en dehors de la fonction ne peut y accéder. Et à l'intérieur de la fonction, *minifier* remplace chaque mention. Les minifiers sont intelligents, ils analysent la structure du code pour ne rien casser. Ils ne sont pas juste une simple fonction de trouvaille et remplacement. -======= -For instance, if a function has `let userName`, minifier replaces it with `let a` (or another letter if this one is occupied), and does it everywhere. That's usually a safe thing to do, because the variable is local, nothing outside the function can access it. And inside the function, minifier replaces every mention of it. Minifiers are smart, they analyze the code structure, so they don't break anything. They're not just a dumb find-and-replace. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Par exemple, si une fonction a `let userName`, le minifier la remplace par `let a` (ou une autre lettre si celle-ci est deja prise), et le fait partout. C’est généralement une chose sûre à faire, car la variable est locale, rien en dehors de la fonction ne peut y accéder. Et à l'intérieur de la fonction, le minifier remplace chaque mention. Les minifiers sont intelligents, ils analysent la structure du code pour ne rien casser. Ils ne sont pas juste une simple fonction de trouvaille et remplacement. Donc, si `new Function` avait accès aux variables externes, il serait impossible de trouver le nom d'utilisateur `userName` renommé. From 79bd25824f90648b31906e0bdace33120e96395c Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 05:20:28 +0100 Subject: [PATCH 14/30] Conflicts fixed on "Scheduling: setTimeout and setInterval" page in french language --- .../08-settimeout-setinterval/article.md | 20 ++----------------- 1 file changed, 2 insertions(+), 18 deletions(-) diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/article.md b/1-js/06-advanced-functions/08-settimeout-setinterval/article.md index bad0aaa87..6101d7e55 100644 --- a/1-js/06-advanced-functions/08-settimeout-setinterval/article.md +++ b/1-js/06-advanced-functions/08-settimeout-setinterval/article.md @@ -128,11 +128,7 @@ setTimeout(() => { clearInterval(timerId); alert('stop'); }, 5000); ```smart header="Le temps continue de s'écouler pendant que `alert` est affiché" Dans la majorité des navigateurs, dont Chrome et Firefox, le timer interne continue à s'incrémenter pendant qu'un message est affiché (via `alert`, `confirm` ou `prompt`). -<<<<<<< HEAD -Donc, si vous exécutez le code ci-dessus et ne fermez pas la fenêtre `alert` pendant un certain temps, alors, dans la prochaine` alert`, s'affichera immédiatement au fur et à mesure que vous le ferez. L'intervalle réel entre les alertes sera inférieur à 2 secondes. -======= -So if you run the code above and don't dismiss the `alert` window for some time, then the next `alert` will be shown immediately as you do it. The actual interval between alerts will be shorter than 2 seconds. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Donc, si vous exécutez le code ci-dessus et que vous ne fermez pas la fenêtre `alert` pendant un certain temps, la prochaine `alert` sera affichée immédiatement lorsque vous le faites. L'intervalle réel entre les alertes sera inférieur à 2 secondes. ``` ## setTimeout imbriqué @@ -285,28 +281,16 @@ Cette même limitation s'applique si on utilise `setInterval` au lieu de `setTim Cette limitation est l'héritage d'un lointain passé et beaucoup de scripts se basent dessus, d'où la nécessité de cette limitation pour des raisons historiques. -<<<<<<< HEAD Pour le JavaScript côté serveur, cette limitation n'existe pas, et il existe d'autres façon de planifier immédiatement des tâches asynchrones, notamment [setImmediate](https://nodejs.org/api/timers.html) pour Node.js. Il faut donc garder à l'esprit que ce nota bene est spécifique aux navigateurs web. -======= -For server-side JavaScript, that limitation does not exist, and there exist other ways to schedule an immediate asynchronous job, like [setImmediate](https://nodejs.org/api/timers.html#timers_setimmediate_callback_args) for Node.js. So this note is browser-specific. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 ```` ## Résumé -<<<<<<< HEAD -- Les méthodes `setInterval(func, delay, ...args)` et `setTimeout(func, delay, ...args)` permettent d'exécuter `func` respectivement périodiquement et une seule fois après `delay` millisecondes. +- Les méthodes `setInterval(func, delay, ...args)` et `setTimeout(func, delay, ...args)` permettent d'exécuter `func` respectivement une seul fois/périodiquement après `delay` millisecondes. - Pour annuler l'exécution, nous devons appeler `clearInterval/clearTimeout` avec la valeur renvoyée par `setInterval/setTimeout`. - Les appels de `setTimeout` imbriqués sont une alternative plus flexible à `setInterval`, ils permettent de configurer le temps *entre* les exécution plus précisément. - L'ordonnancement à délai nul avec `setTimeout(func, 0)` (le même que `setTimeout(func)`) permet de planifier l'exécution "dès que possible, mais seulement une fois que le bloc de code courant a été exécuté". - Le navigateur limite le délai minimal pour cinq appels imbriqués ou plus de `setTimeout` ou pour` setInterval` (après le 5ème appel) à 4 ms. C'est pour des raisons historiques. -======= -- Methods `setTimeout(func, delay, ...args)` and `setInterval(func, delay, ...args)` allow us to run the `func` once/regularly after `delay` milliseconds. -- To cancel the execution, we should call `clearTimeout/clearInterval` with the value returned by `setTimeout/setInterval`. -- Nested `setTimeout` calls are a more flexible alternative to `setInterval`, allowing us to set the time *between* executions more precisely. -- Zero delay scheduling with `setTimeout(func, 0)` (the same as `setTimeout(func)`) is used to schedule the call "as soon as possible, but after the current script is complete". -- The browser limits the minimal delay for five or more nested calls of `setTimeout` or for `setInterval` (after 5th call) to 4ms. That's for historical reasons. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 Veuillez noter que toutes les méthodes de planification ne garantissent pas le délai exact. From 74ca3dbbe9cf9a6b3df26d8e9ec24df69688a956 Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 05:32:07 +0100 Subject: [PATCH 15/30] Conflicts fixed on "Prototypal inheritance" page in french language --- .../01-prototype-inheritance/article.md | 44 +++++-------------- 1 file changed, 10 insertions(+), 34 deletions(-) diff --git a/1-js/08-prototypes/01-prototype-inheritance/article.md b/1-js/08-prototypes/01-prototype-inheritance/article.md index b905966d2..9e5085a9a 100644 --- a/1-js/08-prototypes/01-prototype-inheritance/article.md +++ b/1-js/08-prototypes/01-prototype-inheritance/article.md @@ -12,11 +12,7 @@ En JavaScript, les objets ont une propriété cachée spéciale `[[Prototype]]` ![prototype](object-prototype-empty.svg) -<<<<<<< HEAD -Le prototype est un peu "magique". Lorsque nous voulons lire une propriété de `object`, et qu'elle en manque, JavaScript la prend automatiquement à partir du prototype. En programmation, cela s'appelle "l'héritage prototypal". De nombreuses fonctionnalités et techniques de programmation intéressantes sont basées sur elle. -======= -When we read a property from `object`, and it's missing, JavaScript automatically takes it from the prototype. In programming, such thing is called "prototypal inheritance". And soon we'll study many examples of such inheritance, as well as cooler language features built upon it. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Lorsque nous lisons une propriété depuis `object`, et qu'elle est manquante, JavaScript la prend automatiquement du prototype. En programmation, une telle chose est appelée "héritage prototypal". Et bientôt, nous étudierons de nombreux exemples d'un tel héritage, ainsi que des fonctionnalités de langage plus cool qui en découlent. La propriété `[[Prototype]]` est interne et cachée, mais il y a plusieurs façons de la définir. @@ -35,19 +31,7 @@ rabbit.__proto__ = animal; // sets rabbit.[[Prototype]] = animal */!* ``` -<<<<<<< HEAD -```smart header="`__proto__` est un accesseur/mutateur historique pour `[[Prototype]]`" -Veuillez noter que `__proto__` n'est *pas le même* que `[[Prototype]]`. C'est un accesseur/mutateur pour cela. - -Il existe pour des raisons historiques. Dans le langage moderne, il est remplacé par les fonctions `Object.getPrototypeOf/Object.setPrototypeOf` qui obtiennent/mute également le prototype. Nous étudierons les raisons pour cela et ces fonctions plus tard. - -Selon la spécification, `__proto__` ne doit être pris en charge que par les navigateurs. Cependant, tous les environnements, y compris côté serveur, le prennent en charge. Pour l'instant, comme la notation `__proto__` est un peu plus intuitive, nous l'utilisons dans les exemples. -``` - Si nous recherchons une propriété dans `rabbit`, et qu'elle en manque, JavaScript la prend automatiquement à partir de `animal`. -======= -Now if we read a property from `rabbit`, and it's missing, JavaScript will automatically take it from `animal`. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 Par exemple: @@ -138,37 +122,29 @@ alert(longEar.jumps); // true (de rabbit) ![](proto-animal-rabbit-chain.svg) -<<<<<<< HEAD -Il n'y a que deux limitations : -======= -Now if we read something from `longEar`, and it's missing, JavaScript will look for it in `rabbit`, and then in `animal`. +Maintenant, si nous lisons quelque chose de `longEar`, et qu'il est manquant, JavaScript le recherchera dans `rabbit`, puis dans `animal`. -There are only two limitations: ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Il n'y a que deux limitations : 1. Les références ne peuvent pas tourner en rond. JavaScript va générer une erreur si nous essayons d'assigner `__proto__` dans un cercle. 2. La valeur de `__proto__` peut être un objet ou `null`. Les autres types sont ignorés. Cela peut aussi être évident, mais quand même: il ne peut y avoir qu'un seul `[[Prototype]]`. Un objet ne peut pas hériter de deux autres. -<<<<<<< HEAD -## L'écriture n'utilise pas de prototype -======= -```smart header="`__proto__` is a historical getter/setter for `[[Prototype]]`" -It's a common mistake of novice developers not to know the difference between these two. +```smart header="`__proto__` est un getter/setter historique pour [[Prototype]]`" +C'est une erreur courante des développeurs novices de ne pas connaître la différence entre les deux. -Please note that `__proto__` is *not the same* as the internal `[[Prototype]]` property. It's a getter/setter for `[[Prototype]]`. Later we'll see situations where it matters, for now let's just keep it in mind, as we build our understanding of JavaScript language. +Veuillez noter que `__proto__` n'est *pas la même* que la propriété interne `[[Prototype]]`. C'est un getter/setter pour `[[Prototype]]`. Plus tard, nous verrons des situations où cela compte, pour l'instant gardons cela à l'esprit, alors que nous construisons notre compréhension du langage JavaScript. -The `__proto__` property is a bit outdated. It exists for historical reasons, modern JavaScript suggests that we should use `Object.getPrototypeOf/Object.setPrototypeOf` functions instead that get/set the prototype. We'll also cover these functions later. +La propriété `__proto__` est un peu obsolète. Il existe pour des raisons historiques, le JavaScript moderne suggère que nous devrions utiliser les fonctions `Object.getPrototypeOf/Object.setPrototypeOf` à la place pour obtenir/définir le prototype. Nous aborderons également ces fonctions plus tard. -By the specification, `__proto__` must only be supported by browsers. In fact though, all environments including server-side support `__proto__`, so we're quite safe using it. +Selon la spécification, `__proto__` ne doit être pris en charge que par les navigateurs. En fait cependant, tous les environnements, y compris côté serveur, prennent en charge `__proto__`, donc nous sommes assez sûrs de l'utiliser. -As the `__proto__` notation is a bit more intuitively obvious, we use it in the examples. +Comme la notation `__proto__` est un peu plus évidente, nous l'utilisons dans les exemples. ``` -## Writing doesn't use prototype ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +## L'écriture n'utilise pas de prototype Le prototype n'est utilisé que pour la lecture des propriétés. From f631b61cb74063b65eec4205552a85e7de32306d Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 05:40:48 +0100 Subject: [PATCH 16/30] Conflicts fixed on "Prototype methods, objects without __proto__" page in french language --- 1-js/08-prototypes/04-prototype-methods/article.md | 6 ------ 1 file changed, 6 deletions(-) diff --git a/1-js/08-prototypes/04-prototype-methods/article.md b/1-js/08-prototypes/04-prototype-methods/article.md index c5ccd88d4..9b3032c27 100644 --- a/1-js/08-prototypes/04-prototype-methods/article.md +++ b/1-js/08-prototypes/04-prototype-methods/article.md @@ -175,15 +175,9 @@ alert(Object.keys(chineseDictionary)); // hello,bye Les méthodes modernes pour configurer et accéder directement au prototype sont les suivantes : -<<<<<<< HEAD - [Object.create(proto, [descriptors])](mdn:js/Object/create) -- crée un objet vide avec un `proto` donné en tant que `[[Prototype]]` (peut être `null`) et des descripteurs de propriété facultatifs. - [Object.getPrototypeOf(obj)](mdn:js/Object.getPrototypeOf) -- retourne le `[[Prototype]]` de `obj` (identique au getter `__proto__`). - [Object.setPrototypeOf(obj, proto)](mdn:js/Object.setPrototypeOf) -- configure le `[[Prototype]]` de `obj` à `proto` (identique au setter `__proto__`). -======= -- [Object.create(proto, [descriptors])](mdn:js/Object/create) -- creates an empty object with a given `proto` as `[[Prototype]]` (can be `null`) and optional property descriptors. -- [Object.getPrototypeOf(obj)](mdn:js/Object/getPrototypeOf) -- returns the `[[Prototype]]` of `obj` (same as `__proto__` getter). -- [Object.setPrototypeOf(obj, proto)](mdn:js/Object/setPrototypeOf) -- sets the `[[Prototype]]` of `obj` to `proto` (same as `__proto__` setter). ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 Le getter/setter `__proto__` intégré est dangereux si nous souhaitons placer les clés générées par l'utilisateur dans un objet. Tout simplement parce qu'un utilisateur peut entrer `"__proto __"` comme clé, et il y aura une erreur, avec des conséquences légères, espérons-le, mais généralement imprévisibles. From a7a476680fb8e3faa2ad8904f7999308c74a43b0 Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 05:42:41 +0100 Subject: [PATCH 17/30] Conflict fixed on "Class basic syntax" task page in french language --- 1-js/09-classes/01-class/1-rewrite-to-class/task.md | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/1-js/09-classes/01-class/1-rewrite-to-class/task.md b/1-js/09-classes/01-class/1-rewrite-to-class/task.md index dcbf6c762..efa24ab41 100644 --- a/1-js/09-classes/01-class/1-rewrite-to-class/task.md +++ b/1-js/09-classes/01-class/1-rewrite-to-class/task.md @@ -5,10 +5,6 @@ importance: 5 # Réécrire en classe -<<<<<<< HEAD -La classe `Clock` est écrite en style fonctionnelle. Réécrivez la en syntaxe de "classe". -======= -The `Clock` class (see the sandbox) is written in functional style. Rewrite it in the "class" syntax. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +La classe `Clock` (voir la sandbox) est écrite en style fonctionnelle. Réécrivez la en syntaxe de "classe". P.S. La montre doit tictaquer dans la console, ouvrez la pour la voir. From 38f7cddf03b074e3d7a2469939d9e4aeeacdbe95 Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 05:45:13 +0100 Subject: [PATCH 18/30] Conflict fixed on "Class checking: 'instanceof'" page in french language --- 1-js/09-classes/06-instanceof/article.md | 4 ---- 1 file changed, 4 deletions(-) diff --git a/1-js/09-classes/06-instanceof/article.md b/1-js/09-classes/06-instanceof/article.md index 285d8748b..b6cdd8c1f 100644 --- a/1-js/09-classes/06-instanceof/article.md +++ b/1-js/09-classes/06-instanceof/article.md @@ -2,11 +2,7 @@ L'opérateur `instanceof` permet de vérifier si un objet appartient à une certaine classe. Il prend également en compte l'héritage. -<<<<<<< HEAD Une telle vérification peut être nécessaire dans de nombreux cas. Nous l'utilisons ici pour construire une fonction *polymorphique*, celle qui traite les arguments différemment en fonction de leur type. -======= -Such a check may be necessary in many cases. For example, it can be used for building a *polymorphic* function, the one that treats arguments differently depending on their type. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 ## L'opérateur instanceof [#ref-instanceof] From 72306fc3a0c7a5947f43a05624e0665e167c1677 Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 05:47:10 +0100 Subject: [PATCH 19/30] Conflict fixed on "Promises chaining" page in french language --- 1-js/11-async/03-promise-chaining/article.md | 4 ---- 1 file changed, 4 deletions(-) diff --git a/1-js/11-async/03-promise-chaining/article.md b/1-js/11-async/03-promise-chaining/article.md index 8dd1e7f44..c4b98150b 100644 --- a/1-js/11-async/03-promise-chaining/article.md +++ b/1-js/11-async/03-promise-chaining/article.md @@ -265,11 +265,7 @@ fetch('/article/promise-chaining/user.json') Maintenant faisons quelque chose avec l'utilisateur chargé. -<<<<<<< HEAD Par exemple, nous pouvons faire une demande supplémentaire à GitHub, charger le profil de l'utilisateur et afficher l'avatar: -======= -For instance, we can make one more request to GitHub, load the user profile and show the avatar: ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 ```js run // Faire une demande pour user.json From 1c08e1e7020de9fe6a3e04851d59d1e25649e4b9 Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 06:05:51 +0100 Subject: [PATCH 20/30] Conflict fixed on Promisification page in french language --- 1-js/11-async/06-promisify/article.md | 72 +++++++-------------------- 1 file changed, 18 insertions(+), 54 deletions(-) diff --git a/1-js/11-async/06-promisify/article.md b/1-js/11-async/06-promisify/article.md index 4254f1a67..851c6fb77 100644 --- a/1-js/11-async/06-promisify/article.md +++ b/1-js/11-async/06-promisify/article.md @@ -4,13 +4,9 @@ De telles transformations sont souvent nécessaires dans la vie réelle, car de nombreuses fonctions et bibliothèques sont basées sur des callback. Mais les promesses sont plus pratiques. Il est donc logique de les transformer. -<<<<<<< HEAD -Par exemple, nous avons `loadScript(src, callback)` du chapitre . -======= -For better understanding, let's see an example. +Pour une meilleure compréhension, voyons un exemple. -For instance, we have `loadScript(src, callback)` from the chapter . ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Par exemple, nous avons `loadScript(src, callback)` du chapitre . ```js run function loadScript(src, callback) { @@ -27,17 +23,13 @@ function loadScript(src, callback) { // loadScript('path/script.js', (err, script) => {...}) ``` -<<<<<<< HEAD -Transformons-le. La nouvelle fonction `loadScriptPromise(src)` fera de même, mais acceptera seulement `src` (pas de `callback`) et renverra une promesse. -======= -The function loads a script with the given `src`, and then calls `callback(err)` in case of an error, or `callback(null, script)` in case of successful loading. That's a widespread agreement for using callbacks, we saw it before. +La fonction charge un script avec le `src` donné, puis appelle `callback(err)` en cas d'erreur, ou `callback (null, script) `en cas de chargement réussi. C'est un accord répandu pour l'utilisation des rappels, nous l'avons vu auparavant. -Let's promisify it. +Promisifions le. -We'll make a new function `loadScriptPromise(src)`, that does the same (loads the script), but returns a promise instead of using callbacks. +Nous allons créer une nouvelle fonction `loadScriptPromise(src)`, qui fait la même chose (charge le script), mais retourne une promesse au lieu d'utiliser des rappels. -In other words, we pass it only `src` (no `callback`) and get a promise in return, that resolves with `script` when the load is successful, and rejects with the error otherwise. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +En d'autres termes, nous le transmettons uniquement `src` (pas de `callback`) et obtenons une promesse en retour, qui se résout avec `script` lorsque le chargement est réussi, et sinon rejette avec l'erreur. Here it is: ```js @@ -54,35 +46,19 @@ let loadScriptPromise = function(src) { // loadScriptPromise('path/script.js').then(...) ``` -<<<<<<< HEAD -Maintenant, `loadScriptPromise` s'intègre bien dans du code basé sur des promesses. - -Comme nous pouvons le constater, elle délègue tout le travail au `loadScript` d'origine, en fournissant son propre rappel qui se traduit par la promesse de "résoudre/rejeter". - -En pratique, nous aurons probablement besoin de promettre de nombreuses fonctions. Il est donc logique d'utiliser une fonction assistante. Nous l'appellerons `promisify(f)` : elle accepte une fonction à transformer `f` et renvoie une fonction wrapper. - -Ce wrapper fait la même chose que dans le code ci-dessus: renvoie une promesse et passe l'appel au `f` d'origine, en suivant le résultat dans un rappel personnalisé: - -```js -function promisify(f) { - return function (...args) { // renvoie une fonction wrapper - return new Promise((resolve, reject) => { - function callback(err, result) { // notre rappel personnalisé pour f -======= -As we can see, the new function is a wrapper around the original `loadScript` function. It calls it providing its own callback that translates to promise `resolve/reject`. +Comme nous pouvons le voir, la nouvelle fonction est un wrapper autour de la fonction originale `loadScript`. Il l'appelle en fournissant son propre rappel qui se traduit par la promesse de `resolve/reject`. -Now `loadScriptPromise` fits well in promise-based code. If we like promises more than callbacks (and soon we'll see more reasons for that), then we will use it instead. +Dorénavant `loadScriptPromise` s'intègre bien dans le code basé sur la promesse. Si nous aimons les promesses plus que les rappels (et bientôt nous verrons plus de raisons à cela), alors nous les utiliserons à la place. -In practice we may need to promisify more than one function, so it makes sense to use a helper. +Dans la pratique, nous pouvons avoir besoin de promettre plus d'une fonction, il est donc logique d'utiliser un assistant. -We'll call it `promisify(f)`: it accepts a to-promisify function `f` and returns a wrapper function. +Nous l'appellerons `promisify (f)` : il accepte une fonction à promettre `f` et renvoie une fonction wrapper. ```js function promisify(f) { return function (...args) { // return a wrapper-function (*) return new Promise((resolve, reject) => { function callback(err, result) { // our custom callback for f (**) ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 if (err) { reject(err); } else { @@ -102,26 +78,18 @@ let loadScriptPromise = promisify(loadScript); loadScriptPromise(...).then(...); ``` -<<<<<<< HEAD -Nous supposons ici que la fonction d'origine attend un rappel avec deux arguments `(err, result)`. C'est ce que nous rencontrons le plus souvent. Ensuite, notre rappel personnalisé est exactement au bon format et `promisify` convient parfaitement à un tel cas. -======= -The code may look a bit complex, but it's essentially the same that we wrote above, while promisifying `loadScript` function. +Le code peut sembler un peu complexe, mais c'est essentiellement le même que celui que nous avons écrit ci-dessus, tout en promettant la fonction `loadScript`. -A call to `promisify(f)` returns a wrapper around `f` `(*)`. That wrapper returns a promise and forwards the call to the original `f`, tracking the result in the custom callback `(**)`. +Un appel à `promisify(f)` retourne un wrapper autour de `f` `(*)`. Ce wrapper renvoie une promesse et transmet l'appel au `f` d'origine, en suivant le résultat dans le rappel personnalisé `(**)`. -Here, `promisify` assumes that the original function expects a callback with exactly two arguments `(err, result)`. That's what we encounter most often. Then our custom callback is in exactly the right format, and `promisify` works great for such a case. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Ici, `promisify` suppose que la fonction d'origine attend un rappel avec exactement deux arguments `(err, result) `. C'est ce que nous rencontrons le plus souvent. Ensuite, notre rappel personnalisé est exactement dans le bon format, et `promisify` fonctionne très bien dans un tel cas. Mais que se passe-t-il si le `f` original attend un rappel avec plus d'arguments `callback(err, res1, res2, ...)`? -<<<<<<< HEAD -Voici une version plus avancée de `promisify`: si elle est appelée par `promisify(f, true)`, le résultat de la promesse sera un tableau de résultats de rappel `[res1, res2, ...]`: -======= -We can improve our helper. Let's make a more advanced version of `promisify`. +Nous pouvons améliorer notre helper. Faisons une version plus avancée de `promisify`. -- When called as `promisify(f)` it should work similar to the version above. -- When called as `promisify(f, true)`, it should return the promise that resolves with the array of callback results. That's exactly for callbacks with many arguments. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +- Lorsqu'il est appelé en tant que `promisify(f)`, il devrait fonctionner de la même manière que la version ci-dessus. +- Lorsqu'il est appelé en tant que `promisify(f, true)`, il doit retourner la promesse qui se résout avec le tableau des résultats de rappel. C'est exactement pour les rappels avec de nombreux arguments. ```js // promisify(f, true) pour obtenir un tableau de résultats @@ -149,13 +117,9 @@ f = promisify(f, true); f(...).then(arrayOfResults => ..., err => ...); ``` -<<<<<<< HEAD -Pour des formats de rappel plus exotiques, comme ceux sans `err` : `callback(result)`, nous pouvons transformer de telles fonctions manuellement, sans utiliser la fonction assistante. -======= -As you can see it's essentially the same as above, but `resolve` is called with only one or all arguments depending on whether `manyArgs` is truthy. +Comme vous pouvez le voir, c'est essentiellement la même chose que ci-dessus, mais `resolve` est appelé avec un seul ou tous les arguments selon que `manyArgs` est vrai. -For more exotic callback formats, like those without `err` at all: `callback(result)`, we can promisify such functions manually without using the helper. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Pour des formats de rappel plus exotiques, comme ceux sans `err` : `callback(result)`, nous pouvons promettre de telles fonctions manuellement sans utiliser l'assistant. Il existe également des modules avec des fonctions de promisification un peu plus flexibles, e.g. [es6-promisify](https://github.com/digitaldesignlabs/es6-promisify). Dans Node.js, il existe une fonction intégrée `util.promisify` pour cela. From e019e29a9f0e753b22a829114a20f68c250b1614 Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 06:12:04 +0100 Subject: [PATCH 21/30] Conflict fixed on "Async iteration and generators" page in french language --- .../2-async-iterators-generators/article.md | 18 +++--------------- 1 file changed, 3 insertions(+), 15 deletions(-) diff --git a/1-js/12-generators-iterators/2-async-iterators-generators/article.md b/1-js/12-generators-iterators/2-async-iterators-generators/article.md index 283626871..2aa0b7802 100644 --- a/1-js/12-generators-iterators/2-async-iterators-generators/article.md +++ b/1-js/12-generators-iterators/2-async-iterators-generators/article.md @@ -301,11 +301,7 @@ Désormais, les valeurs sont accompagnées d'un délai de 1 seconde entre elles. ```smart Techniquement, nous pouvons ajouter à la fois `Symbol.iterator` et `Symbol.asyncIterator` à l'objet, donc il est à la fois itérable de manière synchrone (`for..of`) et asynchrone (`for await..of`). -<<<<<<< HEAD En pratique cependant, ce serait une chose étrange à faire. -======= -In practice though, that would be a weird thing to do. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 ``` ## Exemple réel : données paginées @@ -363,21 +359,13 @@ Plus d'explications sur son fonctionnement : 1. Nous utilisons la méthode du navigateur [fetch](info:fetch) pour télécharger les commits. -<<<<<<< HEAD - L'URL initiale est `https://api.github.com/repos//commits`, et la page suivante sera dans l'en-tête `Link` de la réponse. - La méthode `fetch` nous permet de fournir une autorisation et d'autres en-têtes si nécessaire - ici GitHub nécessite `User-Agent`. 2. Les commits sont renvoyés au format JSON. -3. Nous devrions obtenir l'URL de la page suivante à partir de l'en-tête `Link` de la réponse. Il a un format spécial, nous utilisons donc une expression régulière pour cela. - - L'URL de la page suivante peut ressembler à `https://api.github.com/repositories/93253246/commits?page=2`. Il est généré par GitHub lui-même. +3. Nous devrions obtenir l'URL de la page suivante à partir de l'en-tête `Link` de la réponse. Il a un format spécial, nous utilisons donc une [expression régulière](info:regular-expressions)). +pour cela. + - L'URL de la page suivante peut ressembler à `https://api.github.com/repositories/93253246/commits?page=2`. Elle est générée par GitHub lui-même. 4. Ensuite, nous donnons les commits reçus un par un, et quand ils se terminent, la prochaine itération `while(url)` se déclenchera, faisant une demande de plus. -======= - - The initial URL is `https://api.github.com/repos//commits`, and the next page will be in the `Link` header of the response. - - The `fetch` method allows us to supply authorization and other headers if needed -- here GitHub requires `User-Agent`. -2. The commits are returned in JSON format. -3. We should get the next page URL from the `Link` header of the response. It has a special format, so we use a regular expression for that (we will lern this feature in [Regular expressions](info:regular-expressions)). - - The next page URL may look like `https://api.github.com/repositories/93253246/commits?page=2`. It's generated by GitHub itself. -4. Then we yield the received commits one by one, and when they finish, the next `while(url)` iteration will trigger, making one more request. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 Un exemple d'utilisation (montrant les auteurs de chaque commit en console) : From 49a8c050e675b3fd8f910ad6bf4d9a1d0b8b03ca Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 06:13:41 +0100 Subject: [PATCH 22/30] Conflict fixed on "Modules, introduction" page in french language --- 1-js/13-modules/01-modules-intro/article.md | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/1-js/13-modules/01-modules-intro/article.md b/1-js/13-modules/01-modules-intro/article.md index 7a26991be..aa71e8514 100644 --- a/1-js/13-modules/01-modules-intro/article.md +++ b/1-js/13-modules/01-modules-intro/article.md @@ -260,11 +260,7 @@ Comparez au script habituel ci-dessous: From d5fbccc26d0520ec3aaa371ce97482e2429781eb Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 06:20:18 +0100 Subject: [PATCH 23/30] Conflict fixed on "Export and Import" page in french language --- 1-js/13-modules/02-import-export/article.md | 26 ++++----------------- 1 file changed, 5 insertions(+), 21 deletions(-) diff --git a/1-js/13-modules/02-import-export/article.md b/1-js/13-modules/02-import-export/article.md index f9e666404..4c03868fb 100644 --- a/1-js/13-modules/02-import-export/article.md +++ b/1-js/13-modules/02-import-export/article.md @@ -320,11 +320,7 @@ export {default as User} from './user.js'; // réexportez default Pourquoi cela peut être nécessaire ? Voyons un cas d'utilisation pratique. -<<<<<<< HEAD -Imaginons, nous écrivons un "package" : un dossier contenant de nombreux modules, avec certaines des fonctionnalités exportées à l'extérieur (des outils tels que NPM permettent de publier et de distribuer de tels packages), et de nombreux modules ne sont que des "aides" pour une utilisation interne dans d'autres modules. -======= -Imagine, we're writing a "package": a folder with a lot of modules, with some of the functionality exported outside (tools like NPM allow us to publish and distribute such packages, but we don't have to use them), and many modules are just "helpers", for internal use in other package modules. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Imaginez, nous écrivons un "package": un dossier avec beaucoup de modules, avec une partie des fonctionnalités exportées à l'extérieur (des outils comme NPM nous permettent de publier et de distribuer de tels packages, mais nous n'avons pas à les utiliser), et de nombreux modules ne sont que des "helpers", destinés à une utilisation interne dans d'autres modules de package. La structure de fichier pourrait être comme ceci : ``` @@ -381,11 +377,7 @@ export {default as User} from './user.js'; L'exportation par défaut nécessite un traitement séparé lors de la réexportation. -<<<<<<< HEAD -Disons que nous avons `user.js` et que nous aimerions réexporter la classe `User` à partir de celle-ci: -======= -Let's say we have `user.js` with the `export default class User` and would like to re-export it: ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Supposons que nous ayons `user.js` avec le `export default class User` et que nous souhaitons le réexporter : ```js // 📁 user.js @@ -394,13 +386,9 @@ export default class User { } ``` -<<<<<<< HEAD -1. `export User from './user.js'` çe ne fonctionnera pas... C'est une erreur de syntaxe! -======= -We can come across two problems with it: +On peut y rencontrer deux problèmes : -1. `export User from './user.js'` won't work. That would lead to a syntax error. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +1. `export User from './user.js'` çe ne fonctionnera pas... Cela conduirait à une erreur de syntaxe. Pour réexporter l'exportation par défaut, nous devrions écrire `export {default as User}`, comme dans l'exemple ci-dessus. @@ -412,11 +400,7 @@ We can come across two problems with it: export {default} from './user.js'; // réexporter l'exportation par défaut ``` -<<<<<<< HEAD -Cette bizarrerie de réexporter l'exportation par défaut est l'une des raisons pour lesquelles certains développeurs ne les aiment pas. -======= -Such oddities of re-exporting a default export are one of the reasons why some developers don't like default exports and prefer named ones. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Ces bizarreries de réexporter une exportation par défaut sont l'une des raisons pour lesquelles certains développeurs n'aiment pas les exportations par défaut et préfèrent les exportations nommées. ## Sommaire From fc39ef6cf049b0b08230ed1345797d7776c18d3c Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 06:23:58 +0100 Subject: [PATCH 24/30] =?UTF-8?q?Conflicts=20fixed=20on=20"Proxy=20and=20R?= =?UTF-8?q?eflect"=C2=A0page=20and=20task=20in=20french=20language?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- 1-js/99-js-misc/01-proxy/01-error-nonexisting/task.md | 6 +----- 1-js/99-js-misc/01-proxy/article.md | 11 +---------- 2 files changed, 2 insertions(+), 15 deletions(-) diff --git a/1-js/99-js-misc/01-proxy/01-error-nonexisting/task.md b/1-js/99-js-misc/01-proxy/01-error-nonexisting/task.md index 682031a34..cf887372b 100644 --- a/1-js/99-js-misc/01-proxy/01-error-nonexisting/task.md +++ b/1-js/99-js-misc/01-proxy/01-error-nonexisting/task.md @@ -27,10 +27,6 @@ user = wrap(user); alert(user.name); // John *!* -<<<<<<< HEAD -alert(user.age); // ReferenceError: la propriété n'existe pas "age" -======= -alert(user.age); // ReferenceError: Property doesn't exist: "age" ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +alert(user.age); // ReferenceError: la propriété n'existe pas : "age" */!* ``` diff --git a/1-js/99-js-misc/01-proxy/article.md b/1-js/99-js-misc/01-proxy/article.md index 0fada42e7..a60c76fd4 100644 --- a/1-js/99-js-misc/01-proxy/article.md +++ b/1-js/99-js-misc/01-proxy/article.md @@ -375,13 +375,8 @@ user = new Proxy(user, { } }, *!* -<<<<<<< HEAD - deleteProperty(target, prop) { // intercepter la suppression de propriété + deleteProperty(target, prop) { // pour intercepter la suppression de propriété */!* -======= - deleteProperty(target, prop) { // to intercept property deletion -*/!* ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 if (prop.startsWith('_')) { throw new Error("Access denied"); } else { @@ -442,11 +437,7 @@ user = { ``` -<<<<<<< HEAD L'appel `user.checkPassword()` obtient l'`user` proxy comme `this` (l'objet avant le point devient `this`), donc quand il essaie d'accéder à `this._password`, le piège `get` s'active (il se déclenche sur n'importe quelle propriété lue) et génère une erreur. -======= -A call to `user.checkPassword()` gets proxied `user` as `this` (the object before dot becomes `this`), so when it tries to access `this._password`, the `get` trap activates (it triggers on any property read) and throws an error. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 Nous lions donc le contexte des méthodes objet à l'objet d'origine, `target`, dans la ligne `(*)`. Ensuite, leurs futurs appels utiliseront `target` comme `this`, sans aucun piège. From 9641129dc00703ec7e8b01ff07cc56d466048386 Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 06:30:55 +0100 Subject: [PATCH 25/30] Conflicts fixed on "Reference Type" page and task in french language --- .../04-reference-type/3-why-this/solution.md | 12 ++---------- 1-js/99-js-misc/04-reference-type/article.md | 8 ++------ 2 files changed, 4 insertions(+), 16 deletions(-) diff --git a/1-js/99-js-misc/04-reference-type/3-why-this/solution.md b/1-js/99-js-misc/04-reference-type/3-why-this/solution.md index 6385481e4..68ede9b7f 100644 --- a/1-js/99-js-misc/04-reference-type/3-why-this/solution.md +++ b/1-js/99-js-misc/04-reference-type/3-why-this/solution.md @@ -5,11 +5,7 @@ Voici les explications. 2. De même, les parenthèses ne changent pas l'ordre des opérations ici, le point est le premier quand même. -<<<<<<< HEAD -3. Nous avons ici un appel plus complexe `(expression).method()`. L'appel fonctionne comme s'il était divisé en deux lignes : -======= -3. Here we have a more complex call `(expression)()`. The call works as if it were split into two lines: ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +3. Nous avons ici un appel plus complexe `(expression)()`. L'appel fonctionne comme s'il était divisé en deux lignes : ```js no-beautify f = obj.go; // calculer l'expression @@ -18,11 +14,7 @@ Voici les explications. Ici, `f()` est exécuté en tant que fonction, sans `this`. -<<<<<<< HEAD -4. La même chose que `(3)`, à gauche du point `.` nous avons une expression. -======= -4. The similar thing as `(3)`, to the left of the parentheses `()` we have an expression. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +4. La chose similaire à `(3)`, à gauche des parenthèses `()`, nous avons une expression. Pour expliquer le comportement de `(3)` et `(4)`, nous devons rappeler que les accesseurs de propriétés (points ou crochets) renvoient une valeur du type de référence. diff --git a/1-js/99-js-misc/04-reference-type/article.md b/1-js/99-js-misc/04-reference-type/article.md index 221fa782a..85447d78e 100644 --- a/1-js/99-js-misc/04-reference-type/article.md +++ b/1-js/99-js-misc/04-reference-type/article.md @@ -93,11 +93,7 @@ Le type référence est un type interne "intermédiaire", avec comme but de pass N'importe quelle autre opération d'assignement comme `hi = user.hi` rejette le type référence, prends la valeur de `user.hi` (une fonction) et la passe. Ainsi n'importe quelle opération suivante "perd" `this`. -<<<<<<< HEAD -Il en résulte que la valeur de `this` n'est passée correctement seulement lorsque la fonction est appelée directement en utilisant la notation par points `obj.method()` ou la notation par crochet `obj['method']()` (c'est la même chose). Plus tard dans ce tutoriel on apprendra plusieurs manières de régler ce problème. Par exemple avef [func.bind()](/bind#solution-2-bind). -======= -So, as the result, the value of `this` is only passed the right way if the function is called directly using a dot `obj.method()` or square brackets `obj['method']()` syntax (they do the same here). There are various ways to solve this problem such as [func.bind()](/bind#solution-2-bind). ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Il en résulte que la valeur de `this` n'est passée correctement seulement lorsque la fonction est appelée directement en utilisant la notation par points `obj.method()` ou la notation par crochet `obj['method']()` (c'est la même chose). Il existe différentes manières de résoudre ce problème comme [func.bind()](/bind#solution-2-bind). ## Résumé @@ -110,4 +106,4 @@ Cela est fait pour que l'éxécution suivante, l'appel à la méthode `()`, re Pour toutes les autres opérations, le type référence sera automatiquement la valeur de la propriété (une fonction dans notre cas). -Le fonctionnement est caché de notre vision. Cela n'a d'importance que dans certains cas, comme lorsqu'une méthode est obtenue dynamiquement de l'object en utilisant une expression. \ No newline at end of file +Le fonctionnement est caché de notre vision. Cela n'a d'importance que dans certains cas, comme lorsqu'une méthode est obtenue dynamiquement de l'object en utilisant une expression. From b006e0b02d71ed020a646a8506f5b09abb222a7f Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 06:33:19 +0100 Subject: [PATCH 26/30] Conflicts fixed on "Node properties: type, tag and contents" page in french language --- .../05-basic-dom-node-properties/article.md | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/2-ui/1-document/05-basic-dom-node-properties/article.md b/2-ui/1-document/05-basic-dom-node-properties/article.md index 24c0f79f3..3216c10f4 100644 --- a/2-ui/1-document/05-basic-dom-node-properties/article.md +++ b/2-ui/1-document/05-basic-dom-node-properties/article.md @@ -198,11 +198,7 @@ En mode XML, la casse est conservée "en l'état". De nos jours, le mode XML est ## innerHTML: les contenus -<<<<<<< HEAD La propriété [innerHTML](https://w3c.github.io/DOM-Parsing/#widl-Element-innerHTML) permet d'obtenir le HTML à l'intérieur de l'élément sous forme de chaîne de caractères. -======= -The [innerHTML](https://w3c.github.io/DOM-Parsing/#the-innerhtml-mixin) property allows to get the HTML inside the element as a string. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 Nous pouvons également le modifier. C'est donc l'un des moyens les plus puissants de modifier la page. @@ -408,13 +404,8 @@ Comparez les deux : ``` -<<<<<<< HEAD 1. La première `
` obtient le nom "en HTML" : toutes les balises deviennent des balises, nous voyons donc le nom en gras. 2. La seconde `
` obtient le nom "sous forme de texte", donc nous voyons littéralement `Winnie-the-pooh!`. -======= -1. The first `
` gets the name "as HTML": all tags become tags, so we see the bold name. -2. The second `
` gets the name "as text", so we literally see `Winnie-the-Pooh!`. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 Dans la plupart des cas, nous attendons le texte d'un utilisateur et souhaitons le traiter comme du texte. Nous ne voulons pas de HTML inattendu sur notre site. Une affectation à `textContent` fait exactement cela. @@ -422,11 +413,7 @@ Dans la plupart des cas, nous attendons le texte d'un utilisateur et souhaitons L'attribut "hidden" (caché) et la propriété DOM spécifient si l'élément est visible ou non. -<<<<<<< HEAD Nous pouvons l'utiliser dans le HTML ou l'attribuer en utilisant JavaScript, comme ceci : -======= -We can use it in HTML or assign it using JavaScript, like this: ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 ```html run height="80"
Both divs below are hidden
From 315f754a762a7c5d0f2254d726cc34be561c1b7b Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 06:35:02 +0100 Subject: [PATCH 27/30] Conflict fixed on "Attributes and properties" page in french language --- 2-ui/1-document/06-dom-attributes-and-properties/article.md | 4 ---- 1 file changed, 4 deletions(-) diff --git a/2-ui/1-document/06-dom-attributes-and-properties/article.md b/2-ui/1-document/06-dom-attributes-and-properties/article.md index 418c9fc7c..1a99cf8d1 100644 --- a/2-ui/1-document/06-dom-attributes-and-properties/article.md +++ b/2-ui/1-document/06-dom-attributes-and-properties/article.md @@ -298,11 +298,7 @@ Par exemple, ici pour la commande de l'état de l'attribut, `order-state` est ut
``` -<<<<<<< HEAD Pourquoi l'utilisation d'un attribut serait-elle préférable à des classes comme `.order-state-new`, `.order-state-pending`, `order-state-canceled` ? -======= -Why would using an attribute be preferable to having classes like `.order-state-new`, `.order-state-pending`, `.order-state-canceled`? ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 Parce qu'un attribut est plus pratique à gérer. L'état peut être changé aussi facilement que : From 6cd12d24fa54835263ea0464a161a798a654698b Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 06:36:30 +0100 Subject: [PATCH 28/30] Conflict fixed on "Event delegation" page in french language --- 2-ui/2-events/03-event-delegation/article.md | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/2-ui/2-events/03-event-delegation/article.md b/2-ui/2-events/03-event-delegation/article.md index 804220761..ce8b5edf7 100644 --- a/2-ui/2-events/03-event-delegation/article.md +++ b/2-ui/2-events/03-event-delegation/article.md @@ -5,11 +5,7 @@ La capture et le bouillonement ("bubbling") nous permettent d'implémenter l'un L'idée est que si nous avons beaucoup d'éléments traités de la même manière, au lieu d'assigner un gestionnaire à chacun d'eux -- nous mettons un seul gestionnaire sur leur ancêtre commun. -<<<<<<< HEAD -Dans le gestionnaire, nous obtenons `event.target`, voyons où l'événement s'est réellement produit et traitons le. -======= -In the handler we get `event.target` to see where the event actually happened and handle it. ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Dans le gestionnaire, nous obtenons `event.target` pour voir où l'événement s'est réellement produit et le gérer. Voyons un exemple -- le [diagramme Ba-Gua](http://en.wikipedia.org/wiki/Ba_gua) reflétant l'ancienne philosophie chinoise. From 4c557dc9f9534fa1da2f50366cc55f200a1c25d3 Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 06:37:55 +0100 Subject: [PATCH 29/30] Conflict fixed on "Fetch: Abort" page in french language --- 5-network/04-fetch-abort/article.md | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/5-network/04-fetch-abort/article.md b/5-network/04-fetch-abort/article.md index 8d30fedd1..7123d26e6 100644 --- a/5-network/04-fetch-abort/article.md +++ b/5-network/04-fetch-abort/article.md @@ -65,11 +65,7 @@ fetch(url, { La méthode `fetch` sait comment travailler avec `AbortController`. Il écoutera les événements `abort` sur `signal`. -<<<<<<< HEAD -Maintenant, pour abandonner, appelez `controller.abort()` : -======= -Now, to abort, call `controller.abort()`: ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 +Maintenant, pour abandonner, appelons `controller.abort()` : ```js controller.abort(); From 1f557d3cd12f0dd0a7f872c85984ea6680a702d1 Mon Sep 17 00:00:00 2001 From: Hachemi Date: Mon, 23 Nov 2020 06:39:57 +0100 Subject: [PATCH 30/30] Conflict fixed on "Character classes" page in french language --- .../02-regexp-character-classes/article.md | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/9-regular-expressions/02-regexp-character-classes/article.md b/9-regular-expressions/02-regexp-character-classes/article.md index 466c33a2a..0ede55354 100644 --- a/9-regular-expressions/02-regexp-character-classes/article.md +++ b/9-regular-expressions/02-regexp-character-classes/article.md @@ -120,11 +120,7 @@ alert( "CS-4".match(regexp) ); // CS-4 alert( "CS 4".match(regexp) ); // CS 4 (l'espace est aussi un caractère) ``` -<<<<<<< HEAD Veuillez noter qu'un point signifie "n'importe quel caractère", mais pas "l'absence de caractère". Il doit y avoir un caractère avec lequel le faire correspondre : -======= -Please note that a dot means "any character", but not the "absence of a character". There must be a character to match it: ->>>>>>> 99e59ba611ab11319ef9d0d66734b0bea2c3f058 ```js run alert( "CS4".match(/CS.4/) ); // null, pas de correspondance car il n'y a pas de caractère pour le point @@ -204,4 +200,4 @@ Il existe les classes de caractères suivantes : Le codage Unicode, utilisé par JavaScript pour les chaînes, fournit de nombreuses propriétés aux caractères, tels que : à quelle langue la lettre appartient (si c'est une lettre), si c'est un signe de ponctuation, etc. -Nous pouvons également faire une recherche selon leurs propriétés. Cela nécessite l'indicateur `pattern:u`, couvert dans le prochain article. \ No newline at end of file +Nous pouvons également faire une recherche selon leurs propriétés. Cela nécessite l'indicateur `pattern:u`, couvert dans le prochain article.