diff options
Diffstat (limited to 'files/fr/web/javascript/reference/errors')
77 files changed, 2489 insertions, 2448 deletions
diff --git a/files/fr/web/javascript/reference/errors/already_has_pragma/index.md b/files/fr/web/javascript/reference/errors/already_has_pragma/index.md index 506c6bc246..a9aa355462 100644 --- a/files/fr/web/javascript/reference/errors/already_has_pragma/index.md +++ b/files/fr/web/javascript/reference/errors/already_has_pragma/index.md @@ -8,35 +8,37 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Already_has_pragma original_slug: Web/JavaScript/Reference/Erreurs/Already_has_pragma --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">Warning: -fichier- is being assigned a //# sourceMappingURL, but already has one.</pre> + Warning: -fichier- is being assigned a //# sourceMappingURL, but already has one. -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>Un avertissement. L'exécution du script JavaScript n'est pas interrompue.</p> +Un avertissement. L'exécution du script JavaScript n'est pas interrompue. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Un fichier <em>source map</em> a été défini plus d'une fois pour un fichier source JavaScript donné.</p> +Un fichier _source map_ a été défini plus d'une fois pour un fichier source JavaScript donné. -<p>La plupart du temps, les fichiers sources des scripts JavaScript sont fusionnés et minifiés afin que les transferts de fichiers du serveur vers le navigateur soient plus efficaces. Grâce <a href="http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/">aux fichiers de correspondance des sources (<em>source maps</em>)</a>, il est possible d'indiquer au débogueur le code original correspondant. Il existe deux méthodes pour déclarer une correspondance de sources : en utilisant un commentaire ou définissant un en-tête pour le fichier JavaScript.</p> +La plupart du temps, les fichiers sources des scripts JavaScript sont fusionnés et minifiés afin que les transferts de fichiers du serveur vers le navigateur soient plus efficaces. Grâce [aux fichiers de correspondance des sources (_source maps_)](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/), il est possible d'indiquer au débogueur le code original correspondant. Il existe deux méthodes pour déclarer une correspondance de sources : en utilisant un commentaire ou définissant un en-tête pour le fichier JavaScript. -<h2 id="Exemples">Exemples</h2> +## Exemples -<p>Voici une correspondance de source déclarée via un commentaire dans le fichier :</p> +Voici une correspondance de source déclarée via un commentaire dans le fichier : -<pre class="brush: js example-good">//# sourceMappingURL=http://exemple.com/chemin/vers/la/sourcemap.map</pre> +```js example-good +//# sourceMappingURL=http://exemple.com/chemin/vers/la/sourcemap.map +``` -<p>Une autre méthode consiste à indiquer la source originale dans l'en-tête du fichier JavaScript :</p> +Une autre méthode consiste à indiquer la source originale dans l'en-tête du fichier JavaScript : -<pre class="brush: js example-good">X-SourceMap: /chemin/vers/le/fichier.js.map</pre> +```js example-good +X-SourceMap: /chemin/vers/le/fichier.js.map +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Outils/Débogueur/Comment/Utiliser_une_source_map">Comment utiliser une correspondance de source - Les outils de développement Firefox</a></li> - <li><a href="http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/">Une introduction aux correspondances de sources – HTML5 Rocks (en anglais)</a></li> -</ul> +- [Comment utiliser une correspondance de source - Les outils de développement Firefox](/fr/docs/Outils/Débogueur/Comment/Utiliser_une_source_map) +- [Une introduction aux correspondances de sources – HTML5 Rocks (en anglais)](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/) diff --git a/files/fr/web/javascript/reference/errors/array_sort_argument/index.md b/files/fr/web/javascript/reference/errors/array_sort_argument/index.md index 6f7c3d07f2..b39add1b92 100644 --- a/files/fr/web/javascript/reference/errors/array_sort_argument/index.md +++ b/files/fr/web/javascript/reference/errors/array_sort_argument/index.md @@ -8,41 +8,41 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Array_sort_argument original_slug: Web/JavaScript/Reference/Erreurs/Array_sort_argument --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: argument is not a function object (Edge) -TypeError: invalid Array.prototype.sort argument (Firefox) -</pre> + TypeError: argument is not a function object (Edge) + TypeError: invalid Array.prototype.sort argument (Firefox) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}</p> +{{jsxref("TypeError")}} -<h2 id="Que_s'est-il_passé">Que s'est-il passé ?</h2> +## Que s'est-il passé ? -<p>L'argument passé à {{jsxref("Array.prototype.sort()")}} devrait être {{jsxref("undefined")}} ou être une fonction comparant ses opérandes.</p> +L'argument passé à {{jsxref("Array.prototype.sort()")}} devrait être {{jsxref("undefined")}} ou être une fonction comparant ses opérandes. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Cas_invalides">Cas invalides</h3> +### Cas invalides -<pre class="brush: js example-bad">[1, 3, 2].sort(5); // TypeError +```js example-bad +[1, 3, 2].sort(5); // TypeError -var cmp = { asc: (x, y) => x >= y, dsc : (x, y) => x <= y }; +var cmp = { asc: (x, y) => x >= y, dsc : (x, y) => x <= y }; [1, 3, 2].sort(cmp[this.key] || 'asc'); // TypeError -</pre> +``` -<h3 id="Cas_valides">Cas valides</h3> +### Cas valides -<pre class="brush: js example-good">[1, 3, 2].sort(); // [1, 2, 3] +```js example-good +[1, 3, 2].sort(); // [1, 2, 3] -var cmp = { asc: (x, y) => x >= y, dsc : (x, y) => x <= y }; -[1, 3, 2].sort(cmp[this.key || 'asc']); // [1, 2, 3]</pre> +var cmp = { asc: (x, y) => x >= y, dsc : (x, y) => x <= y }; +[1, 3, 2].sort(cmp[this.key || 'asc']); // [1, 2, 3] +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("Array.prototype.sort()")}}</li> -</ul> +- {{jsxref("Array.prototype.sort()")}} diff --git a/files/fr/web/javascript/reference/errors/bad_octal/index.md b/files/fr/web/javascript/reference/errors/bad_octal/index.md index 4b14545161..eeea43f7ac 100644 --- a/files/fr/web/javascript/reference/errors/bad_octal/index.md +++ b/files/fr/web/javascript/reference/errors/bad_octal/index.md @@ -10,44 +10,44 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Bad_octal original_slug: Web/JavaScript/Reference/Erreurs/Bad_octal --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">Warning: SyntaxError: 08 is not a legal ECMA-262 octal constant. -Warning: SyntaxError: 09 is not a legal ECMA-262 octal constant. -</pre> + Warning: SyntaxError: 08 is not a legal ECMA-262 octal constant. + Warning: SyntaxError: 09 is not a legal ECMA-262 octal constant. -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>Un avertissement, l'exécution du script JavaScript ne sera pas interrompue.</p> +Un avertissement, l'exécution du script JavaScript ne sera pas interrompue. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Les littéraux de nombres décimaux peuvent démarrer par un zéro suivi d'un autre chiffre. Si tous les chiffres après le 0 de tête sont inférieurs à 8, le nombre est interprété comme un nombre en notation octale. Or, cela ne peut pas être le cas avec <code>08</code> et <code>09</code> et JavaScript produit un avertissement.</p> +Les littéraux de nombres décimaux peuvent démarrer par un zéro suivi d'un autre chiffre. Si tous les chiffres après le 0 de tête sont inférieurs à 8, le nombre est interprété comme un nombre en notation octale. Or, cela ne peut pas être le cas avec `08` et `09` et JavaScript produit un avertissement. -<p>Les littéraux en notation octale et les séquences d'échappement octales sont désormais dépréciées (il y a aura donc un avertissement complémentaire sur la dépréciation de ces notations). Avec ECMAScript 6 et les versions ultérieures, la syntaxe utilise un zéro initial, suivi de la lettre latine « o » en majuscule ou en minuscule ((<code>0o</code> ou <code>0O)</code>. Pour plus d'informations à ce sujet, voir la page sur <a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Octaux">la grammaire lexicale JavaScript</a>.</p> +Les littéraux en notation octale et les séquences d'échappement octales sont désormais dépréciées (il y a aura donc un avertissement complémentaire sur la dépréciation de ces notations). Avec ECMAScript 6 et les versions ultérieures, la syntaxe utilise un zéro initial, suivi de la lettre latine « o » en majuscule ou en minuscule ((`0o` ou `0O)`. Pour plus d'informations à ce sujet, voir la page sur [la grammaire lexicale JavaScript](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Octaux). -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Nombres_invalides_en_notation_octale">Nombres invalides en notation octale</h3> +### Nombres invalides en notation octale -<pre class="brush: js example-bad">08; +```js example-bad +08; 09; // SyntaxError: 08 is not a legal ECMA-262 octal constant -// SyntaxError: "0"-prefixed octal literals and octal escape sequences are deprecated</pre> +// SyntaxError: "0"-prefixed octal literals and octal escape sequences are deprecated +``` -<h3 id="Nombres_valides_en_notation_octale">Nombres valides en notation octale</h3> +### Nombres valides en notation octale -<p>On utilisera un zéro suivi de la lettre « o » pour indiquer un nombre exprimé en notation octale :</p> +On utilisera un zéro suivi de la lettre « o » pour indiquer un nombre exprimé en notation octale : -<pre class="brush: js example-good">0O755; +```js example-good +0O755; 0o644; -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Octaux">La grammaire lexicale de JavaScript</a></li> - <li><a href="/fr/docs/Web/JavaScript/Reference/Errors/Deprecated_octal">SyntaxError: "0"-prefixed octal literals and octal escape seq. are deprecated</a></li> -</ul> +- [La grammaire lexicale de JavaScript](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Octaux) +- [SyntaxError: "0"-prefixed octal literals and octal escape seq. are deprecated](/fr/docs/Web/JavaScript/Reference/Errors/Deprecated_octal) diff --git a/files/fr/web/javascript/reference/errors/bad_radix/index.md b/files/fr/web/javascript/reference/errors/bad_radix/index.md index c620439cae..ecc2b20a37 100644 --- a/files/fr/web/javascript/reference/errors/bad_radix/index.md +++ b/files/fr/web/javascript/reference/errors/bad_radix/index.md @@ -8,57 +8,54 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Bad_radix original_slug: Web/JavaScript/Reference/Erreurs/Bad_radix --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">RangeError: invalid argument (Edge) -RangeError: radix must be an integer at least 2 and no greater than 36 (Firefox) -RangeError: toString() radix argument must be between 2 and 36 (Chrome) -</pre> + RangeError: invalid argument (Edge) + RangeError: radix must be an integer at least 2 and no greater than 36 (Firefox) + RangeError: toString() radix argument must be between 2 and 36 (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("RangeError")}}</p> +{{jsxref("RangeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>C'est le paramètre utilisé avec la méthode {{jsxref("Number.prototype.toString()")}} ou avec la méthode {{jsxref("BigInt.prototype.toString()")}} pour indiquer la base de conversion qui est en cause. Ce paramètre, optionnel, doit être un nombre entier, compris entre 2 et 36 qui inique la base du système numérique dans lequel on veut représenter les valeurs numériques.</p> +C'est le paramètre utilisé avec la méthode {{jsxref("Number.prototype.toString()")}} ou avec la méthode {{jsxref("BigInt.prototype.toString()")}} pour indiquer la base de conversion qui est en cause. Ce paramètre, optionnel, doit être un nombre entier, compris entre 2 et 36 qui inique la base du système numérique dans lequel on veut représenter les valeurs numériques. -<p>Pourquoi limiter la base à 36 ? Lorsqu'une base est supérieure à 10, on utilise les caractères de l'alphabet pour représenter les chiffres. Or, l'alphabet latin ne possède que 26 caractères. En utilisant donc les 10 chiffres arabes et ces caractères, on possède 36 caractères pour représenter les chiffres d'un nombre.</p> +Pourquoi limiter la base à 36 ? Lorsqu'une base est supérieure à 10, on utilise les caractères de l'alphabet pour représenter les chiffres. Or, l'alphabet latin ne possède que 26 caractères. En utilisant donc les 10 chiffres arabes et ces caractères, on possède 36 caractères pour représenter les chiffres d'un nombre. -<p>Généralement, on emploie cette méthode avec des bases fréquemment utilisées :</p> +Généralement, on emploie cette méthode avec des bases fréquemment utilisées : -<ul> - <li>2 pour <a href="https://fr.wikipedia.org/wiki/Syst%C3%A8me_binaire">les nombres binaires</a>,</li> - <li>8 pour <a href="https://fr.wikipedia.org/wiki/Syst%C3%A8me_octal">les nombres octaux</a>,</li> - <li>10 pour <a href="https://fr.wikipedia.org/wiki/Syst%C3%A8me_d%C3%A9cimal">les nombres décimaux</a>,</li> - <li>16 pour <a href="https://fr.wikipedia.org/wiki/Syst%C3%A8me_hexad%C3%A9cimal">les nombres hexadécimaux</a>.</li> -</ul> +- 2 pour [les nombres binaires](https://fr.wikipedia.org/wiki/Syst%C3%A8me_binaire), +- 8 pour [les nombres octaux](https://fr.wikipedia.org/wiki/Syst%C3%A8me_octal), +- 10 pour [les nombres décimaux](https://fr.wikipedia.org/wiki/Syst%C3%A8me_d%C3%A9cimal), +- 16 pour [les nombres hexadécimaux](https://fr.wikipedia.org/wiki/Syst%C3%A8me_hexad%C3%A9cimal). -<h2 id="Examples">Examples</h2> +## Examples -<h3 id="Exemples_invalides">Exemples invalides</h3> +### Exemples invalides -<pre class="brush: js example-bad">(42).toString(0); +```js example-bad +(42).toString(0); (42).toString(1); (42).toString(37); (42).toString(150); // On ne peut pas utiliser une telle // chaîne pour du formatage : (12071989).toString("MM-dd-yyyy"); -</pre> +``` -<h3 id="Exemples_valides">Exemples valides</h3> +### Exemples valides -<pre class="brush: js example-good">(42).toString(2); // "101010" (binary) +```js example-good +(42).toString(2); // "101010" (binary) (13).toString(8); // "15" (octal) (0x42).toString(10); // "66" (decimal) (100000).toString(16) // "186a0" (hexadecimal) -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("Number.prototype.toString()")}}</li> -</ul> +- {{jsxref("Number.prototype.toString()")}} diff --git a/files/fr/web/javascript/reference/errors/bad_regexp_flag/index.md b/files/fr/web/javascript/reference/errors/bad_regexp_flag/index.md index 9f1632d1a0..17657e237b 100644 --- a/files/fr/web/javascript/reference/errors/bad_regexp_flag/index.md +++ b/files/fr/web/javascript/reference/errors/bad_regexp_flag/index.md @@ -8,100 +8,81 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Bad_regexp_flag original_slug: Web/JavaScript/Reference/Erreurs/Bad_regexp_flag --- -<div>{{jsSidebar("Errors")}}</div> - -<h2 id="Message">Message</h2> - -<pre class="syntaxbox">SyntaxError: Syntax error in regular expression (Edge) -SyntaxError: invalid regular expression flag "x" (Firefox) -SyntaxError: Invalid regular expression flags (Chrome) -</pre> - -<h2 id="Type_d'erreur">Type d'erreur</h2> - -<p>{{jsxref("SyntaxError")}}</p> - -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> - -<p>Un marqueur (<em>flag</em>) invalide est utilisé dans une expression rationnelle. Un littéral d'expression rationnelle se compose d'un motif entouré de deux barres obliques, les marqueurs sont ajoutés après la seconde barre oblique. On peut également les indiquer dans le deuxième paramètre du constructeur {{jsxref("RegExp")}}. Les marqueurs d'une expression rationnelle peuvent être utilisés séparément ou combinés, dans n'importe quel ordre. Il existe uniquement cinq marqueurs autorisés en ECMAScript.</p> - -<p>Pour ajouter un marqueur sur une expression rationnelle, on utilisera cette syntaxe :</p> - -<pre class="brush: js">var re = /motif/marqueurs; -</pre> - -<p>ou encore :</p> - -<pre class="brush: js">var re = new RegExp('motif', 'marqueurs');</pre> - -<table class="standard-table"> - <caption>Marqueurs autorisés pour les expressions rationnelles</caption> - <thead> - <tr> - <th scope="col">Marqueur</th> - <th scope="col">Description</th> - </tr> - </thead> - <tbody> - <tr> - <td><code>g</code></td> - <td>Recherche globale.</td> - </tr> - <tr> - <td>i</td> - <td>Recherche non-sensible à la casse.</td> - </tr> - <tr> - <td>m</td> - <td>Recherche sur plusieurs lignes.</td> - </tr> - <tr> - <td>u</td> - <td>Unicode : le motif est interprété comme une suite de codets Unicode.</td> - </tr> - <tr> - <td>y</td> - <td>La recherche effectuée est « adhérente » et recherche une correspondance à la position indiquée dans la chaîne cible (cf. {{jsxref("RegExp.sticky", "sticky")}}).</td> - </tr> - </tbody> -</table> - -<h2 id="Exemples">Exemples</h2> - -<p>Seuls cinq marqueurs d'expression rationnelle sont valides :</p> - -<pre class="brush: js example-bad">/toto/truc; +{{jsSidebar("Errors")}} + +## Message + + SyntaxError: Syntax error in regular expression (Edge) + SyntaxError: invalid regular expression flag "x" (Firefox) + SyntaxError: Invalid regular expression flags (Chrome) + +## Type d'erreur + +{{jsxref("SyntaxError")}} + +## Quel est le problème ? + +Un marqueur (_flag_) invalide est utilisé dans une expression rationnelle. Un littéral d'expression rationnelle se compose d'un motif entouré de deux barres obliques, les marqueurs sont ajoutés après la seconde barre oblique. On peut également les indiquer dans le deuxième paramètre du constructeur {{jsxref("RegExp")}}. Les marqueurs d'une expression rationnelle peuvent être utilisés séparément ou combinés, dans n'importe quel ordre. Il existe uniquement cinq marqueurs autorisés en ECMAScript. + +Pour ajouter un marqueur sur une expression rationnelle, on utilisera cette syntaxe : + +```js +var re = /motif/marqueurs; +``` + +ou encore : + +```js +var re = new RegExp('motif', 'marqueurs'); +``` + +| Marqueur | Description | +| -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `g` | Recherche globale. | +| i | Recherche non-sensible à la casse. | +| m | Recherche sur plusieurs lignes. | +| u | Unicode : le motif est interprété comme une suite de codets Unicode. | +| y | La recherche effectuée est « adhérente » et recherche une correspondance à la position indiquée dans la chaîne cible (cf. {{jsxref("RegExp.sticky", "sticky")}}). | + +## Exemples + +Seuls cinq marqueurs d'expression rationnelle sont valides : + +```js example-bad +/toto/truc; // SyntaxError: invalid regular expression flag "t" -</pre> +``` -<p>Peut-être souhaitiez-vous créer une expression rationnelle ? Une expression qui contient deux barres obliques est interprétée comme un littéral d'expression rationnelle :</p> +Peut-être souhaitiez-vous créer une expression rationnelle ? Une expression qui contient deux barres obliques est interprétée comme un littéral d'expression rationnelle : -<pre class="brush: js example-bad">let obj = { +```js example-bad +let obj = { url: /docs/Web }; // SyntaxError: invalid regular expression flag "W" -</pre> +``` -<p>Peut-être souhaitiez-vous créer une chaîne de caractères ? Dans ce cas, il faut ajouter des quotes (simples ou doubles) afin de former un littéral de chaîne de caractères :</p> +Peut-être souhaitiez-vous créer une chaîne de caractères ? Dans ce cas, il faut ajouter des quotes (simples ou doubles) afin de former un littéral de chaîne de caractères : -<pre class="brush: js example-good">let obj = { +```js example-good +let obj = { url: '/docs/Web' -};</pre> +}; +``` -<h3 id="Marqueurs_valides">Marqueurs valides</h3> +### Marqueurs valides -<p>Voir le tableau ci-avant pour la liste des marqueurs autorisés pour manipuler les expressions rationnelles en JavaScript.</p> +Voir le tableau ci-avant pour la liste des marqueurs autorisés pour manipuler les expressions rationnelles en JavaScript. -<pre class="brush: js example-good">/toto/g; +```js example-good +/toto/g; /toto/gim; /toto/uy; -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières">Les expressions rationnelles</a></li> - <li><a href="http://xregexp.com/flags/">XRegEx</a> – une bibliothèque relative aux expressions rationnelles qui fournit quatre nouveaux marqueurs (<em>flags</em>) (<code>n</code>, <code>s</code>, <code>x</code>, <code>A</code>)</li> -</ul> +- [Les expressions rationnelles](/fr/docs/Web/JavaScript/Guide/Expressions_régulières) +- [XRegEx](http://xregexp.com/flags/) – une bibliothèque relative aux expressions rationnelles qui fournit quatre nouveaux marqueurs (_flags_) (`n`, `s`, `x`, `A`) diff --git a/files/fr/web/javascript/reference/errors/bad_return_or_yield/index.md b/files/fr/web/javascript/reference/errors/bad_return_or_yield/index.md index 787f099067..f50090e6ec 100644 --- a/files/fr/web/javascript/reference/errors/bad_return_or_yield/index.md +++ b/files/fr/web/javascript/reference/errors/bad_return_or_yield/index.md @@ -9,50 +9,51 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Bad_return_or_yield original_slug: Web/JavaScript/Reference/Erreurs/Bad_return_or_yield --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: 'return' statement outside of function (Edge) -SyntaxError: return not in function (Firefox) -SyntaxError: yield not in function (Firefox) -</pre> + SyntaxError: 'return' statement outside of function (Edge) + SyntaxError: return not in function (Firefox) + SyntaxError: yield not in function (Firefox) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}.</p> +{{jsxref("SyntaxError")}}. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Une instruction <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/return">return</a></code> ou <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/yield">yield</a></code> est utilisée en dehors d'une <a href="/fr/docs/Web/JavaScript/Guide/Fonctions">fonction</a>. Il est possible que des accolades soient manquantes. Les mots-clés <code>return</code> et <code>yield</code> doivent être utilisés dans une fonction car ils permettent de terminer ou d'arrêter/reprendre l'exécution d'une fonction et de définir une valeur qui doit être renvoyée à l'appelant de la fonction.</p> +Une instruction [`return`](/fr/docs/Web/JavaScript/Reference/Instructions/return) ou [`yield`](/fr/docs/Web/JavaScript/Reference/Opérateurs/yield) est utilisée en dehors d'une [fonction](/fr/docs/Web/JavaScript/Guide/Fonctions). Il est possible que des accolades soient manquantes. Les mots-clés `return` et `yield` doivent être utilisés dans une fonction car ils permettent de terminer ou d'arrêter/reprendre l'exécution d'une fonction et de définir une valeur qui doit être renvoyée à l'appelant de la fonction. -<h2 id="Exemples">Exemples</h2> +## Exemples -<pre class="brush: js example-bad">var encouragement = function(score) { +```js example-bad +var encouragement = function(score) { if (score === 147) return "Super !"; }; - if (score > 100) { + if (score > 100) { return "Un record!"; } } -// SyntaxError: return not in function</pre> +// SyntaxError: return not in function +``` -<p>À première vue, les accolades semblent correctes mais en regardant de plus près, on voit qu'il manque une accolade ouvrante ("{") après la première instruction <code>if</code>. La version correcte serait :</p> +À première vue, les accolades semblent correctes mais en regardant de plus près, on voit qu'il manque une accolade ouvrante ("{") après la première instruction `if`. La version correcte serait : -<pre class="brush: js example-good">var encouragement = function(score) { +```js example-good +var encouragement = function(score) { if (score === 147) { return "Maximum!"; } - if (score > 100) { + if (score > 100) { return "Century!"; } -};</pre> +}; +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/return">return</a></code></li> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/yield">yield</a></code></li> -</ul> +- [`return`](/fr/docs/Web/JavaScript/Reference/Instructions/return) +- [`yield`](/fr/docs/Web/JavaScript/Reference/Opérateurs/yield) diff --git a/files/fr/web/javascript/reference/errors/called_on_incompatible_type/index.md b/files/fr/web/javascript/reference/errors/called_on_incompatible_type/index.md index 35fcf07a52..a560955088 100644 --- a/files/fr/web/javascript/reference/errors/called_on_incompatible_type/index.md +++ b/files/fr/web/javascript/reference/errors/called_on_incompatible_type/index.md @@ -8,34 +8,34 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Called_on_incompatible_type original_slug: Web/JavaScript/Reference/Erreurs/Called_on_incompatible_type --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: 'this' is not a Set object (Edge) -TypeError: Function.prototype.toString called on incompatible object (Firefox) -TypeError: Function.prototype.bind called on incompatible target (Firefox) -TypeError: Method Set.prototype.add called on incompatible receiver undefined (Chrome) -TypeError: Bind must be called on a function (Chrome) -</pre> + TypeError: 'this' is not a Set object (Edge) + TypeError: Function.prototype.toString called on incompatible object (Firefox) + TypeError: Function.prototype.bind called on incompatible target (Firefox) + TypeError: Method Set.prototype.add called on incompatible receiver undefined (Chrome) + TypeError: Bind must be called on a function (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}</p> +{{jsxref("TypeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Lorsque cette erreur est levée, cela signifie qu'une fonction (d'un objet donné) est appelé avec une valeur <code>this</code> qui ne correspond pas au type attendu par la fonction.</p> +Lorsque cette erreur est levée, cela signifie qu'une fonction (d'un objet donné) est appelé avec une valeur `this` qui ne correspond pas au type attendu par la fonction. -<p>Cela peut se produire lorsqu'on utilise les méthodes {{jsxref("Function.prototype.call()")}} ou {{jsxref("Function.prototype.apply()")}} et qu'on fournit un argument <code>this</code> dont le type n'est pas celui attendu.</p> +Cela peut se produire lorsqu'on utilise les méthodes {{jsxref("Function.prototype.call()")}} ou {{jsxref("Function.prototype.apply()")}} et qu'on fournit un argument `this` dont le type n'est pas celui attendu. -<p>Cela peut également se produire quand on fournit une fonction (sous la forme d'un objet) comme argument d'une autre fonction. Dans ce cas, l'objet ne sera pas capturé comme valeur <code>this</code> pour la fonction. Pour contourner ce problème, on peut fournir une fonction lambda qui effectue l'appel ou utiliser la fonction {{jsxref("Function.prototype.bind()")}} afin que <code>this</code> soit l'objet attendu.</p> +Cela peut également se produire quand on fournit une fonction (sous la forme d'un objet) comme argument d'une autre fonction. Dans ce cas, l'objet ne sera pas capturé comme valeur `this` pour la fonction. Pour contourner ce problème, on peut fournir une fonction lambda qui effectue l'appel ou utiliser la fonction {{jsxref("Function.prototype.bind()")}} afin que `this` soit l'objet attendu. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Exemples_invalides">Exemples invalides</h3> +### Exemples invalides -<pre class="brush: js example-bad">var monSet = new Set; +```js example-bad +var monSet = new Set; ['truc', 'bidule'].forEach(monSet.add); // monSet.add est une fonction mais // "monSet" n'est pas capturé en tant que this. @@ -47,30 +47,27 @@ var maFonction = function () { // maFonction.bind est une fonction // mais "maFonction" n'est pas capturé en tant // que this. +``` -</pre> +### Exemples valides -<h3 id="Exemples_valides">Exemples valides</h3> - -<pre class="brush: js example-good">var monSet = new Set; +```js example-good +var monSet = new Set; ['truc', 'bidule'].forEach(monSet.add.bind(monSet)); // Cela fonctionne car on lie "monSet" avec this. var maFonction = function () { console.log(this) }; -['truc', 'bidule'].forEach(x => maFonction.bind(x)); +['truc', 'bidule'].forEach(x => maFonction.bind(x)); // Cela fonctionne car on utilise // la fonction "bind" ce qui permet de // créer une fonction lambda qui propage // l'argument. +``` -</pre> - -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("Function.prototype.call()")}}</li> - <li>{{jsxref("Function.prototype.apply()")}}</li> - <li>{{jsxref("Function.prototype.bind()")}}</li> -</ul> +- {{jsxref("Function.prototype.call()")}} +- {{jsxref("Function.prototype.apply()")}} +- {{jsxref("Function.prototype.bind()")}} diff --git a/files/fr/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.md b/files/fr/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.md index 1ac434163b..351754cba4 100644 --- a/files/fr/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.md +++ b/files/fr/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.md @@ -9,30 +9,30 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Cant_access_lexical_declaration_before_init original_slug: Web/JavaScript/Reference/Erreurs/Cant_access_lexical_declaration_before_init --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">ReferenceError: Use before delaration (Edge) -ReferenceError: can't access lexical declaration `X' before initialization (Firefox) -ReferenceError: 'x' is not defined (Chrome) -</pre> + ReferenceError: Use before delaration (Edge) + ReferenceError: can't access lexical declaration `X' before initialization (Firefox) + ReferenceError: 'x' is not defined (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("ReferenceError")}}</p> +{{jsxref("ReferenceError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Il y a eu un accès à une variable déclarée avec <code>let</code> ou <code>const</code> avant que celle-ci ait été initialisée. Cela peut se produire dans n'importe quelle instruction de bloc avec une variable déclarée avec <code>let</code> ou <code>const</code> et qui est utilisée avant son initialisation.</p> +Il y a eu un accès à une variable déclarée avec `let` ou `const` avant que celle-ci ait été initialisée. Cela peut se produire dans n'importe quelle instruction de bloc avec une variable déclarée avec `let` ou `const` et qui est utilisée avant son initialisation. -<h2 id="Exemple">Exemple</h2> +## Exemple -<h3 id="Exemples_invalides">Exemples invalides</h3> +### Exemples invalides -<p>Dans l'exemple qui suit, la variable <code>toto</code> est redéclarée dans le bloc avec un second <code>let</code> et elle n'est donc pas initialisée.</p> +Dans l'exemple qui suit, la variable `toto` est redéclarée dans le bloc avec un second `let` et elle n'est donc pas initialisée. -<pre class="brush: js example-bad">function test(){ +```js example-bad +function test(){ let toto = 33; if (true) { let toto = (toto + 55); @@ -41,23 +41,22 @@ ReferenceError: 'x' is not defined (Chrome) } } test(); -</pre> +``` -<h3 id="Exemples_valides">Exemples valides</h3> +### Exemples valides -<p>Afin que <code>toto</code> puisse être modifiée au sein de l'instruction <code>if</code>, on enlèvera la redéclaration dans ce bloc :</p> +Afin que `toto` puisse être modifiée au sein de l'instruction `if`, on enlèvera la redéclaration dans ce bloc : -<pre class="brush: js example-good">function test(){ +```js example-good +function test(){ let toto = 33; if (true) { toto = (toto + 55); } } test(); -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Instructions/let#Zone_morte_temporaire_(Temporal_Dead_Zone_TDZ)_et_les_erreurs_liées_à_let">La « zone morte temporelle » (ou TDZ pour « <em>Temporal Dead Zone</em> ») et les erreurs avec <code>let</code></a></li> -</ul> +- [La « zone morte temporelle » (ou TDZ pour « _Temporal Dead Zone_ ») et les erreurs avec `let`](</fr/docs/Web/JavaScript/Reference/Instructions/let#Zone_morte_temporaire_(Temporal_Dead_Zone_TDZ)_et_les_erreurs_liées_à_let>) diff --git a/files/fr/web/javascript/reference/errors/cant_access_property/index.md b/files/fr/web/javascript/reference/errors/cant_access_property/index.md index e9ea7c5e0c..20c4ffd4a6 100644 --- a/files/fr/web/javascript/reference/errors/cant_access_property/index.md +++ b/files/fr/web/javascript/reference/errors/cant_access_property/index.md @@ -8,53 +8,53 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Cant_access_property original_slug: Web/JavaScript/Reference/Erreurs/Cant_access_property --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: Unable to get property {x} of undefined or null reference (Edge) -TypeError: can't access property {x} of {y} (Firefox) -TypeError: {y} is undefined, can't access property {x} of it (Firefox) -TypeError: {y} is null, can't access property {x} of it (Firefox) + TypeError: Unable to get property {x} of undefined or null reference (Edge) + TypeError: can't access property {x} of {y} (Firefox) + TypeError: {y} is undefined, can't access property {x} of it (Firefox) + TypeError: {y} is null, can't access property {x} of it (Firefox) -Exemples -TypeError: x is undefined, can't access property "prop" of it -TypeError: x is null, can't access property "prop" of it -TypeError: can't access property "prop" of undefined -TypeError: can't access property "prop" of null -</pre> + Exemples + TypeError: x is undefined, can't access property "prop" of it + TypeError: x is null, can't access property "prop" of it + TypeError: can't access property "prop" of undefined + TypeError: can't access property "prop" of null -<h2 id="Types_d'erreur">Types d'erreur</h2> +## Types d'erreur -<p>{{jsxref("TypeError")}}.</p> +{{jsxref("TypeError")}}. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>On a tenté d'accéder à une propriété sur la valeur {{jsxref("undefined")}} ou {{jsxref("null")}}.</p> +On a tenté d'accéder à une propriété sur la valeur {{jsxref("undefined")}} ou {{jsxref("null")}}. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Cas_invalides">Cas invalides</h3> +### Cas invalides -<pre class="brush: js example-bad">// undefined et null ne possèdent aucune propriété et aucune méthode substring +```js example-bad +// undefined et null ne possèdent aucune propriété et aucune méthode substring var toto = undefined; toto.substring(1); // TypeError: x is undefined, can't access property "substring" of it var toto = null; toto.substring(1); // TypeError: x is null, can't access property "substring" of it -</pre> +``` -<h3 id="Corriger_le_problème">Corriger le problème</h3> +### Corriger le problème -<p>Pour détecter le cas où la valeur utilisée est <code>undefined</code> ou <code>null</code>, on peut utiliser l'opérateur <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof">typeof</a></code>. Par exemple :</p> +Pour détecter le cas où la valeur utilisée est `undefined` ou `null`, on peut utiliser l'opérateur [`typeof`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof). Par exemple : -<pre class="brush: js">if (typeof toto !== 'undefined') { +```js +if (typeof toto !== 'undefined') { // On sait alors que toto est bien défini et on peut utiliser ses propriétés s'il en a. -}</pre> +} +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("undefined")}}</li> - <li>{{jsxref("null")}}</li> -</ul> +- {{jsxref("undefined")}} +- {{jsxref("null")}} diff --git a/files/fr/web/javascript/reference/errors/cant_assign_to_property/index.md b/files/fr/web/javascript/reference/errors/cant_assign_to_property/index.md index 29b72aaa47..771d329791 100644 --- a/files/fr/web/javascript/reference/errors/cant_assign_to_property/index.md +++ b/files/fr/web/javascript/reference/errors/cant_assign_to_property/index.md @@ -9,48 +9,47 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Cant_assign_to_property original_slug: Web/JavaScript/Reference/Erreurs/Cant_assign_to_property --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: can't assign to property "x" on {y}: not an object (Firefox) -TypeError: Cannot create property 'x' on {y} (Chrome) -</pre> + TypeError: can't assign to property "x" on {y}: not an object (Firefox) + TypeError: Cannot create property 'x' on {y} (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}.</p> +{{jsxref("TypeError")}}. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>En <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>, une exception {{jsxref("TypeError")}} est déclenchée lorsqu'on tente de créer une propriété sur <a href="/fr/docs/Web/JavaScript/Structures_de_données#Les_valeurs_primitives">une valeur primitive</a> telle qu'un symbole, une chaîne de caractères, un nombre ou un booleén.</p> +En [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode), une exception {{jsxref("TypeError")}} est déclenchée lorsqu'on tente de créer une propriété sur [une valeur primitive](/fr/docs/Web/JavaScript/Structures_de_données#Les_valeurs_primitives) telle qu'un symbole, une chaîne de caractères, un nombre ou un booleén. -<p>Le problème peut être lié à une valeur qui se trouve à un endroit inattendu ou qu'un équivalent objet d'une valeur primitive est attendu (ex. {{jsxref("String")}} pour la chaîne de caractères ou {{jsxref("Number")}} pour un nombre).</p> +Le problème peut être lié à une valeur qui se trouve à un endroit inattendu ou qu'un équivalent objet d'une valeur primitive est attendu (ex. {{jsxref("String")}} pour la chaîne de caractères ou {{jsxref("Number")}} pour un nombre). -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Exemple_invalide">Exemple invalide</h3> +### Exemple invalide -<pre class="brush: js example-bad">'use strict'; +```js example-bad +'use strict'; var foo = "my string"; // The following line does nothing if not in strict mode. foo.bar = {}; // TypeError: can't assign to property "bar" on "my string": not an object -</pre> +``` -<h3 id="Exemple_valide">Exemple valide</h3> +### Exemple valide -<p>On pourra corriger le problème en convertissant la valeur primitive en sont équivalent objet avec un constructeur (ici {{jsxref("String")}} pour .</p> +On pourra corriger le problème en convertissant la valeur primitive en sont équivalent objet avec un constructeur (ici {{jsxref("String")}} pour . -<pre class="brush: js example-good">'use strict'; +```js example-good +'use strict'; var foo = new String("my string"); foo.bar = {}; -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("Strict_mode")}}</li> - <li>{{Glossary("primitive")}}</li> -</ul> +- {{jsxref("Strict_mode")}} +- {{Glossary("primitive")}} diff --git a/files/fr/web/javascript/reference/errors/cant_define_property_object_not_extensible/index.md b/files/fr/web/javascript/reference/errors/cant_define_property_object_not_extensible/index.md index 674ffd0138..8849cda16d 100644 --- a/files/fr/web/javascript/reference/errors/cant_define_property_object_not_extensible/index.md +++ b/files/fr/web/javascript/reference/errors/cant_define_property_object_not_extensible/index.md @@ -8,59 +8,60 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Cant_define_property_object_not_extensible original_slug: Web/JavaScript/Reference/Erreurs/Cant_define_property_object_not_extensible --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: Cannot create property for a non-extensible object (Edge) -TypeError: can't define property "x": "obj" is not extensible (Firefox) -TypeError: Cannot define property: "x", object is not extensible. (Chrome) -</pre> + TypeError: Cannot create property for a non-extensible object (Edge) + TypeError: can't define property "x": "obj" is not extensible (Firefox) + TypeError: Cannot define property: "x", object is not extensible. (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}</p> +{{jsxref("TypeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>La plupart du temps, un objet est extensible, ce qui signifie qu'on peut lui ajouter de nouvelles propriétés. Cependant, dans ce cas, on a utilisé la méthode {{jsxref("Object.preventExtensions()")}} afin de marquer l'objet comme non-extensible. Celui-ci ne pourra donc pas recevoir de nouvelles propriétés en plus de celles dont il dispose déjà.</p> +La plupart du temps, un objet est extensible, ce qui signifie qu'on peut lui ajouter de nouvelles propriétés. Cependant, dans ce cas, on a utilisé la méthode {{jsxref("Object.preventExtensions()")}} afin de marquer l'objet comme non-extensible. Celui-ci ne pourra donc pas recevoir de nouvelles propriétés en plus de celles dont il dispose déjà. -<h2 id="Exemples">Exemples</h2> +## Exemples -<p>En <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>, si on essaie d'ajouter une nouvelle propriété sur un objet non-extensible, on obtient une exception <code>TypeError</code>. En mode non-strict, l'ajout de la nouvelle propriété est ignoré silencieusement.</p> +En [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode), si on essaie d'ajouter une nouvelle propriété sur un objet non-extensible, on obtient une exception `TypeError`. En mode non-strict, l'ajout de la nouvelle propriété est ignoré silencieusement. -<pre class="brush: js example-bad">'use strict'; +```js example-bad +'use strict'; var obj = {}; Object.preventExtensions(obj); obj.x = 'toto'; // TypeError: can't define property "x": "obj" is not extensible -</pre> +``` -<p>Pour le mode strict ete le mode non-strict, un appel à {{jsxref("Object.defineProperty()")}} déclenchera une exception lorsqu'on utilisera cette méthode pour ajouter une nouvelle propriété à un objet non-extenssible.</p> +Pour le mode strict ete le mode non-strict, un appel à {{jsxref("Object.defineProperty()")}} déclenchera une exception lorsqu'on utilisera cette méthode pour ajouter une nouvelle propriété à un objet non-extenssible. -<pre class="brush: js example-bad">var obj = { }; +```js example-bad +var obj = { }; Object.preventExtensions(obj); Object.defineProperty(obj, 'x', { value: "toto" } ); // TypeError: can't define property "x": "obj" is not extensible -</pre> +``` -<p>Pour corriger cet erreur, il faut retirer l'appel à {{jsxref("Object.preventExtensions()")}} pour que l'objet soit extensible, soit ajouter la propriété avant que l'objet devienne non-extensible, soit retirer l'ajout de cette propriété si elle n'est pas nécessaire.</p> +Pour corriger cet erreur, il faut retirer l'appel à {{jsxref("Object.preventExtensions()")}} pour que l'objet soit extensible, soit ajouter la propriété avant que l'objet devienne non-extensible, soit retirer l'ajout de cette propriété si elle n'est pas nécessaire. -<pre class="brush: js example-good">'use strict'; +```js example-good +'use strict'; var obj = {}; obj.x = 'toto'; // On ajoute la propriété avant de // bloquer l'ajout d'autres propriétés -Object.preventExtensions(obj);</pre> +Object.preventExtensions(obj); +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("Object.preventExtensions()")}}</li> -</ul> +- {{jsxref("Object.preventExtensions()")}} diff --git a/files/fr/web/javascript/reference/errors/cant_delete/index.md b/files/fr/web/javascript/reference/errors/cant_delete/index.md index 7ec2b3bac8..c2e807eecf 100644 --- a/files/fr/web/javascript/reference/errors/cant_delete/index.md +++ b/files/fr/web/javascript/reference/errors/cant_delete/index.md @@ -9,30 +9,30 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Cant_delete original_slug: Web/JavaScript/Reference/Erreurs/Cant_delete --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: Calling delete on 'x' is not allowed in strict mode (Edge) -TypeError: property "x" is non-configurable and can't be deleted. (Firefox) -TypeError: Cannot delete property 'x' of #<Object> (Chrome) -</pre> + TypeError: Calling delete on 'x' is not allowed in strict mode (Edge) + TypeError: property "x" is non-configurable and can't be deleted. (Firefox) + TypeError: Cannot delete property 'x' of #<Object> (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}} in strict mode only.</p> +{{jsxref("TypeError")}} in strict mode only. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Une instruction demande la suppression d'une propriété <a href="/fr/docs/Web/JavaScript/Structures_de_données#Propriétés">non-configurable</a>. L'attribut <code>configurable</code> permet de contrôler si la propriété peut être supprimée de l'objet auquel elle est rattachée et si ces attributs (en dehors de <code>writable</code>) peuvent être modifiés.</p> +Une instruction demande la suppression d'une propriété [non-configurable](/fr/docs/Web/JavaScript/Structures_de_données#Propriétés). L'attribut `configurable` permet de contrôler si la propriété peut être supprimée de l'objet auquel elle est rattachée et si ces attributs (en dehors de `writable`) peuvent être modifiés. -<p>Cette erreur ne se produit qu'en <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>. En mode non-strict, l'opération de suppression renverra <code>false</code>.</p> +Cette erreur ne se produit qu'en [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode). En mode non-strict, l'opération de suppression renverra `false`. -<h2 id="Exemples">Exemples</h2> +## Exemples -<p>Les propriétés non-configurables ne sont pas très fréquentes mais il est possible d'en créer grâce à {{jsxref("Object.defineProperty()")}} ou à {{jsxref("Object.freeze()")}}.</p> +Les propriétés non-configurables ne sont pas très fréquentes mais il est possible d'en créer grâce à {{jsxref("Object.defineProperty()")}} ou à {{jsxref("Object.freeze()")}}. -<pre class="brush: js example-bad">"use strict"; +```js example-bad +"use strict"; var obj = Object.freeze({name: "Elsa", score: 157}); delete obj.score; // TypeError @@ -44,17 +44,17 @@ delete obj.toto; // TypeError "use strict"; var frozenArray = Object.freeze([0, 1, 2]); frozenArray.pop(); // TypeError -</pre> +``` -<p>Certaines propriétés natives de JavaScript sont non-configurables. Peut-être que le code tente de supprimer une constante mathématique :</p> +Certaines propriétés natives de JavaScript sont non-configurables. Peut-être que le code tente de supprimer une constante mathématique : -<pre class="brush: js example-bad">"use strict"; -delete Math.PI; // TypeError</pre> +```js example-bad +"use strict"; +delete Math.PI; // TypeError +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete">L'opérateur <code>delete</code></a></li> - <li>{{jsxref("Object.defineProperty()")}}</li> - <li>{{jsxref("Object.freeze()")}}</li> -</ul> +- [L'opérateur `delete`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete) +- {{jsxref("Object.defineProperty()")}} +- {{jsxref("Object.freeze()")}} diff --git a/files/fr/web/javascript/reference/errors/cant_redefine_property/index.md b/files/fr/web/javascript/reference/errors/cant_redefine_property/index.md index 5311f957a5..0c445fd4a6 100644 --- a/files/fr/web/javascript/reference/errors/cant_redefine_property/index.md +++ b/files/fr/web/javascript/reference/errors/cant_redefine_property/index.md @@ -8,45 +8,45 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Cant_redefine_property original_slug: Web/JavaScript/Reference/Erreurs/Cant_redefine_property --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: Cannot modify non-writable property {x} (Edge) -TypeError: can't redefine non-configurable property "x" (Firefox) -TypeError: Cannot redefine property: "x" (Chrome) -</pre> + TypeError: Cannot modify non-writable property {x} (Edge) + TypeError: can't redefine non-configurable property "x" (Firefox) + TypeError: Cannot redefine property: "x" (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}</p> +{{jsxref("TypeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>On essaie de redéfinir une propriété alors que celle-ci est <a href="/fr/docs/Web/JavaScript/Structures_de_données#Propriétés">non-configurable</a>. L'attribut <code>configurable</code> permet d'indiquer si la propriété peut être supprimée d'un objet et si ses attributs (en dehors de <code>writable</code>) peuvent être modifiés. Généralement, les propriétés d'un objet créées avec un <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet">initialisateur d'objet</a> sont configurables. Cependant, lorsqu'on utilise la méthode {{jsxref("Object.defineProperty()")}}, la propriété n'est pas configurable par défaut.</p> +On essaie de redéfinir une propriété alors que celle-ci est [non-configurable](/fr/docs/Web/JavaScript/Structures_de_données#Propriétés). L'attribut `configurable` permet d'indiquer si la propriété peut être supprimée d'un objet et si ses attributs (en dehors de `writable`) peuvent être modifiés. Généralement, les propriétés d'un objet créées avec un [initialisateur d'objet](/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet) sont configurables. Cependant, lorsqu'on utilise la méthode {{jsxref("Object.defineProperty()")}}, la propriété n'est pas configurable par défaut. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Propriétés_non-configurables_créées_avec_Object.defineProperty()">Propriétés non-configurables créées avec <code>Object.defineProperty()</code></h3> +### Propriétés non-configurables créées avec `Object.defineProperty()` -<p>La méthode {{jsxref("Object.defineProperty()")}} crée des propriétés non-configurables si on n'indique pas le contraire :</p> +La méthode {{jsxref("Object.defineProperty()")}} crée des propriétés non-configurables si on n'indique pas le contraire : -<pre class="brush: js example-bad">var obj = Object.create({}); +```js example-bad +var obj = Object.create({}); Object.defineProperty(obj, "toto", {value: "machin"}); Object.defineProperty(obj, "toto", {value: "bidule"}); // TypeError: can't redefine non-configurable property "toto" -</pre> +``` -<p>Si on veut pouvoir redéfinir la propriété "toto" dans la suite du code, il faudra la créer comme étant configurable.</p> +Si on veut pouvoir redéfinir la propriété "toto" dans la suite du code, il faudra la créer comme étant configurable. -<pre class="brush: js example-good">var obj = Object.create({}); +```js example-good +var obj = Object.create({}); Object.defineProperty(obj, "toto", {value: "machin", configurable: true}); -Object.defineProperty(obj, "toto", {value: "bidule", configurable: true});</pre> +Object.defineProperty(obj, "toto", {value: "bidule", configurable: true}); +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Structures_de_données#Propriétés">[[Configurable]]</a></li> - <li>{{jsxref("Object.defineProperty()")}}</li> -</ul> +- [\[\[Configurable\]\]](/fr/docs/Web/JavaScript/Structures_de_données#Propriétés) +- {{jsxref("Object.defineProperty()")}} diff --git a/files/fr/web/javascript/reference/errors/cyclic_object_value/index.md b/files/fr/web/javascript/reference/errors/cyclic_object_value/index.md index aa50f933f9..58de02ab6d 100644 --- a/files/fr/web/javascript/reference/errors/cyclic_object_value/index.md +++ b/files/fr/web/javascript/reference/errors/cyclic_object_value/index.md @@ -8,45 +8,47 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Cyclic_object_value original_slug: Web/JavaScript/Reference/Erreurs/Cyclic_object_value --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: cyclic object value (Firefox) -TypeError: Converting circular structure to JSON (Chrome and Opera) -TypeError: Circular reference in value argument not supported (Edge) -</pre> + TypeError: cyclic object value (Firefox) + TypeError: Converting circular structure to JSON (Chrome and Opera) + TypeError: Circular reference in value argument not supported (Edge) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}</p> +{{jsxref("TypeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Lorsqu'on appelle la méthode {{jsxref("JSON.stringify()")}}, les structures de références cycliques ne peuvent pas être converties en chaîne de caractères car <a href="https://www.json.org/">le format JSON</a> ne prend pas en charge les références (bien qu'<a href="http://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03">un brouillon IETF existe</a>).</p> +Lorsqu'on appelle la méthode {{jsxref("JSON.stringify()")}}, les structures de références cycliques ne peuvent pas être converties en chaîne de caractères car [le format JSON](https://www.json.org/) ne prend pas en charge les références (bien qu'[un brouillon IETF existe](http://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03)). -<h2 id="Exemples">Exemples</h2> +## Exemples -<p>Avec une structure circulaire comme la suivante :</p> +Avec une structure circulaire comme la suivante : -<pre class="brush: js">var a = {}; +```js +var a = {}; var b = {}; a.child = b; b.child = a; -</pre> +``` -<p>{{jsxref("JSON.stringify()")}} échouera :</p> +{{jsxref("JSON.stringify()")}} échouera : -<pre class="brush: js example-bad">JSON.stringify(a); +```js example-bad +JSON.stringify(a); // TypeError: cyclic object value -</pre> +``` -<p>Il est nécessaire de contrôler l'existence de cycles avant la conversion en chaîne de caractères. On peut par exemple fournir une fonction de remplacement comme deuxième argument de la fonction {{jsxref("JSON.stringify()")}}.</p> +Il est nécessaire de contrôler l'existence de cycles avant la conversion en chaîne de caractères. On peut par exemple fournir une fonction de remplacement comme deuxième argument de la fonction {{jsxref("JSON.stringify()")}}. -<pre class="brush: js">const getCircularReplacer = () => { +```js +const getCircularReplacer = () => { const seen = new WeakSet(); - return (key, value) => { - if (typeof value === "object" && value !== null) { + return (key, value) => { + if (typeof value === "object" && value !== null) { if (seen.has(value)) { return; } @@ -57,13 +59,12 @@ b.child = a; }; JSON.stringify(circularReference, getCircularReplacer()); -// {"otherData":123}</pre> +// {"otherData":123} +``` -<p>On peut également utiliser une bibliothèque ou une fonction utilitaire pour ce scénario. comme <a href="https://github.com/douglascrockford/JSON-js/blob/master/cycle.js">cycle.js</a>.</p> +On peut également utiliser une bibliothèque ou une fonction utilitaire pour ce scénario. comme [cycle.js](https://github.com/douglascrockford/JSON-js/blob/master/cycle.js). -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("JSON.stringify")}}</li> - <li><a href="https://github.com/douglascrockford/JSON-js/blob/master/cycle.js">cycle.js</a> qui introduit deux fonctions : <code>JSON.decycle</code> <code>et JSON.retrocycle</code> qui permettent d'encoder et de décoder des structures cycliques en JSON.</li> -</ul> +- {{jsxref("JSON.stringify")}} +- [cycle.js](https://github.com/douglascrockford/JSON-js/blob/master/cycle.js) qui introduit deux fonctions : `JSON.decycle` `et JSON.retrocycle` qui permettent d'encoder et de décoder des structures cycliques en JSON. diff --git a/files/fr/web/javascript/reference/errors/dead_object/index.md b/files/fr/web/javascript/reference/errors/dead_object/index.md index ba4498fd26..0f65953ae7 100644 --- a/files/fr/web/javascript/reference/errors/dead_object/index.md +++ b/files/fr/web/javascript/reference/errors/dead_object/index.md @@ -8,43 +8,44 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Dead_object original_slug: Web/JavaScript/Reference/Erreurs/Dead_object --- -<div>{{JSSidebar("Errors")}}</div> +{{JSSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: can't access dead object -</pre> + TypeError: can't access dead object -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}</p> +{{jsxref("TypeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Afin d'améliorer l'utilisation de la mémoire et de prévenir les fuites mémoire, Firefox empêche les modules complémentaires de conserver des références fortes vers les objets du DOM après que leur document parent a été détruit. Un objet mort (<em>dead</em>) est un objet qui contient une référence forte vers un éléments du DOM, même après que celui-ci a été détruit dans le DOM. Pour éviter ces problèmes, les références aux objets du DOM d'un document étranger devraient être enregistrées dans un objet spécifique à ce document et être nettoyées lors de la suppression du document. On peut également utiliser les objets qui permettent d'enregistrer <a href="/fr/docs/Mozilla/Tech/XPCOM/Language_Bindings/Components.utils.getWeakReference">des références faibles</a>.</p> +Afin d'améliorer l'utilisation de la mémoire et de prévenir les fuites mémoire, Firefox empêche les modules complémentaires de conserver des références fortes vers les objets du DOM après que leur document parent a été détruit. Un objet mort (_dead_) est un objet qui contient une référence forte vers un éléments du DOM, même après que celui-ci a été détruit dans le DOM. Pour éviter ces problèmes, les références aux objets du DOM d'un document étranger devraient être enregistrées dans un objet spécifique à ce document et être nettoyées lors de la suppression du document. On peut également utiliser les objets qui permettent d'enregistrer [des références faibles](/fr/docs/Mozilla/Tech/XPCOM/Language_Bindings/Components.utils.getWeakReference). -<h2 id="Vérifier_si_un_objet_est_mort">Vérifier si un objet est mort</h2> +## Vérifier si un objet est mort -<p><code><a href="/fr/docs/Components.utils">Components.utils</a></code> fournit une méthode <code>isDeadWrapper()</code> qui peut être utilisée par du code privilégié :</p> +[`Components.utils`](/fr/docs/Components.utils) fournit une méthode `isDeadWrapper()` qui peut être utilisée par du code privilégié : -<pre class="brush: js">if (Components.utils.isDeadWrapper(window)) { +```js +if (Components.utils.isDeadWrapper(window)) { // dead -}</pre> +} +``` -<p>Du code sans privilège ne pourra pas accéder à <code>Component.utils</code> et pourra simplement intercepter l'exception :</p> +Du code sans privilège ne pourra pas accéder à `Component.utils` et pourra simplement intercepter l'exception : -<pre class="brush: js">try { +```js +try { String(window); } catch (e) { console.log("window est problablement mort "); -}</pre> +} +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="https://blog.mozilla.org/addons/2012/09/12/what-does-cant-access-dead-object-mean/">Que signifie “can’t access dead object” ? (en anglais)</a></li> - <li><a href="/fr/docs/Extensions/Common_causes_of_memory_leaks_in_extensions">Les causes principales des fuites mémoire dans les extensions</a></li> - <li><code><a href="/fr/docs/Components.utils">Components.utils</a></code></li> - <li><a href="/en-US/docs/Mozilla/Zombie_compartments#Zombie_compartments">Compartiments zombies</a></li> -</ul> +- [Que signifie “can’t access dead object” ? (en anglais)](https://blog.mozilla.org/addons/2012/09/12/what-does-cant-access-dead-object-mean/) +- [Les causes principales des fuites mémoire dans les extensions](/fr/docs/Extensions/Common_causes_of_memory_leaks_in_extensions) +- [`Components.utils`](/fr/docs/Components.utils) +- [Compartiments zombies](/en-US/docs/Mozilla/Zombie_compartments#Zombie_compartments) diff --git a/files/fr/web/javascript/reference/errors/delete_in_strict_mode/index.md b/files/fr/web/javascript/reference/errors/delete_in_strict_mode/index.md index 4451a729be..19d3f9b747 100644 --- a/files/fr/web/javascript/reference/errors/delete_in_strict_mode/index.md +++ b/files/fr/web/javascript/reference/errors/delete_in_strict_mode/index.md @@ -10,34 +10,34 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Delete_in_strict_mode original_slug: Web/JavaScript/Reference/Erreurs/Delete_in_strict_mode --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: Calling delete on expression not allowed in strict mode (Edge) -SyntaxError: applying the 'delete' operator to an unqualified name is deprecated (Firefox) -SyntaxError: Delete of an unqualified identifier in strict mode. (Chrome) -</pre> + SyntaxError: Calling delete on expression not allowed in strict mode (Edge) + SyntaxError: applying the 'delete' operator to an unqualified name is deprecated (Firefox) + SyntaxError: Delete of an unqualified identifier in strict mode. (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}, uniquement en <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>.</p> +{{jsxref("SyntaxError")}}, uniquement en [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode). -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Les variables JavaScript ne peuvent pas être supprimées grâce à l'opérateur <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete">delete</a></code>. En mode strict, toute tentative de suppression d'une variable lèvera une exception.</p> +Les variables JavaScript ne peuvent pas être supprimées grâce à l'opérateur [`delete`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete). En mode strict, toute tentative de suppression d'une variable lèvera une exception. -<p>L'opérateur <code>delete</code> sert uniquement à supprimer des propriétés sur un objet. Les propriétés d'un objet sont « qualifiées » si elles sont configurables.</p> +L'opérateur `delete` sert uniquement à supprimer des propriétés sur un objet. Les propriétés d'un objet sont « qualifiées » si elles sont configurables. -<p>Contrairement à ce qu'on pourrait penser, l'opérateur <code>delete</code> n'a rien à voir avec la libération de la mémoire. La gestion de la mémoire se fait indirectement en cassant les références utilisées. Pour plus d'informations, consulter les pages sur <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete">delete</a></code> et <a href="/fr/docs/Web/JavaScript/Gestion_de_la_mémoire">la gestion de la mémoire en JavaScript</a>.</p> +Contrairement à ce qu'on pourrait penser, l'opérateur `delete` n'a rien à voir avec la libération de la mémoire. La gestion de la mémoire se fait indirectement en cassant les références utilisées. Pour plus d'informations, consulter les pages sur [`delete`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete) et [la gestion de la mémoire en JavaScript](/fr/docs/Web/JavaScript/Gestion_de_la_mémoire). -<p>Cette erreur ne se produit qu'en <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>. En mode non-strict, l'opération renvoie simplement <code>false</code>.</p> +Cette erreur ne se produit qu'en [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode). En mode non-strict, l'opération renvoie simplement `false`. -<h2 id="Exemples">Exemples</h2> +## Exemples -<p>Essayer de supprimer une variable normale avec <code>delete</code> ne fonctionne pas, voire lève une exception en mode strict :</p> +Essayer de supprimer une variable normale avec `delete` ne fonctionne pas, voire lève une exception en mode strict : -<pre class="brush: js example-bad">'use strict'; +```js example-bad +'use strict'; var x; @@ -47,23 +47,22 @@ delete x; // SyntaxError: applying the 'delete' operator to // an unqualified name is deprecated -</pre> +``` -<p>Pour libérer le contenu d'une variable, on peut la passer à {{jsxref("null")}} :</p> +Pour libérer le contenu d'une variable, on peut la passer à {{jsxref("null")}} : -<pre class="brush: js example-good">'use strict'; +```js example-good +'use strict'; var x; // ... x = null; // x peut être ramassée par le ramasse-miettes -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete">delete</a></code></li> - <li><a href="/fr/docs/Web/JavaScript/Gestion_de_la_mémoire">La gestion de la mémoire en JavaScript</a></li> - <li><a href="/en-US/docs/Web/JavaScript/Reference/Errors/Cant_delete">TypeError: property "x" is non-configurable and can't be deleted</a></li> -</ul> +- [`delete`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_delete) +- [La gestion de la mémoire en JavaScript](/fr/docs/Web/JavaScript/Gestion_de_la_mémoire) +- [TypeError: property "x" is non-configurable and can't be deleted](/en-US/docs/Web/JavaScript/Reference/Errors/Cant_delete) diff --git a/files/fr/web/javascript/reference/errors/deprecated_caller_or_arguments_usage/index.md b/files/fr/web/javascript/reference/errors/deprecated_caller_or_arguments_usage/index.md index 669f4903a9..d9aba3fe1e 100644 --- a/files/fr/web/javascript/reference/errors/deprecated_caller_or_arguments_usage/index.md +++ b/files/fr/web/javascript/reference/errors/deprecated_caller_or_arguments_usage/index.md @@ -8,31 +8,31 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Deprecated_caller_or_arguments_usage original_slug: Web/JavaScript/Reference/Erreurs/Deprecated_caller_or_arguments_usage --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: 'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context (Edge) -Warning: ReferenceError: deprecated caller usage (Firefox) -Warning: ReferenceError: deprecated arguments usage (Firefox) -TypeError: 'callee' and 'caller' cannot be accessed in strict mode. (Safari) -</pre> + TypeError: 'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context (Edge) + Warning: ReferenceError: deprecated caller usage (Firefox) + Warning: ReferenceError: deprecated arguments usage (Firefox) + TypeError: 'callee' and 'caller' cannot be accessed in strict mode. (Safari) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>Un avertissement uniquement affiché en mode strict qui prend la forme d'une {{jsxref("ReferenceError")}}. L'exécution du script JavaScript n'est pas interrompue.</p> +Un avertissement uniquement affiché en mode strict qui prend la forme d'une {{jsxref("ReferenceError")}}. L'exécution du script JavaScript n'est pas interrompue. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p><a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">En mode strict</a>, les propriétés {{jsxref("Function.caller")}} et/ou {{jsxref("Function.arguments")}} sont utilisées alors qu'elles ne devraient pas l'être. Ces propriétés sont dépréciées car elles font fuiter des informations sur l'appelant de la fonction et ne sont pas standards. De plus, ces propriétés rendent certaines optimisations plus complexe et peuvent nuire aux performances.</p> +[En mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode), les propriétés {{jsxref("Function.caller")}} et/ou {{jsxref("Function.arguments")}} sont utilisées alors qu'elles ne devraient pas l'être. Ces propriétés sont dépréciées car elles font fuiter des informations sur l'appelant de la fonction et ne sont pas standards. De plus, ces propriétés rendent certaines optimisations plus complexe et peuvent nuire aux performances. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Utilisation_de_function.caller_ou_de_arguments.callee.caller">Utilisation de <code>function.caller</code> ou de <code>arguments.callee.caller</code></h3> +### Utilisation de `function.caller` ou de `arguments.callee.caller` -<p>{{jsxref("Function.caller")}} et <code><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/arguments/callee">arguments.callee.caller</a></code> sont dépréciées (se référer aux articles de la référence pour plus d'informations).</p> +{{jsxref("Function.caller")}} et [`arguments.callee.caller`](/fr/docs/Web/JavaScript/Reference/Fonctions/arguments/callee) sont dépréciées (se référer aux articles de la référence pour plus d'informations). -<pre class="brush: js example-bad">"use strict"; +```js example-bad +"use strict"; function myFunc() { if (myFunc.caller == null) { @@ -44,19 +44,21 @@ function myFunc() { myFunc(); // Warning: ReferenceError: deprecated caller usage -// "La fonction a été appelée depuis la portée globale !"</pre> +// "La fonction a été appelée depuis la portée globale !" +``` -<h3 id="Function.arguments"><code>Function.arguments</code></h3> +### `Function.arguments` -<p>{{jsxref("Function.arguments")}} est dépréciée (se référer à l'article sur cette propriété pour plus d'informations).</p> +{{jsxref("Function.arguments")}} est dépréciée (se référer à l'article sur cette propriété pour plus d'informations). -<pre class="brush: js example-bad">"use strict"; +```js example-bad +"use strict"; function f(n) { g(n - 1); } function g(n) { console.log('before: ' + g.arguments[0]); - if (n > 0) { f(n); } + if (n > 0) { f(n); } console.log('after: ' + g.arguments[0]); } @@ -64,13 +66,11 @@ f(2); console.log('returned: ' + g.arguments); // Warning: ReferenceError: deprecated arguments usage -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/JavaScript/Reference/Annexes/Fonctionnalités_dépréciées">Les fonctionnalités obsolètes et dépréciées</a></li> - <li><a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">Le mode strict</a></li> - <li>{{jsxref("Function.arguments")}}</li> - <li>{{jsxref("Function.caller")}} and <code><a href="/fr/docs/Web/JavaScript/Reference/Functions/arguments/callee">arguments.callee.caller</a></code></li> -</ul> +- [Les fonctionnalités obsolètes et dépréciées](/fr/docs/JavaScript/Reference/Annexes/Fonctionnalités_dépréciées) +- [Le mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode) +- {{jsxref("Function.arguments")}} +- {{jsxref("Function.caller")}} and [`arguments.callee.caller`](/fr/docs/Web/JavaScript/Reference/Functions/arguments/callee) diff --git a/files/fr/web/javascript/reference/errors/deprecated_expression_closures/index.md b/files/fr/web/javascript/reference/errors/deprecated_expression_closures/index.md index 5cd6889b74..8f709e61a9 100644 --- a/files/fr/web/javascript/reference/errors/deprecated_expression_closures/index.md +++ b/files/fr/web/javascript/reference/errors/deprecated_expression_closures/index.md @@ -8,73 +8,76 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Deprecated_expression_closures original_slug: Web/JavaScript/Reference/Erreurs/Deprecated_expression_closures --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">Warning: expression closures are deprecated -</pre> + Warning: expression closures are deprecated -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>Un avertissement, l'exécution du code JavaScript ne sera pas interrompue.</p> +Un avertissement, l'exécution du code JavaScript ne sera pas interrompue. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>La syntaxe non-standard avec <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Expression_closures">une expression de fermeture</a> est dépréciée et ne devrait plus être utilisée. Cette syntaxe sera complètement retirée avec le bug {{bug(1083458)}} et les scripts qui l'utilisent déclencheront alors une exception {{jsxref("SyntaxError")}}.</p> +La syntaxe non-standard avec [une expression de fermeture](/fr/docs/Web/JavaScript/Reference/Opérateurs/Expression_closures) est dépréciée et ne devrait plus être utilisée. Cette syntaxe sera complètement retirée avec le bug {{bug(1083458)}} et les scripts qui l'utilisent déclencheront alors une exception {{jsxref("SyntaxError")}}. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Syntaxe_dépréciée">Syntaxe dépréciée</h3> +### Syntaxe dépréciée -<p>Les expression de fermeture permettent de ne pas utiliser les accolades ou les instructions <code>return</code> au sein d'une déclaration de fonction ou pour une définition de méthode dans un objet.</p> +Les expression de fermeture permettent de ne pas utiliser les accolades ou les instructions `return` au sein d'une déclaration de fonction ou pour une définition de méthode dans un objet. -<pre class="brush: js example-bad">var x = function() 1; +```js example-bad +var x = function() 1; var obj = { count: function() 1 }; -</pre> +``` -<h3 id="Syntaxe_standard">Syntaxe standard</h3> +### Syntaxe standard -<p>Pour convertir cette syntaxe non-standard en une syntaxe standard, il suffit d'ajouter des accolades et l'instruction return.</p> +Pour convertir cette syntaxe non-standard en une syntaxe standard, il suffit d'ajouter des accolades et l'instruction return. -<pre class="brush: js example-good">var x = function() { return 1; } +```js example-good +var x = function() { return 1; } var obj = { count: function() { return 1; } }; -</pre> +``` -<h3 id="Syntaxe_standard_avec_les_fonctions_fléchées">Syntaxe standard avec les fonctions fléchées</h3> +### Syntaxe standard avec les fonctions fléchées -<p>On peut aussi utiliser <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées">les fonctions fléchées</a> :</p> +On peut aussi utiliser [les fonctions fléchées](/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées) : -<pre class="brush: js example-good">var x = () => 1;</pre> +```js example-good +var x = () => 1; +``` -<h3 id="Syntaxe_standard_avec_la_notation_raccourcie_pour_les_méthodes">Syntaxe standard avec la notation raccourcie pour les méthodes</h3> +### Syntaxe standard avec la notation raccourcie pour les méthodes -<p>On retrouve parfois les expressions de fermeture dans les accesseurs et les mutateurs, par exemple :</p> +On retrouve parfois les expressions de fermeture dans les accesseurs et les mutateurs, par exemple : -<pre class="brush: js example-bad">var obj = { +```js example-bad +var obj = { get x() 1, set x(v) this.v = v }; -</pre> +``` -<p>Grâce aux <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Définition_de_méthode">définitions de méthodes</a> ES2015, on peut convertir le fragment de code précédent en :</p> +Grâce aux [définitions de méthodes](/fr/docs/Web/JavaScript/Reference/Fonctions/Définition_de_méthode) ES2015, on peut convertir le fragment de code précédent en : -<pre class="brush: js example-good">var obj = { +```js example-good +var obj = { get x() { return 1 }, set x(v) { this.v = v } }; -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Expression_closures">Les expressions de fermeture</a></li> - <li><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées">Les fonctions fléchées</a></li> - <li><a href="/fr/docs/Web/JavaScript/Reference/Fonctions/Définition_de_méthode">Les définitions de méthode</a></li> -</ul> +- [Les expressions de fermeture](/fr/docs/Web/JavaScript/Reference/Opérateurs/Expression_closures) +- [Les fonctions fléchées](/fr/docs/Web/JavaScript/Reference/Fonctions/Fonctions_fléchées) +- [Les définitions de méthode](/fr/docs/Web/JavaScript/Reference/Fonctions/Définition_de_méthode) diff --git a/files/fr/web/javascript/reference/errors/deprecated_octal/index.md b/files/fr/web/javascript/reference/errors/deprecated_octal/index.md index 067c0a363a..9b9b9c92f6 100644 --- a/files/fr/web/javascript/reference/errors/deprecated_octal/index.md +++ b/files/fr/web/javascript/reference/errors/deprecated_octal/index.md @@ -9,61 +9,62 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Deprecated_octal original_slug: Web/JavaScript/Reference/Erreurs/Deprecated_octal --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: Octal numeric literals and escape characters not allowed in strict mode (Edge) -SyntaxError: -"0"-prefixed octal literals and octal escape sequences are deprecated; -for octal literals use the "0o" prefix instead -</pre> + SyntaxError: Octal numeric literals and escape characters not allowed in strict mode (Edge) + SyntaxError: + "0"-prefixed octal literals and octal escape sequences are deprecated; + for octal literals use the "0o" prefix instead -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}, uniquement en <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>.</p> +{{jsxref("SyntaxError")}}, uniquement en [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode). -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Les littéraux en base octale et les séquences d'échappement octales sont dépréciées et lèvent une exception {{jsxref("SyntaxError")}} en mode strict. À partir d'ECMAScript 2015, la syntaxe standard utilise un zéro suivi de la lettre « o » (en minuscule ou en majuscule) (<code>0o</code> or <code>0O)</code>.</p> +Les littéraux en base octale et les séquences d'échappement octales sont dépréciées et lèvent une exception {{jsxref("SyntaxError")}} en mode strict. À partir d'ECMAScript 2015, la syntaxe standard utilise un zéro suivi de la lettre « o » (en minuscule ou en majuscule) (`0o` or `0O)`. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Littéraux_en_base_octale_préfixés_par_0">Littéraux en base octale préfixés par 0</h3> +### Littéraux en base octale préfixés par 0 -<pre class="brush: js example-bad">"use strict"; +```js example-bad +"use strict"; 03; // SyntaxError: "0"-prefixed octal literals and octal escape sequences -// are deprecated</pre> +// are deprecated +``` -<h3 id="Séquences_d'échappement_en_base_octale">Séquences d'échappement en base octale</h3> +### Séquences d'échappement en base octale -<pre class="brush: js example-bad">"use strict"; +```js example-bad +"use strict"; "\251"; // SyntaxError: "0"-prefixed octal literals and octal escape sequences // are deprecated -</pre> +``` -<h3 id="Littéraux_valides">Littéraux valides</h3> +### Littéraux valides -<p>Pour former un littéral en base octal, on pourra utiliser un zéro suivi de la lettre « o » :</p> +Pour former un littéral en base octal, on pourra utiliser un zéro suivi de la lettre « o » : -<pre class="brush: js example-good">0o3; -</pre> +```js example-good +0o3; +``` -<p>Pour former une séquence d'échappement en base octale, on écrira une séquence d'échappement en base hexadécimale :</p> +Pour former une séquence d'échappement en base octale, on écrira une séquence d'échappement en base hexadécimale : -<pre class="brush: js example-good">'\xA9';</pre> +```js example-good +'\xA9'; +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Octaux">La grammaire lexicale JavaScript</a></li> - <li> - <p><a href="/fr/docs/Web/JavaScript/Reference/Erreurs/Bad_octal">Warning: 08/09 is not a legal ECMA-262 octal constant</a></p> - </li> -</ul> +- [La grammaire lexicale JavaScript](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Octaux) +- [Warning: 08/09 is not a legal ECMA-262 octal constant](/fr/docs/Web/JavaScript/Reference/Erreurs/Bad_octal) diff --git a/files/fr/web/javascript/reference/errors/deprecated_source_map_pragma/index.md b/files/fr/web/javascript/reference/errors/deprecated_source_map_pragma/index.md index 8d36de23af..f08481d96a 100644 --- a/files/fr/web/javascript/reference/errors/deprecated_source_map_pragma/index.md +++ b/files/fr/web/javascript/reference/errors/deprecated_source_map_pragma/index.md @@ -10,50 +10,52 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Deprecated_source_map_pragma original_slug: Web/JavaScript/Reference/Erreurs/Deprecated_source_map_pragma --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">Warning: SyntaxError: Using //@ to indicate sourceURL pragmas is deprecated. Use //# instead + Warning: SyntaxError: Using //@ to indicate sourceURL pragmas is deprecated. Use //# instead -Warning: SyntaxError: Using //@ to indicate sourceMappingURL pragmas is deprecated. Use //# instead -</pre> + Warning: SyntaxError: Using //@ to indicate sourceMappingURL pragmas is deprecated. Use //# instead -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>Un avertissement prenant la forme d'une exception {{jsxref("SyntaxError")}}. L'exécution du code JavaScript n'est pas interrompue.</p> +Un avertissement prenant la forme d'une exception {{jsxref("SyntaxError")}}. L'exécution du code JavaScript n'est pas interrompue. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Une syntaxe dépréciée a été utilisée pour indiquer une correspondance de source (<em>source map</em>) dans le code JavaScript.</p> +Une syntaxe dépréciée a été utilisée pour indiquer une correspondance de source (_source map_) dans le code JavaScript. -<p>Il arrive souvent que les fichiers sources JavaScript soient combinés et minifiés afin que le transfert depuis le serveur vers le client soit plus efficace. Grâce <a href="http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/">aux correspondances de source (ou <em>source maps</em>)</a>, le débogueur peut utiliser les sources des fichiers correspondants aux fichiers minifiés.</p> +Il arrive souvent que les fichiers sources JavaScript soient combinés et minifiés afin que le transfert depuis le serveur vers le client soit plus efficace. Grâce [aux correspondances de source (ou _source maps_)](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/), le débogueur peut utiliser les sources des fichiers correspondants aux fichiers minifiés. -<p>La spécification sur cet outil a évolué car il existait un conflit de syntaxe avec IE (après <code>//@cc_on</code>, la correspondance était interprétée comme un test conditionnel de compilation du moteur JScript).<a href="https://msdn.microsoft.com/en-us/library/8ka90k2e%28v=vs.94%29.aspx"> Ce commentaire de compilation conditionnelle</a> pour IE est peu connu mais son existence entraînait des erreurs avec <a href="https://bugs.jquery.com/ticket/13274">jQuery</a> et d'autres bibliothèques.</p> +La spécification sur cet outil a évolué car il existait un conflit de syntaxe avec IE (après `//@cc_on`, la correspondance était interprétée comme un test conditionnel de compilation du moteur JScript).[ Ce commentaire de compilation conditionnelle](https://msdn.microsoft.com/en-us/library/8ka90k2e%28v=vs.94%29.aspx) pour IE est peu connu mais son existence entraînait des erreurs avec [jQuery](https://bugs.jquery.com/ticket/13274) et d'autres bibliothèques. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Syntaxe_dépréciée">Syntaxe dépréciée</h3> +### Syntaxe dépréciée -<p>La syntaxe utilisant l'arobase (@) est dépréciée :</p> +La syntaxe utilisant l'arobase (@) est dépréciée : -<pre class="brush: js example-bad">//@ sourceMappingURL=http://exemple.com/chemin/vers/la/sourcemap.map -</pre> +```js example-bad +//@ sourceMappingURL=http://exemple.com/chemin/vers/la/sourcemap.map +``` -<h3 id="Syntaxe_standard">Syntaxe standard</h3> +### Syntaxe standard -<p>Il faut utiliser le dièse (#) :</p> +Il faut utiliser le dièse (#) : -<pre class="brush: js example-good">//# sourceMappingURL=http://exemple.com/chemin/vers/la/sourcemap.map</pre> +```js example-good +//# sourceMappingURL=http://exemple.com/chemin/vers/la/sourcemap.map +``` -<p>Autrement, on peut indiquer la correspondance dans un en-tête {{HTTPHeader("SourceMap")}} pour servir le fichier JavaScript afin d'éviter tout commentaire :</p> +Autrement, on peut indiquer la correspondance dans un en-tête {{HTTPHeader("SourceMap")}} pour servir le fichier JavaScript afin d'éviter tout commentaire : -<pre class="brush: js example-good">X-SourceMap: /path/to/file.js.map</pre> +```js example-good +X-SourceMap: /path/to/file.js.map +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Outils/Débogueur/Comment/Utiliser_une_source_map">Comment utiliser les <em>source map</em> – Documentation des outils Firefox</a></li> - <li><a href="http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/">Introduction to source maps – HTML5 rocks</a></li> - <li>{{HTTPHeader("SourceMap")}}</li> -</ul> +- [Comment utiliser les _source map_ – Documentation des outils Firefox](/fr/docs/Outils/Débogueur/Comment/Utiliser_une_source_map) +- [Introduction to source maps – HTML5 rocks](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/) +- {{HTTPHeader("SourceMap")}} diff --git a/files/fr/web/javascript/reference/errors/deprecated_string_generics/index.md b/files/fr/web/javascript/reference/errors/deprecated_string_generics/index.md index f348c0b4d8..fa9305c553 100644 --- a/files/fr/web/javascript/reference/errors/deprecated_string_generics/index.md +++ b/files/fr/web/javascript/reference/errors/deprecated_string_generics/index.md @@ -8,65 +8,66 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Deprecated_String_generics original_slug: Web/JavaScript/Reference/Erreurs/Deprecated_String_generics --- -<div>{{jsSidebar("Errors")}}</div> - -<div>Les méthodes génériques pour les chaînes de caractères ont été retirées à partir de Firefox 68.</div> - -<h2 id="Message">Message</h2> - -<pre class="syntaxbox">Warning: String.charAt is deprecated; use String.prototype.charAt instead -Warning: String.charCodeAt is deprecated; use String.prototype.charCodeAt instead -Warning: String.concat is deprecated; use String.prototype.concat instead -Warning: String.contains is deprecated; use String.prototype.contains instead -Warning: String.endsWith is deprecated; use String.prototype.endsWith instead -Warning: String.includes is deprecated; use String.prototype.includes instead -Warning: String.indexOf is deprecated; use String.prototype.indexOf instead -Warning: String.lastIndexOf is deprecated; use String.prototype.lastIndexOf instead -Warning: String.localeCompare is deprecated; use String.prototype.localeCompare instead -Warning: String.match is deprecated; use String.prototype.match instead -Warning: String.normalize is deprecated; use String.prototype.normalize instead -Warning: String.replace is deprecated; use String.prototype.replace instead -Warning: String.search is deprecated; use String.prototype.search instead -Warning: String.slice is deprecated; use String.prototype.slice instead -Warning: String.split is deprecated; use String.prototype.split instead -Warning: String.startsWith is deprecated; use String.prototype.startsWith instead -Warning: String.substr is deprecated; use String.prototype.substr instead -Warning: String.substring is deprecated; use String.prototype.substring instead -Warning: String.toLocaleLowerCase is deprecated; use String.prototype.toLocaleLowerCase instead -Warning: String.toLocaleUpperCase is deprecated; use String.prototype.toLocaleUpperCase instead -Warning: String.toLowerCase is deprecated; use String.prototype.toLowerCase instead -Warning: String.toUpperCase is deprecated; use String.prototype.toUpperCase instead -Warning: String.trim is deprecated; use String.prototype.trim instead -Warning: String.trimLeft is deprecated; use String.prototype.trimLeft instead -Warning: String.trimRight is deprecated; use String.prototype.trimRight instead -</pre> - -<h2 id="Type_d'erreur">Type d'erreur</h2> - -<p>Un avertissement, l'exécution du script n'est pas interrompue.</p> - -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> - -<p>Les méthodes génériques non-standards de {{jsxref("String")}} sont dépréciées et ont été retirées à partir de Firefox 68 (il n'y a pas de prise en charge des navigateurs en dehors de Firefox). Les méthodes génériques sont des méthodes utilisées pour manipuler les instances de ce type d'objet et qui sont disponibles sur l'objet <code>String</code>, ce qui permet de les appliquer à n'importe quel objet.</p> - -<h2 id="Exemples">Exemples</h2> - -<h3 id="Syntaxe_dépréciée">Syntaxe dépréciée</h3> - -<pre class="brush: js example-bad">var num = 15; -String.replace(num, /5/, '2');</pre> - -<h3 id="Syntaxe_standard">Syntaxe standard</h3> - -<pre class="brush: js example-good">var num = 15; +{{jsSidebar("Errors")}}Les méthodes génériques pour les chaînes de caractères ont été retirées à partir de Firefox 68. + +## Message + + Warning: String.charAt is deprecated; use String.prototype.charAt instead + Warning: String.charCodeAt is deprecated; use String.prototype.charCodeAt instead + Warning: String.concat is deprecated; use String.prototype.concat instead + Warning: String.contains is deprecated; use String.prototype.contains instead + Warning: String.endsWith is deprecated; use String.prototype.endsWith instead + Warning: String.includes is deprecated; use String.prototype.includes instead + Warning: String.indexOf is deprecated; use String.prototype.indexOf instead + Warning: String.lastIndexOf is deprecated; use String.prototype.lastIndexOf instead + Warning: String.localeCompare is deprecated; use String.prototype.localeCompare instead + Warning: String.match is deprecated; use String.prototype.match instead + Warning: String.normalize is deprecated; use String.prototype.normalize instead + Warning: String.replace is deprecated; use String.prototype.replace instead + Warning: String.search is deprecated; use String.prototype.search instead + Warning: String.slice is deprecated; use String.prototype.slice instead + Warning: String.split is deprecated; use String.prototype.split instead + Warning: String.startsWith is deprecated; use String.prototype.startsWith instead + Warning: String.substr is deprecated; use String.prototype.substr instead + Warning: String.substring is deprecated; use String.prototype.substring instead + Warning: String.toLocaleLowerCase is deprecated; use String.prototype.toLocaleLowerCase instead + Warning: String.toLocaleUpperCase is deprecated; use String.prototype.toLocaleUpperCase instead + Warning: String.toLowerCase is deprecated; use String.prototype.toLowerCase instead + Warning: String.toUpperCase is deprecated; use String.prototype.toUpperCase instead + Warning: String.trim is deprecated; use String.prototype.trim instead + Warning: String.trimLeft is deprecated; use String.prototype.trimLeft instead + Warning: String.trimRight is deprecated; use String.prototype.trimRight instead + +## Type d'erreur + +Un avertissement, l'exécution du script n'est pas interrompue. + +## Quel est le problème ? + +Les méthodes génériques non-standards de {{jsxref("String")}} sont dépréciées et ont été retirées à partir de Firefox 68 (il n'y a pas de prise en charge des navigateurs en dehors de Firefox). Les méthodes génériques sont des méthodes utilisées pour manipuler les instances de ce type d'objet et qui sont disponibles sur l'objet `String`, ce qui permet de les appliquer à n'importe quel objet. + +## Exemples + +### Syntaxe dépréciée + +```js example-bad +var num = 15; +String.replace(num, /5/, '2'); +``` + +### Syntaxe standard + +```js example-good +var num = 15; String(num).replace(/5/, '2'); -</pre> +``` -<h2 id="Shim">Shim</h2> +## Shim -<p>Voici une méthode qui permet d'avoir les méthodes génériques au sein des navigateurs qui ne les prennent pas en charge :</p> +Voici une méthode qui permet d'avoir les méthodes génériques au sein des navigateurs qui ne les prennent pas en charge : -<pre class="brush: js">/*globals define*/ +```js +/*globals define*/ // Assumes all supplied String instance methods already present // (one may use shims for these if not available) (function() { @@ -93,14 +94,13 @@ String(num).replace(/5/, '2'); }; }; - for (i = 0; i < methodCount; i++) { + for (i = 0; i < methodCount; i++) { assignStringGeneric(methods[i]); } -}());</pre> +}()); +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("String")}}</li> - <li><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array#Les_méthodes_génériques_de_manipulation_de_tableaux">Les méthodes génériques pour les tableaux</a> (également dépréciées).</li> -</ul> +- {{jsxref("String")}} +- [Les méthodes génériques pour les tableaux](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array#Les_méthodes_génériques_de_manipulation_de_tableaux) (également dépréciées). diff --git a/files/fr/web/javascript/reference/errors/deprecated_tolocaleformat/index.md b/files/fr/web/javascript/reference/errors/deprecated_tolocaleformat/index.md index 444295566c..362fb57677 100644 --- a/files/fr/web/javascript/reference/errors/deprecated_tolocaleformat/index.md +++ b/files/fr/web/javascript/reference/errors/deprecated_tolocaleformat/index.md @@ -8,85 +8,89 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Deprecated_toLocaleFormat original_slug: Web/JavaScript/Reference/Erreurs/Deprecated_toLocaleFormat --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">Warning: Date.prototype.toLocaleFormat is deprecated; consider using Intl.DateTimeFormat instead -</pre> + Warning: Date.prototype.toLocaleFormat is deprecated; consider using Intl.DateTimeFormat instead -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>Un avertissement, l'exécution du script JavaScript n'est pas interrompue.</p> +Un avertissement, l'exécution du script JavaScript n'est pas interrompue. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>La méthode non-standard {{jsxref("Date.prototype.toLocaleFormat")}} est dépréciée et ne devrait plus être utilisée. Elle utilise une chaîne de caractères qui indique le format avec la même syntaxe que la fonction <code>strftime()</code> en C. Cette fonction n'est plus disponible à partir de Firefox 58.</p> +La méthode non-standard {{jsxref("Date.prototype.toLocaleFormat")}} est dépréciée et ne devrait plus être utilisée. Elle utilise une chaîne de caractères qui indique le format avec la même syntaxe que la fonction `strftime()` en C. Cette fonction n'est plus disponible à partir de Firefox 58. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Syntaxe_dépréciée">Syntaxe dépréciée</h3> +### Syntaxe dépréciée -<p>La méthode {{jsxref("Date.prototype.toLocaleFormat")}} est dépréciée et sera retirée (aucune prise en charge par les autres navigateurs en dehors de Firefox).</p> +La méthode {{jsxref("Date.prototype.toLocaleFormat")}} est dépréciée et sera retirée (aucune prise en charge par les autres navigateurs en dehors de Firefox). -<pre class="brush: js example-bad">var today = new Date(); +```js example-bad +var today = new Date(); var date = today.toLocaleFormat('%A %e %B %Y'); console.log(date); // En français -// "Vendredi 10 mars 2017"</pre> +// "Vendredi 10 mars 2017" +``` -<h3 id="Utiliser_une_syntaxe_standard_grâce_à_l'API_ECMAScript_Intl">Utiliser une syntaxe standard grâce à l'API ECMAScript Intl</h3> +### Utiliser une syntaxe standard grâce à l'API ECMAScript Intl -<p>Le standard ECMA-402 (l'API ECMAScript Intl) définit des objets et méthodes standards qui permettent de mettre en forme des dates et heures (disponible à partir de Chrome 24, de Firefox 29, d'IE11 et de Safari10).</p> +Le standard ECMA-402 (l'API ECMAScript Intl) définit des objets et méthodes standards qui permettent de mettre en forme des dates et heures (disponible à partir de Chrome 24, de Firefox 29, d'IE11 et de Safari10). -<p>Si on souhaite uniquement formater une date, on pourra utiliser la méthode {{jsxref("Date.prototype.toLocaleDateString")}}.</p> +Si on souhaite uniquement formater une date, on pourra utiliser la méthode {{jsxref("Date.prototype.toLocaleDateString")}}. -<pre class="brush: js example-good">var today = new Date(); +```js example-good +var today = new Date(); var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' }; var date = today.toLocaleDateString('fr-FR', options); console.log(date); // "Vendredi 10 mars 2017" -</pre> +``` -<p>Si on manipule plus de dates, on peut utiliser l'objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} qui permet de mettre en cache certains des calculs afin d'avoir une mise en forme rapide (ce qui s'avère utile lorsqu'on a une boucle par exemple) :</p> +Si on manipule plus de dates, on peut utiliser l'objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} qui permet de mettre en cache certains des calculs afin d'avoir une mise en forme rapide (ce qui s'avère utile lorsqu'on a une boucle par exemple) : -<pre class="brush: js example-good">var options = { weekday: 'long', year: 'numeric', +```js example-good +var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' }; var dateFormatter = new Intl.DateTimeFormat('de-DE', options) var dates = [Date.UTC(2012, 11, 20, 3, 0, 0), Date.UTC(2014, 04, 12, 8, 0, 0)]; -dates.forEach(date => console.log(dateFormatter.format(date))); +dates.forEach(date => console.log(dateFormatter.format(date))); // "Donnerstag, 20. Dezember 2012" // "Montag, 12. Mai 2014" -</pre> +``` -<h3 id="Utiliser_les_méthodes_de_l'objet_Date">Utiliser les méthodes de l'objet <code>Date</code></h3> +### Utiliser les méthodes de l'objet `Date` -<p>L'objet {{jsxref("Date")}} dispose de plusieurs méthodes qui permettent de construire une chaîne de caractères pour une date donnée. Ainsi</p> +L'objet {{jsxref("Date")}} dispose de plusieurs méthodes qui permettent de construire une chaîne de caractères pour une date donnée. Ainsi -<pre class="brush: js example-bad">(new Date()).toLocaleFormat("%Y%m%d"); +```js example-bad +(new Date()).toLocaleFormat("%Y%m%d"); // "20170310" -</pre> +``` -<p>Pourra être converti en :</p> +Pourra être converti en : -<pre class="brush: js example-good">let now = new Date(); +```js example-good +let now = new Date(); let date = now.getFullYear() * 10000 + (now.getMonth() + 1) * 100 + now.getDate(); console.log(date); -// "20170310"</pre> +// "20170310" +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("Date.prototype.toLocaleFormat")}}</li> - <li>{{jsxref("Date.prototype.toLocaleDateString")}}</li> - <li>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}</li> -</ul> +- {{jsxref("Date.prototype.toLocaleFormat")}} +- {{jsxref("Date.prototype.toLocaleDateString")}} +- {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} diff --git a/files/fr/web/javascript/reference/errors/equal_as_assign/index.md b/files/fr/web/javascript/reference/errors/equal_as_assign/index.md index 2e420be691..400fb4a797 100644 --- a/files/fr/web/javascript/reference/errors/equal_as_assign/index.md +++ b/files/fr/web/javascript/reference/errors/equal_as_assign/index.md @@ -8,47 +8,49 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Equal_as_assign original_slug: Web/JavaScript/Reference/Erreurs/Equal_as_assign --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">Warning: SyntaxError: test for equality (==) mistyped as assignment (=)? -</pre> + Warning: SyntaxError: test for equality (==) mistyped as assignment (=)? -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>Uniquement pour Firefox. Un avertissement sous la forme d'une exception {{jsxref("SyntaxError")}}, généré uniquement si la préférence <code>javascript.options.strict</code> vaut <code>true</code>.</p> +Uniquement pour Firefox. Un avertissement sous la forme d'une exception {{jsxref("SyntaxError")}}, généré uniquement si la préférence `javascript.options.strict` vaut `true`. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Le code utilise une affectation (<code>=</code>) là où on attendrait un test d'égalité (<code>==</code>). Afin d'aider au débogage, le moteur JavaScript déclenche des avertissements lorsqu'il détecte ce motif.</p> +Le code utilise une affectation (`=`) là où on attendrait un test d'égalité (`==`). Afin d'aider au débogage, le moteur JavaScript déclenche des avertissements lorsqu'il détecte ce motif. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Des_affectations_utilisées_au_sein_d'expressions_conditionnelles">Des affectations utilisées au sein d'expressions conditionnelles</h3> +### Des affectations utilisées au sein d'expressions conditionnelles -<p>Il est conseillé de ne pas utiliser d'affectations simples dans des expressions conditionnelles (comme le test effectué avec <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/if...else">if...else</a></code>) car on peut confondre les deux à la lecture du code. Ainsi, on n'utilisera pas la forme suivante :</p> +Il est conseillé de ne pas utiliser d'affectations simples dans des expressions conditionnelles (comme le test effectué avec [`if...else`](/fr/docs/Web/JavaScript/Reference/Instructions/if...else)) car on peut confondre les deux à la lecture du code. Ainsi, on n'utilisera pas la forme suivante : -<pre class="brush: js example-bad">if (x = y) { +```js example-bad +if (x = y) { // do the right thing } -</pre> +``` -<p>Si on doit effectivement affecter une variable dans une expression conditionnelle, on entourera l'affectation d'une paire de parenthèses supplémentaires afin de montrer qu'on veut bien effectuer une affectation, comme ceci :</p> +Si on doit effectivement affecter une variable dans une expression conditionnelle, on entourera l'affectation d'une paire de parenthèses supplémentaires afin de montrer qu'on veut bien effectuer une affectation, comme ceci : -<pre class="brush: js">if ((x = y)) { +```js +if ((x = y)) { // exécuter le code -}</pre> +} +``` -<p>Autrement (généralement), on veut plutôt utiliser un opérateur de comparaison (<code>==</code> ou <code>===</code> par exemple) :</p> +Autrement (généralement), on veut plutôt utiliser un opérateur de comparaison (`==` ou `===` par exemple) : -<pre class="brush: js">if (x == y) { +```js +if (x == y) { // exécuter le code -}</pre> +} +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/if...else">if...else</a></code></li> - <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison">Les opérateurs de comparaison</a></li> -</ul> +- [`if...else`](/fr/docs/Web/JavaScript/Reference/Instructions/if...else) +- [Les opérateurs de comparaison](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison) diff --git a/files/fr/web/javascript/reference/errors/for-each-in_loops_are_deprecated/index.md b/files/fr/web/javascript/reference/errors/for-each-in_loops_are_deprecated/index.md index 26954d8e79..7d1e4dc118 100644 --- a/files/fr/web/javascript/reference/errors/for-each-in_loops_are_deprecated/index.md +++ b/files/fr/web/javascript/reference/errors/for-each-in_loops_are_deprecated/index.md @@ -7,95 +7,100 @@ tags: translation_of: Web/JavaScript/Reference/Errors/For-each-in_loops_are_deprecated original_slug: Web/JavaScript/Reference/Erreurs/For-each-in_loops_are_deprecated --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">Warning: JavaScript 1.6's for-each-in loops are deprecated; consider using ES6 for-of instead -</pre> + Warning: JavaScript 1.6's for-each-in loops are deprecated; consider using ES6 for-of instead -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>Avertissement.</p> +Avertissement. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>L'instruction {{jsxref("Instructions/for_each...in", "for each (variable in obj)")}} présente à partir de JavaScript 1.6 est une instruction dépréciée et est amenée à disparaître dans un avenir proche.</p> +L'instruction {{jsxref("Instructions/for_each...in", "for each (variable in obj)")}} présente à partir de JavaScript 1.6 est une instruction dépréciée et est amenée à disparaître dans un avenir proche. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Itérer_sur_un_objet">Itérer sur un objet</h3> +### Itérer sur un objet -<p>{{jsxref("Instructions/for_each...in", "for each...in")}} pouvait être utilisé pour parcourir les valeurs contenues dans un objet.</p> +{{jsxref("Instructions/for_each...in", "for each...in")}} pouvait être utilisé pour parcourir les valeurs contenues dans un objet. -<h4 id="Syntaxe_dépréciée">Syntaxe dépréciée</h4> +#### Syntaxe dépréciée -<pre class="brush: js example-bad">var objet = { a: 10, b: 20 }; +```js example-bad +var objet = { a: 10, b: 20 }; for each (var x in objet) { console.log(x); // 10 // 20 } -</pre> +``` -<h4 id="Syntaxe_alternative_standard">Syntaxe alternative, standard</h4> +#### Syntaxe alternative, standard -<p>On peut désormais utilisé l'instruction de boucle standard {{jsxref("Instructions/for...in", "for...in")}} afin d'itérer sur les clés d'un objet et de récupérer les valeurs des propriétés :</p> +On peut désormais utilisé l'instruction de boucle standard {{jsxref("Instructions/for...in", "for...in")}} afin d'itérer sur les clés d'un objet et de récupérer les valeurs des propriétés : -<pre class="brush: js example-good">var objet = { a: 10, b: 20 }; +```js example-good +var objet = { a: 10, b: 20 }; for (var key in objet) { var x = objet[key]; console.log(x); // 10 // 20 } -</pre> +``` -<p>Ou alors, on peut utiliser {{jsxref("Instructions/for...of", "for...of")}} (ES2015) et {{jsxref("Object.values")}} (ES2017) afin d'obtenir un tableau des valeurs associées à un objet pour ensuite le parcourir :</p> +Ou alors, on peut utiliser {{jsxref("Instructions/for...of", "for...of")}} (ES2015) et {{jsxref("Object.values")}} (ES2017) afin d'obtenir un tableau des valeurs associées à un objet pour ensuite le parcourir : -<pre class="brush: js example-good">var objet = { a: 10, b: 20 }; +```js example-good +var objet = { a: 10, b: 20 }; for (var x of Object.values(objet)) { console.log(x); // 10 // 20 } -</pre> +``` -<h3 id="Itérer_sur_un_tableau">Itérer sur un tableau</h3> +### Itérer sur un tableau -<p>{{jsxref("Instructions/for_each...in", "for each...in")}} pouvait être utilisée afin de parcourir les éléments d'un tableau.</p> +{{jsxref("Instructions/for_each...in", "for each...in")}} pouvait être utilisée afin de parcourir les éléments d'un tableau. -<h4 id="Syntaxe_dépréciée_2">Syntaxe dépréciée</h4> +#### Syntaxe dépréciée -<pre class="brush: js example-bad">var array = [10, 20, 30]; +```js example-bad +var array = [10, 20, 30]; for each (var x in array) { console.log(x); // 10 // 20 // 30 } -</pre> +``` -<h4 id="Syntaxe_alternative_standard_2">Syntaxe alternative, standard</h4> +#### Syntaxe alternative, standard -<p>On peut obtenir le même effet avec les boucles {{jsxref("Instructions/for...of", "for...of")}} (ES2015).</p> +On peut obtenir le même effet avec les boucles {{jsxref("Instructions/for...of", "for...of")}} (ES2015). -<pre class="brush: js example-good">var array = [10, 20, 30]; +```js example-good +var array = [10, 20, 30]; for (var x of array) { console.log(x); // 10 // 20 // 30 } -</pre> +``` -<h3 id="Parcourir_un_tableau_qui_vaille_null_ou_undefined">Parcourir un tableau qui vaille <code>null</code> ou <code>undefined</code></h3> +### Parcourir un tableau qui vaille `null` ou `undefined` -<p>{{jsxref("Instructions/for_each...in", "for each...in")}} ne fera rien si la valeur fournie est <code>null</code> ou <code>undefined</code>. En revanche, {{jsxref("Instructions/for...of", "for...of")}} lèvera une exception dans ces cas.</p> +{{jsxref("Instructions/for_each...in", "for each...in")}} ne fera rien si la valeur fournie est `null` ou `undefined`. En revanche, {{jsxref("Instructions/for...of", "for...of")}} lèvera une exception dans ces cas. -<h4 id="Syntaxe_dépréciée_3">Syntaxe dépréciée</h4> +#### Syntaxe dépréciée -<pre class="brush: js example-bad">function func(array) { +```js example-bad +function func(array) { for each (var x in array) { console.log(x); } @@ -104,13 +109,14 @@ func([10, 20]); // 10 // 20 func(null); // rien ne s'affiche func(undefined); // rien ne s'affiche -</pre> +``` -<h4 id="Syntaxe_alternative_standard_3">Syntaxe alternative, standard</h4> +#### Syntaxe alternative, standard -<p>Pour réécrire les instructions {{jsxref("Instructions/for_each...in", "for each...in")}} afin que les valeurs <code>null</code> ou <code>undefined</code> puissent être gérées avec {{jsxref("Instructions/for...of", "for...of")}}, il faudra rajouter une protection :</p> +Pour réécrire les instructions {{jsxref("Instructions/for_each...in", "for each...in")}} afin que les valeurs `null` ou `undefined` puissent être gérées avec {{jsxref("Instructions/for...of", "for...of")}}, il faudra rajouter une protection : -<pre class="brush: js example-good">function func(array) { +```js example-good +function func(array) { if (array) { for (var x of array) { console.log(x); @@ -121,49 +127,50 @@ func([10, 20]); // 10 // 20 func(null); // rien ne s'affiche func(undefined); // rien ne s'affiche -</pre> +``` -<h3 id="Itérer_sur_les_tuples_clé-valeur_d'un_objet">Itérer sur les tuples clé-valeur d'un objet</h3> +### Itérer sur les tuples clé-valeur d'un objet -<h4 id="Syntaxe_dépréciée_4">Syntaxe dépréciée</h4> +#### Syntaxe dépréciée -<p>On pouvait utiliser une forme syntaxique particulière, désormais dépréciée, qui combine {{jsxref("Instructions/for_each...in", "for each...in")}} et l'objet déprécié {{jsxref("Iterator")}}.</p> +On pouvait utiliser une forme syntaxique particulière, désormais dépréciée, qui combine {{jsxref("Instructions/for_each...in", "for each...in")}} et l'objet déprécié {{jsxref("Iterator")}}. -<pre class="brush: js example-bad">var object = { a: 10, b: 20 }; +```js example-bad +var object = { a: 10, b: 20 }; for each (var [key, value] in Iterator(object)) { console.log(key, value); // "a", 10 // "b", 20 } -</pre> +``` -<h4 id="Syntaxe_alternative_standard_4">Syntaxe alternative, standard</h4> +#### Syntaxe alternative, standard -<p>On peut désormais utiliser la boucle {{jsxref("Instructions/for...in", "for...in")}} afin de parcourir les différentes clés d'un objet pour ensuite récupérer les valeurs associées :</p> +On peut désormais utiliser la boucle {{jsxref("Instructions/for...in", "for...in")}} afin de parcourir les différentes clés d'un objet pour ensuite récupérer les valeurs associées : -<pre class="brush: js example-good">var object = { a: 10, b: 20 }; +```js example-good +var object = { a: 10, b: 20 }; for (var key in object) { var value = object[key]; console.log(key, value); // "a", 10 // "b", 20 } -</pre> +``` -<p>Ou encore, on peut utiliser {{jsxref("Instructions/for...of", "for...of")}} (ES2015) et {{jsxref("Object.entries")}} (ES2017) pour récupérer un tableau contenant les clés et les valeurs d'un objet qu'on pourra ensuite parcourir :</p> +Ou encore, on peut utiliser {{jsxref("Instructions/for...of", "for...of")}} (ES2015) et {{jsxref("Object.entries")}} (ES2017) pour récupérer un tableau contenant les clés et les valeurs d'un objet qu'on pourra ensuite parcourir : -<pre class="brush: js example-good">var object = { a: 10, b: 20 }; +```js example-good +var object = { a: 10, b: 20 }; for (var [key, value] of Object.entries(object)) { console.log(key, value); // "a", 10 // "b", 20 } -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("Instructions/for...of", "for...of")}}</li> - <li>{{jsxref("Object.values")}}</li> - <li>{{jsxref("Object.entries")}}</li> -</ul> +- {{jsxref("Instructions/for...of", "for...of")}} +- {{jsxref("Object.values")}} +- {{jsxref("Object.entries")}} diff --git a/files/fr/web/javascript/reference/errors/getter_only/index.md b/files/fr/web/javascript/reference/errors/getter_only/index.md index 01fd2c0e14..d308e5b583 100644 --- a/files/fr/web/javascript/reference/errors/getter_only/index.md +++ b/files/fr/web/javascript/reference/errors/getter_only/index.md @@ -9,28 +9,28 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Getter_only original_slug: Web/JavaScript/Reference/Erreurs/Getter_only --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: Assignment to read-only properties is not allowed in strict mode (Edge) -TypeError: setting getter-only property "x" (Firefox) -TypeError: Cannot set property "prop" of #<Object> which has only a getter (Chrome) -</pre> + TypeError: Assignment to read-only properties is not allowed in strict mode (Edge) + TypeError: setting getter-only property "x" (Firefox) + TypeError: Cannot set property "prop" of #<Object> which has only a getter (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}, uniquement en <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>.</p> +{{jsxref("TypeError")}}, uniquement en [mode strict](/en-US/docs/Web/JavaScript/Reference/Strict_mode). -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>On essaie de fournir une nouvelle valeur pour une propriété qui ne dispose que d'un <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/get">accesseur</a>. Ceci échouera en mode non-strict mais lèvera une exception {{jsxref("TypeError")}} en <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>.</p> +On essaie de fournir une nouvelle valeur pour une propriété qui ne dispose que d'un [accesseur](/fr/docs/Web/JavaScript/Reference/Fonctions/get). Ceci échouera en mode non-strict mais lèvera une exception {{jsxref("TypeError")}} en [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode). -<h2 id="Exemples">Exemples</h2> +## Exemples -<p>Dans l'exemple qui suit, on voit comment créer un accesseur sur une propriété. En revanche, dans la définition de l'objet, on n'inclut aucun <a href="/fr/docs/Web/JavaScript/Reference/Fonctions/set">mutateur</a> et une exception <code>TypeError</code> sera déclenchée lorsqu'on voudra modifier la propriété <code>temperature</code> pour la passer à <code>30</code>. Pour plus de détails, on pourra consulter la page {{jsxref("Object.defineProperty()")}}.</p> +Dans l'exemple qui suit, on voit comment créer un accesseur sur une propriété. En revanche, dans la définition de l'objet, on n'inclut aucun [mutateur](/fr/docs/Web/JavaScript/Reference/Fonctions/set) et une exception `TypeError` sera déclenchée lorsqu'on voudra modifier la propriété `temperature` pour la passer à `30`. Pour plus de détails, on pourra consulter la page {{jsxref("Object.defineProperty()")}}. -<pre class="brush: js example-bad">"use strict"; +```js example-bad +"use strict"; function Archiver() { var temperature = null; @@ -47,11 +47,12 @@ arc.temperature; // 'get!' arc.temperature = 30; // TypeError: setting a property that has only a getter -</pre> +``` -<p>Pour corriger cette erreur, soit on retire la ligne 16 (où on tente de modifier la propriété) soit on implémente un mutateur, comme ceci :</p> +Pour corriger cette erreur, soit on retire la ligne 16 (où on tente de modifier la propriété) soit on implémente un mutateur, comme ceci : -<pre class="brush: js example-good highlight[12]">"use strict"; +```js example-good +"use strict"; function Archiver() { var temperature = null; @@ -75,11 +76,10 @@ var arc = new Archiver(); arc.temperature; // 'get!' arc.temperature = 11; arc.temperature = 13; -arc.getArchive(); // [{ val: 11 }, { val: 13 }]</pre> +arc.getArchive(); // [{ val: 11 }, { val: 13 }] +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("Object.defineProperty()")}}</li> - <li>{{jsxref("Object.defineProperties()")}}</li> -</ul> +- {{jsxref("Object.defineProperty()")}} +- {{jsxref("Object.defineProperties()")}} diff --git a/files/fr/web/javascript/reference/errors/identifier_after_number/index.md b/files/fr/web/javascript/reference/errors/identifier_after_number/index.md index 1401b41432..b2ca711e5a 100644 --- a/files/fr/web/javascript/reference/errors/identifier_after_number/index.md +++ b/files/fr/web/javascript/reference/errors/identifier_after_number/index.md @@ -8,32 +8,32 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Identifier_after_number original_slug: Web/JavaScript/Reference/Erreurs/Identifier_after_number --- -<div>{{JSSidebar("Errors")}}</div> +{{JSSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: Unexpected identifier after numeric literal (Edge) -SyntaxError: identifier starts immediately after numeric literal (Firefox) -SyntaxError: Unexpected number (Chrome) -</pre> + SyntaxError: Unexpected identifier after numeric literal (Edge) + SyntaxError: identifier starts immediately after numeric literal (Firefox) + SyntaxError: Unexpected number (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}</p> +{{jsxref("SyntaxError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Les noms qu'on donne aux variables (aussi appelés « identifiants ») doivent respecter certaines règles…</p> +Les noms qu'on donne aux variables (aussi appelés « identifiants ») doivent respecter certaines règles… -<p>En JavaScript, un identifiant doit commencer par une lettre, un tiret bas (_) ou un dollar ($), il ne peut pas commencer par un chiffre. Seuls les caractères après le premier peuvent être des chiffres.</p> +En JavaScript, un identifiant doit commencer par une lettre, un tiret bas (\_) ou un dollar ($), il ne peut pas commencer par un chiffre. Seuls les caractères après le premier peuvent être des chiffres. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Des_variables_dont_le_nom_commence_par_un_chiffre">Des variables dont le nom commence par un chiffre</h3> +### Des variables dont le nom commence par un chiffre -<p>En JavaScript, les noms des variables ne peuvent pas commencer par un chiffre. Aussi, le script suivant provoquera des erreurs :</p> +En JavaScript, les noms des variables ne peuvent pas commencer par un chiffre. Aussi, le script suivant provoquera des erreurs : -<pre class="brush: js example-bad">var 1vie = 'toto'; +```js example-bad +var 1vie = 'toto'; // SyntaxError: identifier starts immediately after numeric literal var toto = 1vie; @@ -41,17 +41,16 @@ var toto = 1vie; alert(1.toto); // SyntaxError: identifier starts immediately after numeric literal -</pre> +``` -<p>Pour éviter ce problème, il faudra renommer les variables afin d'éviter d'utiliser un chiffre au début :</p> +Pour éviter ce problème, il faudra renommer les variables afin d'éviter d'utiliser un chiffre au début : -<pre class="brush: js example-good">var vie1 = 'toto'; +```js example-good +var vie1 = 'toto'; var toto = vie1; -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale">La grammaire lexicale de JavaScript</a></li> - <li><a href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Variables">Les variables</a> dans le <a href="/fr/docs/Web/JavaScript/Guide">Guide JavaScript</a></li> -</ul> +- [La grammaire lexicale de JavaScript](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale) +- [Les variables](/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Variables) dans le [Guide JavaScript](/fr/docs/Web/JavaScript/Guide) diff --git a/files/fr/web/javascript/reference/errors/illegal_character/index.md b/files/fr/web/javascript/reference/errors/illegal_character/index.md index 9c886718f5..d1da414713 100644 --- a/files/fr/web/javascript/reference/errors/illegal_character/index.md +++ b/files/fr/web/javascript/reference/errors/illegal_character/index.md @@ -8,30 +8,30 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Illegal_character original_slug: Web/JavaScript/Reference/Erreurs/Illegal_character --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: Invalid character (Edge) -SyntaxError: illegal character (Firefox) -SyntaxError: Invalid or unexpected token (Chrome) -</pre> + SyntaxError: Invalid character (Edge) + SyntaxError: illegal character (Firefox) + SyntaxError: Invalid or unexpected token (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}</p> +{{jsxref("SyntaxError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Dans le code, il y a un élément de la syntaxe qui n'est pas à la bonne place. Pour détecter les erreurs de ce type, vous pouvez utiliser un éditeur de texte qui prend en charge la coloration syntaxique et qui met en évidence les caractères problématiques (par exemple si on a utilisé un tiret (<code> – </code>) au lieu d'un moins ( - ) ou des guillemets anglais (<code> “ </code>) à la place de doubles quotes ( " ).</p> +Dans le code, il y a un élément de la syntaxe qui n'est pas à la bonne place. Pour détecter les erreurs de ce type, vous pouvez utiliser un éditeur de texte qui prend en charge la coloration syntaxique et qui met en évidence les caractères problématiques (par exemple si on a utilisé un tiret (` – `) au lieu d'un moins ( - ) ou des guillemets anglais (` “ `) à la place de doubles quotes ( " ). -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Caractères_ressemblants">Caractères ressemblants</h3> +### Caractères ressemblants -<p>Certains caractères ressemblent à des caractères spéciaux en JavaScript mais n'en sont pas. Dans ce cas, lorsque le moteur analysera le code, il échouera.</p> +Certains caractères ressemblent à des caractères spéciaux en JavaScript mais n'en sont pas. Dans ce cas, lorsque le moteur analysera le code, il échouera. -<pre class="brush: js example-bad">“Ceci ressemble à une chaîne de caractères.”; +```js example-bad +“Ceci ressemble à une chaîne de caractères.”; // “ n'est pas le caractère " // SyntaxError: illegal character @@ -40,45 +40,50 @@ SyntaxError: Invalid or unexpected token (Chrome) // SyntaxError: illegal character var toto = "truc"; -// ; (<37e>) n'est pas le caractère ; +// ; (<37e>) n'est pas le caractère ; // SyntaxError: illegal character -</pre> +``` -<p>On peut corriger ce point en utilisant les bons caractères :</p> +On peut corriger ce point en utilisant les bons caractères : -<pre class="brush: js example-good">"Ceci est vraiment une chaîne de caractères."; +```js example-good +"Ceci est vraiment une chaîne de caractères."; 42 - 13; var toto = "truc"; -</pre> +``` -<p>Certains éditeurs et environnements de développement intégrés indiqueront la présence de tels caractères avec une coloration syntaxique différente. Toutefois, tous les éditeurs n'ont pas une telle fonctionnalité et si vous n'arrivez pas à déterminer l'origine du problème, il vaudra sans doute mieux supprimer la ligne incriminée et la resaisir manuellement.</p> +Certains éditeurs et environnements de développement intégrés indiqueront la présence de tels caractères avec une coloration syntaxique différente. Toutefois, tous les éditeurs n'ont pas une telle fonctionnalité et si vous n'arrivez pas à déterminer l'origine du problème, il vaudra sans doute mieux supprimer la ligne incriminée et la resaisir manuellement. -<h3 id="Caractères_oubliés">Caractères oubliés</h3> +### Caractères oubliés -<p>On oublie parfois un caractère.</p> +On oublie parfois un caractère. -<pre class="brush: js example-bad">var couleurs = ['#000', #333', '#666']; +```js example-bad +var couleurs = ['#000', #333', '#666']; // SyntaxError: illegal character -</pre> +``` -<p>Dans ce cas, il suffit de rajouter la quote pour <code>'#333'</code>.</p> +Dans ce cas, il suffit de rajouter la quote pour `'#333'`. -<pre class="brush: js example-good">var couleurs = ['#000', '#333', '#666'];</pre> +```js example-good +var couleurs = ['#000', '#333', '#666']; +``` -<h3 id="Caractères_cachés">Caractères cachés</h3> +### Caractères cachés -<p>Lorsque vous copiez/collez du code depuis des sources externes, celles-ci peuvent contenir des caractères invalides difficiles à discerner.</p> +Lorsque vous copiez/collez du code depuis des sources externes, celles-ci peuvent contenir des caractères invalides difficiles à discerner. -<pre class="brush: js example-bad">var toto = 'truc'; +```js example-bad +var toto = 'truc'; // SyntaxError: illegal character -</pre> +``` -<p>Lorsqu'on inspecte ce code grâce à un éditeur de texte (par exemple Vim), on peut voir qu'il y en fait un <a href="https://fr.wikipedia.org/wiki/Espace_sans_chasse">espace sans chasse (ZWSP) (U+200B)</a>.</p> +Lorsqu'on inspecte ce code grâce à un éditeur de texte (par exemple Vim), on peut voir qu'il y en fait un [espace sans chasse (ZWSP) (U+200B)](https://fr.wikipedia.org/wiki/Espace_sans_chasse). -<pre class="brush: js">var toto = 'truc';<200b></pre> +```js +var toto = 'truc';<200b> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale">La grammaire lexicale de JavaScript</a></li> -</ul> +- [La grammaire lexicale de JavaScript](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale) diff --git a/files/fr/web/javascript/reference/errors/in_operator_no_object/index.md b/files/fr/web/javascript/reference/errors/in_operator_no_object/index.md index 104971982d..4a07499692 100644 --- a/files/fr/web/javascript/reference/errors/in_operator_no_object/index.md +++ b/files/fr/web/javascript/reference/errors/in_operator_no_object/index.md @@ -8,67 +8,71 @@ tags: translation_of: Web/JavaScript/Reference/Errors/in_operator_no_object original_slug: Web/JavaScript/Reference/Erreurs/in_operator_no_object --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: Invalid operand to 'in' (Edge) -TypeError: right-hand side of 'in' should be an object, got 'x' (Firefox) -TypeError: cannot use 'in' operator to search for 'x' in 'y' (Firefox, Chrome) -</pre> + TypeError: Invalid operand to 'in' (Edge) + TypeError: right-hand side of 'in' should be an object, got 'x' (Firefox) + TypeError: cannot use 'in' operator to search for 'x' in 'y' (Firefox, Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}</p> +{{jsxref("TypeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>L'<a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in">opérateur <code>in</code></a> peut uniquement être utilisé pour vérifier qu'une propriété appartient à un objet. Il ne peut pas être utilisé pour rechercher des caractères dans des chaînes de caractères, des nombres ou dans d'autres types de données en dehors des objets.</p> +L'[opérateur `in`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in) peut uniquement être utilisé pour vérifier qu'une propriété appartient à un objet. Il ne peut pas être utilisé pour rechercher des caractères dans des chaînes de caractères, des nombres ou dans d'autres types de données en dehors des objets. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Rechercher_un_texte_dans_une_chaîne_de_caractères">Rechercher un texte dans une chaîne de caractères</h3> +### Rechercher un texte dans une chaîne de caractères -<p>À la différence de certains langages de programmation (Python par exemple), JavaScript ne permet pas de chercher des textes dans une chaîne de caractères grâce à l'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in"><code>in</code></a>.</p> +À la différence de certains langages de programmation (Python par exemple), JavaScript ne permet pas de chercher des textes dans une chaîne de caractères grâce à l'opérateur [`in`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in). -<pre class="brush: js example-bad">"Coucou" in "Coucou monde"; +```js example-bad +"Coucou" in "Coucou monde"; // TypeError: cannot use 'in' operator to search for 'Coucou' in 'Coucou monde' -</pre> +``` -<p>On utilisera plutôt la méthode {{jsxref("String.prototype.indexOf()")}} :</p> +On utilisera plutôt la méthode {{jsxref("String.prototype.indexOf()")}} : -<pre class="brush: js example-good">"Coucou monde".indexOf("Coucou") !== -1; -// true</pre> +```js example-good +"Coucou monde".indexOf("Coucou") !== -1; +// true +``` -<h3 id="null_ou_undefined_ne_fonctionnent_pas"><code>null</code> ou <code>undefined</code> ne fonctionnent pas</h3> +### `null` ou `undefined` ne fonctionnent pas -<p>Avant d'utiliser <code>in</code>, il faut s'assurer que la valeur qu'on inspecte n'est pas {{jsxref("null")}} ou {{jsxref("undefined")}}.</p> +Avant d'utiliser `in`, il faut s'assurer que la valeur qu'on inspecte n'est pas {{jsxref("null")}} ou {{jsxref("undefined")}}. -<pre class="brush: js example-bad">var toto = null; +```js example-bad +var toto = null; "truc" in toto; // TypeError: cannot use 'in' operator to search for 'truc' in 'toto" (Chrome) // TypeError: right-hand side of 'in' should be an object, got null (Firefox) -</pre> +``` -<p>L'opérateur <code>in</code> doit être utilisé avec un objet.</p> +L'opérateur `in` doit être utilisé avec un objet. -<pre class="brush: js example-good">var toto = { machin: "bidule" }; +```js example-good +var toto = { machin: "bidule" }; "truc" in toto; // false "PI" in Math; // true "pi" in Math; // false -</pre> +``` -<h3 id="Rechercher_dans_un_tableau">Rechercher dans un tableau</h3> +### Rechercher dans un tableau -<p>Attention lorsqu'on utilise l'opérateur <code>in</code> quand on recherche une valeur dans un objet {{jsxref("Array")}}. L'opérateur <code>in</code> vérifie la présence de l'index mais pas la valeur présente à cet index.</p> +Attention lorsqu'on utilise l'opérateur `in` quand on recherche une valeur dans un objet {{jsxref("Array")}}. L'opérateur `in` vérifie la présence de l'index mais pas la valeur présente à cet index. -<pre class="brush: js">var arbres = ['cèdre', 'bouleau', 'pin', 'sapin', 'érable']; +```js +var arbres = ['cèdre', 'bouleau', 'pin', 'sapin', 'érable']; 3 in arbres; // true -"pin" in arbres; // false</pre> +"pin" in arbres; // false +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in">L'opérateur <code>in</code></a></li> -</ul> +- [L'opérateur `in`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_in) diff --git a/files/fr/web/javascript/reference/errors/index.md b/files/fr/web/javascript/reference/errors/index.md index 7110b7682a..aeaeeb5519 100644 --- a/files/fr/web/javascript/reference/errors/index.md +++ b/files/fr/web/javascript/reference/errors/index.md @@ -6,19 +6,17 @@ tags: translation_of: Web/JavaScript/Reference/Errors original_slug: Web/JavaScript/Reference/Erreurs --- -<p>{{jsSidebar("Errors")}}</p> +{{jsSidebar("Errors")}} -<p><em>Errare ECMAScript est</em>…<br> - Vous trouverez ci-après une liste d'erreurs causées par le moteur JavaScript. Ces erreurs peuvent aider à déboguer certains problèmes mais leur signification n'est pas toujours claire. Chacune de ces pages fournit donc des explications et informations supplémentaires à propos de ces erreurs.</p> +_Errare ECMAScript est_… +Vous trouverez ci-après une liste d'erreurs causées par le moteur JavaScript. Ces erreurs peuvent aider à déboguer certains problèmes mais leur signification n'est pas toujours claire. Chacune de ces pages fournit donc des explications et informations supplémentaires à propos de ces erreurs. -<p>D'un point de vue technique, chaque erreur est un objet {{jsxref("Error")}} et possède une propriété <code>name</code> (son nom) et une propriété <code>message</code>.</p> +D'un point de vue technique, chaque erreur est un objet {{jsxref("Error")}} et possède une propriété `name` (son nom) et une propriété `message`. -<h2 id="Liste_d'erreurs">Liste d'erreurs</h2> +## Liste d'erreurs -<p>{{ListSubPages("/fr/docs/Web/JavaScript/Reference/Erreurs")}}</p> +{{ListSubPages("/fr/docs/Web/JavaScript/Reference/Erreurs")}} -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Learn/JavaScript/First_steps/What_went_wrong">Qu'est-ce qui a cloché ? Diagnostiquer un problème JavaScript</a> : un tutoriel introductif pour réparer les erreurs JavaScript</li> -</ul> +- [Qu'est-ce qui a cloché ? Diagnostiquer un problème JavaScript](/fr/docs/Learn/JavaScript/First_steps/What_went_wrong) : un tutoriel introductif pour réparer les erreurs JavaScript diff --git a/files/fr/web/javascript/reference/errors/invalid_array_length/index.md b/files/fr/web/javascript/reference/errors/invalid_array_length/index.md index aa5fd0d701..b8db76535a 100644 --- a/files/fr/web/javascript/reference/errors/invalid_array_length/index.md +++ b/files/fr/web/javascript/reference/errors/invalid_array_length/index.md @@ -8,40 +8,38 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Invalid_array_length original_slug: Web/JavaScript/Reference/Erreurs/Invalid_array_length --- -<div>{{jsSidebar("Erreurs")}}</div> +{{jsSidebar("Erreurs")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">RangeError: Array length must be a finite positive integer (Edge) -RangeError: invalid array length (Firefox) -RangeError: Invalid array length (Chrome) -RangeError: Invalid array buffer length (Chrome) -</pre> + RangeError: Array length must be a finite positive integer (Edge) + RangeError: invalid array length (Firefox) + RangeError: Invalid array length (Chrome) + RangeError: Invalid array buffer length (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("RangeError")}}</p> +{{jsxref("RangeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Deux cas de figures peuvent causer cette erreur :</p> +Deux cas de figures peuvent causer cette erreur : -<ul> - <li>La création d'un tableau {{jsxref("Array")}} ou {{jsxref("ArrayBuffer")}} dont la longueur est négative ou supérieure ou égale à 2^32</li> - <li>La modification de la propriété {{jsxref("Array.length")}} pour que celle-ci ait une valeur négative ou supérieure ou égale à 2^32.</li> -</ul> +- La création d'un tableau {{jsxref("Array")}} ou {{jsxref("ArrayBuffer")}} dont la longueur est négative ou supérieure ou égale à 2^32 +- La modification de la propriété {{jsxref("Array.length")}} pour que celle-ci ait une valeur négative ou supérieure ou égale à 2^32. -<p>Les tailles des objets <code>Array</code> et <code>ArrayBuffer</code> sont limitées car leurs longueurs (<code>length</code>) sont représentées par des entiers non-signés sur 32 bits. Ces valeurs sont donc nécessairement comprises dans l'intervalle allant de 0 à 2^32-1.</p> +Les tailles des objets `Array` et `ArrayBuffer` sont limitées car leurs longueurs (`length`) sont représentées par des entiers non-signés sur 32 bits. Ces valeurs sont donc nécessairement comprises dans l'intervalle allant de 0 à 2^32-1. -<p>Si vous utilisez le constructeur pour <code>Array</code>, il est probable que vous souhaitiez utiliser la notation littérale plutôt que le constructeur. En effet, le premier argument de ce constructeur correspond à la longueur du tableau.</p> +Si vous utilisez le constructeur pour `Array`, il est probable que vous souhaitiez utiliser la notation littérale plutôt que le constructeur. En effet, le premier argument de ce constructeur correspond à la longueur du tableau. -<p>Sinon, vous pouvez réduire la longueur utilisée afin que celle-ci soit dans l'intervalle valide avant de l'utiliser pour une telle création ou modification.</p> +Sinon, vous pouvez réduire la longueur utilisée afin que celle-ci soit dans l'intervalle valide avant de l'utiliser pour une telle création ou modification. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Exemples_invalides">Exemples invalides</h3> +### Exemples invalides -<pre class="brush: js example-bad">new Array(Math.pow(2, 40)) +```js example-bad +new Array(Math.pow(2, 40)) new Array(-1) new ArrayBuffer(Math.pow(2, 32)) new ArrayBuffer(-1) @@ -51,11 +49,12 @@ a.length = a.length - 1; // set -1 to the length property let b = new Array(Math.pow(2, 32) - 1); b.length = b.length + 1; // set 2^32 to the length property -</pre> +``` -<h3 id="Exemples_valides">Exemples valides</h3> +### Exemples valides -<pre class="brush: js example-good">[ Math.pow(2, 40) ] // [ 1099511627776 ] +```js example-good +[ Math.pow(2, 40) ] // [ 1099511627776 ] [ -1 ] // [ -1 ] new ArrayBuffer(Math.pow(2, 32) - 1) new ArrayBuffer(0) @@ -68,13 +67,11 @@ b.length = Math.min(0xffffffff, b.length + 1); // 0xffffffff est la notation hexadécimale // pour 2^32 - 1 -// ce qu'on peut également écrire (-1 >>> 0) -</pre> +// ce qu'on peut également écrire (-1 >>> 0) +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("Array")}}</li> - <li>{{jsxref("Array.length")}}</li> - <li>{{jsxref("ArrayBuffer")}}</li> -</ul> +- {{jsxref("Array")}} +- {{jsxref("Array.length")}} +- {{jsxref("ArrayBuffer")}} diff --git a/files/fr/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.md b/files/fr/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.md index 5a441e32a9..b35d7cdcc1 100644 --- a/files/fr/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.md +++ b/files/fr/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.md @@ -8,24 +8,24 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Invalid_assignment_left-hand_side original_slug: Web/JavaScript/Reference/Erreurs/Invalid_assignment_left-hand_side --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">ReferenceError: invalid assignment left-hand side -</pre> + ReferenceError: invalid assignment left-hand side -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("ReferenceError")}}.</p> +{{jsxref("ReferenceError")}}. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Un affectation inattendue a eu lieu. Cela peut être dû à un mélange entre <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation">un opérateur d'affectation</a> et <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison">un opérateur de comparaison</a>. Un seul signe égal affectera une valeur à une variable alors que les opérateurs <code>==</code> ou <code>===</code> comparent des valeurs entre elles.</p> +Un affectation inattendue a eu lieu. Cela peut être dû à un mélange entre [un opérateur d'affectation](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation) et [un opérateur de comparaison](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison). Un seul signe égal affectera une valeur à une variable alors que les opérateurs `==` ou `===` comparent des valeurs entre elles. -<h2 id="Exemples">Exemples</h2> +## Exemples -<pre class="brush: js example-bad">if (Math.PI = 3 || Math.PI = 4) { +```js example-bad +if (Math.PI = 3 || Math.PI = 4) { console.log('Nope !'); } // ReferenceError: invalid assignment left-hand side @@ -34,22 +34,21 @@ var str = 'Hello, ' += 'is it me ' += 'you\'re looking for?'; // ReferenceError: invalid assignment left-hand side -</pre> +``` -<p>Dans l'instruction <code>if</code>, plutôt qu'une affectation, on voudra plutôt utiliser un opérateur <code>==</code> ou <code>===</code> et l'opérateur de concaténation (+) à la place pour la chaîne.</p> +Dans l'instruction `if`, plutôt qu'une affectation, on voudra plutôt utiliser un opérateur `==` ou `===` et l'opérateur de concaténation (+) à la place pour la chaîne. -<pre class="brush: js example-good">if (Math.PI == 3 || Math.PI == 4) { +```js example-good +if (Math.PI == 3 || Math.PI == 4) { console.log('no way!'); } var str = 'Hello, ' + 'from the ' + 'other side!'; -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation">Opérateurs d'affectation</a></li> - <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison">Opérateurs de comparaison</a></li> -</ul> +- [Opérateurs d'affectation](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation) +- [Opérateurs de comparaison](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison) diff --git a/files/fr/web/javascript/reference/errors/invalid_const_assignment/index.md b/files/fr/web/javascript/reference/errors/invalid_const_assignment/index.md index 76219c8d9f..8205bb266e 100644 --- a/files/fr/web/javascript/reference/errors/invalid_const_assignment/index.md +++ b/files/fr/web/javascript/reference/errors/invalid_const_assignment/index.md @@ -8,84 +8,91 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Invalid_const_assignment original_slug: Web/JavaScript/Reference/Erreurs/Invalid_const_assignment --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: invalid assignment to const "x" (Firefox) -TypeError: Assignment to constant variable. (Chrome) -TypeError: Redeclaration of const 'x' (Edge) -</pre> + TypeError: invalid assignment to const "x" (Firefox) + TypeError: Assignment to constant variable. (Chrome) + TypeError: Redeclaration of const 'x' (Edge) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}</p> +{{jsxref("TypeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Une constante est une valeur qui ne peut pas être modifiée lors de l'exécution du programme. Elle ne peut pas être modifiée grâce à une réaffectation ou grâce à une redéclaration. En JavaScript, les constantes sont déclarées grâce au mot-clé <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/const">const</a></code>.</p> +Une constante est une valeur qui ne peut pas être modifiée lors de l'exécution du programme. Elle ne peut pas être modifiée grâce à une réaffectation ou grâce à une redéclaration. En JavaScript, les constantes sont déclarées grâce au mot-clé [`const`](/fr/docs/Web/JavaScript/Reference/Instructions/const). -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Redéclaration_invalide">Redéclaration invalide</h3> +### Redéclaration invalide -<p>Si on affecte une valeur à une constante dans la même portée de bloc que celui qui contient l'affectation initiale, une exception sera levée :</p> +Si on affecte une valeur à une constante dans la même portée de bloc que celui qui contient l'affectation initiale, une exception sera levée : -<pre class="brush: js example-bad">const COLUMNS = 80; +```js example-bad +const COLUMNS = 80; // ... -COLUMNS = 120; // TypeError: invalid assignment to const `COLUMNS'</pre> +COLUMNS = 120; // TypeError: invalid assignment to const `COLUMNS' +``` -<h3 id="Résoudre_le_problème">Résoudre le problème</h3> +### Résoudre le problème -<p>Il existe plusieurs façons de résoudre ce problème et il faut au préalable comprendre le rôle de la constante en question.</p> +Il existe plusieurs façons de résoudre ce problème et il faut au préalable comprendre le rôle de la constante en question. -<h4 id="Utiliser_un_autre_nom">Utiliser un autre nom</h4> +#### Utiliser un autre nom -<p>Si on souhaite déclarer une autre constante, on peut utiliser un autre nom que celui qui est déjà pris dans cette portée :</p> +Si on souhaite déclarer une autre constante, on peut utiliser un autre nom que celui qui est déjà pris dans cette portée : -<pre class="brush: js example-good">const COLUMNS = 80; -const WIDE_COLUMNS = 120;</pre> +```js example-good +const COLUMNS = 80; +const WIDE_COLUMNS = 120; +``` -<h4 id="const_let_ou_var"><code>const</code>, <code>let</code> ou <code>var</code> ?</h4> +#### `const`, `let` ou `var` ? -<p><code>const</code> ne doit pas être utilisé si on ne souhaite pas déclarer de constante. Peut-être qu'on souhaite simplement déclarer une variable avec une portée de bloc grâce à <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/let">let</a></code> ou une variable globale avec <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code>.</p> +`const` ne doit pas être utilisé si on ne souhaite pas déclarer de constante. Peut-être qu'on souhaite simplement déclarer une variable avec une portée de bloc grâce à [`let`](/fr/docs/Web/JavaScript/Reference/Instructions/let) ou une variable globale avec [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var). -<pre class="brush: js example-good">let columns = 80; +```js example-good +let columns = 80; // ... let columns = 120; -</pre> +``` -<h4 id="Gérer_les_portées">Gérer les portées</h4> +#### Gérer les portées -<p>On peut également vérifier qu'on est dans la bonne portée. Est-ce que la constante devait apparaître dans la portée en question ou devait être utilisée dans une fonction ?</p> +On peut également vérifier qu'on est dans la bonne portée. Est-ce que la constante devait apparaître dans la portée en question ou devait être utilisée dans une fonction ? -<pre class="brush: js example-good">const COLUMNS = 80; +```js example-good +const COLUMNS = 80; function setupBigScreenEnvironment() { const COLUMNS = 120; -}</pre> +} +``` -<h3 id="const_et_l'immuabilité"><code>const</code> et l'immuabilité</h3> +### `const` et l'immuabilité -<p>La déclaration <code>const</code> crée une référence en lecture seule vers une valeur. Elle ne signifie pas que la valeur en question est immuable mais uniquement que l'identifiant de la référence ne peut pas recevoir de nouvelle valeur. Ainsi, si le contenu est un objet, celui-ci pourra toujours être modifié :</p> +La déclaration `const` crée une référence en lecture seule vers une valeur. Elle ne signifie pas que la valeur en question est immuable mais uniquement que l'identifiant de la référence ne peut pas recevoir de nouvelle valeur. Ainsi, si le contenu est un objet, celui-ci pourra toujours être modifié : -<pre class="brush: js example-bad">const obj = {toto: 'truc'}; +```js example-bad +const obj = {toto: 'truc'}; obj = {toto: 'bidule'}; // TypeError: invalid assignment to const `obj' -</pre> +``` -<p>En revanche, on peut modifier les propriétés :</p> +En revanche, on peut modifier les propriétés : -<pre class="brush: js example-good">obj.toto = 'bidule'; -obj; // Object { toto: "bidule" }</pre> +```js example-good +obj.toto = 'bidule'; +obj; // Object { toto: "bidule" } +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/const">const</a></code></li> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/let">let</a></code></li> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code></li> -</ul> +- [`const`](/fr/docs/Web/JavaScript/Reference/Instructions/const) +- [`let`](/fr/docs/Web/JavaScript/Reference/Instructions/let) +- [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var) diff --git a/files/fr/web/javascript/reference/errors/invalid_date/index.md b/files/fr/web/javascript/reference/errors/invalid_date/index.md index a89f979fbc..ab0905ac9f 100644 --- a/files/fr/web/javascript/reference/errors/invalid_date/index.md +++ b/files/fr/web/javascript/reference/errors/invalid_date/index.md @@ -8,50 +8,52 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Invalid_date original_slug: Web/JavaScript/Reference/Erreurs/Invalid_date --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">RangeError: invalid date (Edge) -RangeError: invalid date (Firefox) -RangeError: invalid time value (Chrome) -RangeError: Provided date is not in valid range (Chrome) -</pre> + RangeError: invalid date (Edge) + RangeError: invalid date (Firefox) + RangeError: invalid time value (Chrome) + RangeError: Provided date is not in valid range (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("RangeError")}}</p> +{{jsxref("RangeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Une chaîne de caractères indiquant une date invalide a été fournie comme argument au constructeur {{jsxref("Date")}} ou à la méthode {{jsxref("Date.parse()")}}.</p> +Une chaîne de caractères indiquant une date invalide a été fournie comme argument au constructeur {{jsxref("Date")}} ou à la méthode {{jsxref("Date.parse()")}}. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Exemples_invalides">Exemples invalides</h3> +### Exemples invalides -<p>Les chaînes de caractères qui ne peuvent pas être converties en date ou les dates qui contiennent des éléments illégaux pour le format ISO renvoient généralement {{jsxref("NaN")}}. Cependant, selon l'implémentation, les chaînes de caractères qui ne respectent pas le format ISO pour les dates peuvent déclencher une exception <code>RangeError: invalid date</code>. Les instructions suivantes déclencheront cette erreur dans Firefox :</p> +Les chaînes de caractères qui ne peuvent pas être converties en date ou les dates qui contiennent des éléments illégaux pour le format ISO renvoient généralement {{jsxref("NaN")}}. Cependant, selon l'implémentation, les chaînes de caractères qui ne respectent pas le format ISO pour les dates peuvent déclencher une exception `RangeError: invalid date`. Les instructions suivantes déclencheront cette erreur dans Firefox : -<pre class="brush: js example-bad">new Date('toto-truc 2014'); +```js example-bad +new Date('toto-truc 2014'); new Date('2014-25-23').toISOString(); new Date('toto-truc 2014').toString(); -</pre> +``` -<p>En revanche, cette instruction renverra {{jsxref("NaN")}} dans Firefox :</p> +En revanche, cette instruction renverra {{jsxref("NaN")}} dans Firefox : -<pre class="brush: js example-bad">Date.parse('toto-truc 2014'); // NaN</pre> +```js example-bad +Date.parse('toto-truc 2014'); // NaN +``` -<p>Pour plus de détails, consulter la documentation sur {{jsxref("Date.parse()")}}.</p> +Pour plus de détails, consulter la documentation sur {{jsxref("Date.parse()")}}. -<h3 id="Exemples_valides">Exemples valides</h3> +### Exemples valides -<pre class="brush: js example-good">new Date('05 October 2011 14:48 UTC'); -new Date(1317826080); // timestamp Unix pour le 5 octobre 2011 14:48:00 UTC</pre> +```js example-good +new Date('05 October 2011 14:48 UTC'); +new Date(1317826080); // timestamp Unix pour le 5 octobre 2011 14:48:00 UTC +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("Date")}}</li> - <li>{{jsxref("Date.prototype.parse()")}}</li> - <li>{{jsxref("Date.prototype.toISOString()")}}</li> -</ul> +- {{jsxref("Date")}} +- {{jsxref("Date.prototype.parse()")}} +- {{jsxref("Date.prototype.toISOString()")}} diff --git a/files/fr/web/javascript/reference/errors/invalid_for-in_initializer/index.md b/files/fr/web/javascript/reference/errors/invalid_for-in_initializer/index.md index 2ae766aadc..64160b2884 100644 --- a/files/fr/web/javascript/reference/errors/invalid_for-in_initializer/index.md +++ b/files/fr/web/javascript/reference/errors/invalid_for-in_initializer/index.md @@ -9,28 +9,28 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Invalid_for-in_initializer original_slug: Web/JavaScript/Reference/Erreurs/Invalid_for-in_initializer --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: for-in loop head declarations cannot have an initializer (Edge) -SyntaxError: for-in loop head declarations may not have initializers (Firefox) -SyntaxError: for-in loop variable declaration may not have an initializer. (Chrome) -</pre> + SyntaxError: for-in loop head declarations cannot have an initializer (Edge) + SyntaxError: for-in loop head declarations may not have initializers (Firefox) + SyntaxError: for-in loop variable declaration may not have an initializer. (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}, uniquement en <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">mode strict</a>.</p> +{{jsxref("SyntaxError")}}, uniquement en [mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode). -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>L'en-tête d'une boucle <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...in">for...in</a></code> contient une expression d'initialisation, c'est-à-dire qu'une variable est déclarée et qu'on lui affecte une valeur. Ceci n'est pas autorisé en mode strict (et ignoré en mode non-strict).</p> +L'en-tête d'une boucle [`for...in`](/fr/docs/Web/JavaScript/Reference/Instructions/for...in) contient une expression d'initialisation, c'est-à-dire qu'une variable est déclarée et qu'on lui affecte une valeur. Ceci n'est pas autorisé en mode strict (et ignoré en mode non-strict). -<h2 id="Exemples">Exemples</h2> +## Exemples -<p>Cet exemple déclenchera une exception <code>SyntaxError</code> :</p> +Cet exemple déclenchera une exception `SyntaxError` : -<pre class="brush: js example-bad">"use strict"; +```js example-bad +"use strict"; var obj = {a: 1, b: 2, c: 3 }; @@ -39,37 +39,38 @@ for (var i = 0 in obj) { } // SyntaxError: for-in loop head declarations may not have initializers -</pre> +``` -<h3 id="Boucle_for-in_valide">Boucle for-in valide</h3> +### Boucle for-in valide -<p>On peut retirer l'initialisateur de l'en-tête de la boucle :</p> +On peut retirer l'initialisateur de l'en-tête de la boucle : -<pre class="brush: js example-good">"use strict"; +```js example-good +"use strict"; var obj = {a: 1, b: 2, c: 3 }; for (var i in obj) { console.log(obj[i]); } -</pre> +``` -<h3 id="Parcours_d'un_tableau">Parcours d'un tableau</h3> +### Parcours d'un tableau -<p><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...in#Utiliser_for...in_et_parcourir_un_tableau">Il ne faut pas utiliser de boucle <code>for...in</code> pour parcourir un tableau (<code>Array</code>)</a>. Peut-être souhaitiez-vous utiliser une boucle <code>for</code> pour parcourir le tableau ? Cette boucle <code>for</code> permet également d'utiliser un initialisateur :</p> +[Il ne faut pas utiliser de boucle `for...in` pour parcourir un tableau (`Array`)](/fr/docs/Web/JavaScript/Reference/Instructions/for...in#Utiliser_for...in_et_parcourir_un_tableau). Peut-être souhaitiez-vous utiliser une boucle `for` pour parcourir le tableau ? Cette boucle `for` permet également d'utiliser un initialisateur : -<pre class="brush: js example-good">var arr = [ "a", "b", "c" ] +```js example-good +var arr = [ "a", "b", "c" ] -for (var i = 2; i < arr.length; i++) { +for (var i = 2; i < arr.length; i++) { console.log(arr[i]); } -// "c"</pre> +// "c" +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...in">for...in</a></code></li> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of">for...of</a></code> interdit également d'utiliser un initialisateur en mode strict et non-strict</li> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for">for</a></code> permet de définir un initialisateur lors de l'itération et doit être privilégié pour parcourir un tableau</li> -</ul> +- [`for...in`](/fr/docs/Web/JavaScript/Reference/Instructions/for...in) +- [`for...of`](/fr/docs/Web/JavaScript/Reference/Instructions/for...of) interdit également d'utiliser un initialisateur en mode strict et non-strict +- [`for`](/fr/docs/Web/JavaScript/Reference/Instructions/for) permet de définir un initialisateur lors de l'itération et doit être privilégié pour parcourir un tableau diff --git a/files/fr/web/javascript/reference/errors/invalid_for-of_initializer/index.md b/files/fr/web/javascript/reference/errors/invalid_for-of_initializer/index.md index 943b5399fc..932f1f44ce 100644 --- a/files/fr/web/javascript/reference/errors/invalid_for-of_initializer/index.md +++ b/files/fr/web/javascript/reference/errors/invalid_for-of_initializer/index.md @@ -10,41 +10,43 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Invalid_for-of_initializer original_slug: Web/JavaScript/Reference/Erreurs/Invalid_for-of_initializer --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: for-of loop head declarations cannot have an initializer (Edge) -SyntaxError: a declaration in the head of a for-of loop can't have an initializer (Firefox) -SyntaxError: for-of loop variable declaration may not have an initializer. (Chrome) -</pre> + SyntaxError: for-of loop head declarations cannot have an initializer (Edge) + SyntaxError: a declaration in the head of a for-of loop can't have an initializer (Firefox) + SyntaxError: for-of loop variable declaration may not have an initializer. (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}</p> +{{jsxref("SyntaxError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>L'en-tête d'une boucle <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of">for...of</a></code> contient une expression d'initialisation, c'est-à-dire qu'une variable est déclarée et qu'on lui affecte une valeur. Ceci n'est pas autorisé pour les boucles <code>for-of</code>. En revanche, les boucles <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for">for</a></code> permettent d'avoir un initialisateur.</p> +L'en-tête d'une boucle [`for...of`](/fr/docs/Web/JavaScript/Reference/Instructions/for...of) contient une expression d'initialisation, c'est-à-dire qu'une variable est déclarée et qu'on lui affecte une valeur. Ceci n'est pas autorisé pour les boucles `for-of`. En revanche, les boucles [`for`](/fr/docs/Web/JavaScript/Reference/Instructions/for) permettent d'avoir un initialisateur. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Boucles_for-of_invalides">Boucles <code>for-of</code> invalides</h3> +### Boucles `for-of` invalides -<pre class="brush: js example-bad">let iterable = [10, 20, 30]; +```js example-bad +let iterable = [10, 20, 30]; for (let value = 50 of iterable) { console.log(value); } // SyntaxError: a declaration in the head of a for-of loop can't -// have an initializer</pre> +// have an initializer +``` -<h3 id="Boucles_for-of_valides">Boucles <code>for-of</code> valides</h3> +### Boucles `for-of` valides -<p>Il faut retirer l'initialisateur de l'en-tête de la boucle pour ne plus avoir l'erreur. Si cette valeur devait servir d'incrément, on peut ajouter l'addition dans le corps de la boucle.</p> +Il faut retirer l'initialisateur de l'en-tête de la boucle pour ne plus avoir l'erreur. Si cette valeur devait servir d'incrément, on peut ajouter l'addition dans le corps de la boucle. -<pre class="brush: js example-good">let iterable = [10, 20, 30]; +```js example-good +let iterable = [10, 20, 30]; for (let value of iterable) { value += 50; @@ -53,12 +55,10 @@ for (let value of iterable) { // 60 // 70 // 80 -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of">for...of</a></code></li> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...in">for...in</a></code> interdit également d'utiliser un initialisateur en mode strict (<a href="/fr/docs/Web/JavaScript/Reference/Errors/Invalid_for-in_initializer">SyntaxError: for-in loop head declarations may not have initializers</a>)</li> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for">for</a></code> permet de définir un initialisateur lors de l'itération</li> -</ul> +- [`for...of`](/fr/docs/Web/JavaScript/Reference/Instructions/for...of) +- [`for...in`](/fr/docs/Web/JavaScript/Reference/Instructions/for...in) interdit également d'utiliser un initialisateur en mode strict ([SyntaxError: for-in loop head declarations may not have initializers](/fr/docs/Web/JavaScript/Reference/Errors/Invalid_for-in_initializer)) +- [`for`](/fr/docs/Web/JavaScript/Reference/Instructions/for) permet de définir un initialisateur lors de l'itération diff --git a/files/fr/web/javascript/reference/errors/invalid_right_hand_side_instanceof_operand/index.md b/files/fr/web/javascript/reference/errors/invalid_right_hand_side_instanceof_operand/index.md index a9fe80e977..12e1bc3e14 100644 --- a/files/fr/web/javascript/reference/errors/invalid_right_hand_side_instanceof_operand/index.md +++ b/files/fr/web/javascript/reference/errors/invalid_right_hand_side_instanceof_operand/index.md @@ -10,26 +10,27 @@ tags: translation_of: Web/JavaScript/Reference/Errors/invalid_right_hand_side_instanceof_operand original_slug: Web/JavaScript/Reference/Erreurs/invalid_right_hand_side_instanceof_operand --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: invalid 'instanceof' operand "x" (Firefox) -TypeError: "x" is not a function (Firefox) -TypeError: Right-hand side of 'instanceof' is not an object (Chrome) -TypeError: Right-hand side of 'instanceof' is not callable (Chrome)</pre> + TypeError: invalid 'instanceof' operand "x" (Firefox) + TypeError: "x" is not a function (Firefox) + TypeError: Right-hand side of 'instanceof' is not an object (Chrome) + TypeError: Right-hand side of 'instanceof' is not callable (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}</p> +{{jsxref("TypeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>L'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/instanceof"><code>instanceof</code></a> attend un opérande droit qui soit un objet constructeur, c'est-à-dire un objet possédant une propriété <code>prototype</code> et qui puisse être appelé.</p> +L'opérateur [`instanceof`](/fr/docs/Web/JavaScript/Reference/Opérateurs/instanceof) attend un opérande droit qui soit un objet constructeur, c'est-à-dire un objet possédant une propriété `prototype` et qui puisse être appelé. -<h2 id="Exemples">Exemples</h2> +## Exemples -<pre class="brush: js example-bad">"test" instanceof ""; // TypeError: invalid 'instanceof' operand "" +```js example-bad +"test" instanceof ""; // TypeError: invalid 'instanceof' operand "" 42 instanceof 0; // TypeError: invalid 'instanceof' operand 0 function Toto() {} @@ -38,11 +39,12 @@ var x = new Toto(); x instanceof f; // TypeError: invalid 'instanceof' operand f x instanceof x; // TypeError: x is not a function -</pre> +``` -<p>Pour corriger ces erreurs, il faut remplacer l'opérateur <code>instanceof</code> avec l'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof"><code>typeof</code></a> ou s'assurer que l'opérande droit est la fonction et non le résultat de son évaluation.</p> +Pour corriger ces erreurs, il faut remplacer l'opérateur `instanceof` avec l'opérateur [`typeof`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof) ou s'assurer que l'opérande droit est la fonction et non le résultat de son évaluation. -<pre class="brush: js example-good">typeof "test" == "string"; // true +```js example-good +typeof "test" == "string"; // true typeof 42 == "number" // true function Toto() {} @@ -51,13 +53,9 @@ var x = new Toto(); x instanceof f; // true x instanceof Toto; // true -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>L'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/instanceof"><code>instanceof</code></a></li> - <li>L'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof"><code>typeof</code></a></li> -</ul> - -<p> </p> +- L'opérateur [`instanceof`](/fr/docs/Web/JavaScript/Reference/Opérateurs/instanceof) +- L'opérateur [`typeof`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof) diff --git a/files/fr/web/javascript/reference/errors/is_not_iterable/index.md b/files/fr/web/javascript/reference/errors/is_not_iterable/index.md index 1aba992ca7..f2c751c136 100644 --- a/files/fr/web/javascript/reference/errors/is_not_iterable/index.md +++ b/files/fr/web/javascript/reference/errors/is_not_iterable/index.md @@ -9,37 +9,38 @@ tags: translation_of: Web/JavaScript/Reference/Errors/is_not_iterable original_slug: Web/JavaScript/Reference/Erreurs/is_not_iterable --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: 'x' is not iterable (Firefox, Chrome) -TypeError: 'x' is not a function or its return value is not iterable (Chrome) -</pre> + TypeError: 'x' is not iterable (Firefox, Chrome) + TypeError: 'x' is not a function or its return value is not iterable (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}</p> +{{jsxref("TypeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>La valeur passée comme opérande droit de <a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of"><code>for…of</code> </a>ou comme argument d'une fonction telle que {{jsxref("Promise.all")}} ou {{jsxref("TypedArray.from")}} n'est pas <a href="/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration">un objet itérable</a>. Un objet itérable peut être un objet itérable natif tel qu'un objet {{jsxref("Array")}}, {{jsxref("String")}} ou {{jsxref("Map")}} ou le résultat d'un générateur ou un objet qui implémente <a href="/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_«_itérable_»">le protocole itérable</a>.</p> +La valeur passée comme opérande droit de [`for…of` ](/fr/docs/Web/JavaScript/Reference/Instructions/for...of)ou comme argument d'une fonction telle que {{jsxref("Promise.all")}} ou {{jsxref("TypedArray.from")}} n'est pas [un objet itérable](/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration). Un objet itérable peut être un objet itérable natif tel qu'un objet {{jsxref("Array")}}, {{jsxref("String")}} ou {{jsxref("Map")}} ou le résultat d'un générateur ou un objet qui implémente [le protocole itérable](/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_«_itérable_»). -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Parcourir_les_propriétés_d'un_objet">Parcourir les propriétés d'un objet</h3> +### Parcourir les propriétés d'un objet -<p>En JavaScript, les objets ne sont pas itérables car ils n'implémentent pas le <a href="/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_«_itérable_»">protocole itérable</a>. On ne peut donc pas utiliser <code>for...of</code> afin d'en parcourir les propriétés.</p> +En JavaScript, les objets ne sont pas itérables car ils n'implémentent pas le [protocole itérable](/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_«_itérable_»). On ne peut donc pas utiliser `for...of` afin d'en parcourir les propriétés. -<pre class="brush: js example-bad">var obj = { 'France': 'Paris', 'England': 'London' }; +```js example-bad +var obj = { 'France': 'Paris', 'England': 'London' }; for (let p of obj) { // TypeError: obj is not iterable // … } -</pre> +``` -<p>Si on souhaite utiliser un itérateur pour parcourir les propriétés (leurs noms ou leurs valeurs), on pourra utiliser les méthodes {{jsxref("Object.keys")}} ou {{jsxref("Object.entries")}} qui fournissent des itérateurs :</p> +Si on souhaite utiliser un itérateur pour parcourir les propriétés (leurs noms ou leurs valeurs), on pourra utiliser les méthodes {{jsxref("Object.keys")}} ou {{jsxref("Object.entries")}} qui fournissent des itérateurs : -<pre class="brush: js example-good">var obj = { 'France': 'Paris', 'England': 'London' }; +```js example-good +var obj = { 'France': 'Paris', 'England': 'London' }; // On parcourt les noms des propriétés for (let country of Object.keys(obj)) { var capital = obj[country]; @@ -48,11 +49,12 @@ for (let country of Object.keys(obj)) { for (const [country, capital] of Object.entries(obj)) console.log(country, capital); -</pre> +``` -<p>On pourrait également utiliser un objet {{jsxref("Map")}} :</p> +On pourrait également utiliser un objet {{jsxref("Map")}} : -<pre class="brush: js example-good">var map = new Map; +```js example-good +var map = new Map; map.set('France', 'Paris'); map.set('England', 'London'); // On parcourt les noms des propriétés @@ -66,37 +68,40 @@ for (let capital of map.values()) for (const [country, capital] of map.entries()) console.log(country, capital); -</pre> +``` -<h3 id="Itérer_grâce_à_un_générateur">Itérer grâce à un générateur</h3> +### Itérer grâce à un générateur -<p><a href="/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs">Les générateurs</a> sont des fonctions qui, lorsqu'elles sont appelées, produisent des objets itérables.</p> +[Les générateurs](/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs) sont des fonctions qui, lorsqu'elles sont appelées, produisent des objets itérables. -<pre class="brush: js example-bad">function* generate(a, b) { +```js example-bad +function* generate(a, b) { yield a; yield b; } for (let x of generate) // TypeError: generate is not iterable console.log(x); -</pre> +``` -<p>Lorsqu'elles ne sont pas appelées, l'objet {{jsxref("Function")}} correspondant au générateur peut être appelé mais il n'est pass itérable. Il ne faut donc pas oublier d'invoquer le générateur afin de parcourir les valeurs de l'itérateur qu'il produit.</p> +Lorsqu'elles ne sont pas appelées, l'objet {{jsxref("Function")}} correspondant au générateur peut être appelé mais il n'est pass itérable. Il ne faut donc pas oublier d'invoquer le générateur afin de parcourir les valeurs de l'itérateur qu'il produit. -<pre class="brush: js example-good">function* generate(a, b) { +```js example-good +function* generate(a, b) { yield a; yield b; } for (let x of generate(1,2)) console.log(x); -</pre> +``` -<h3 id="Parcourir_un_itérable_spécifique">Parcourir un itérable spécifique</h3> +### Parcourir un itérable spécifique -<p>Les itérables spécifiques (<em>custom iterables</em>) peuvent être créés en implémentant la méthode {{jsxref("Symbol.iterator")}}. En implémentant cette méthode, il faut s'assurer que la valeur renvoyée est un objet qui est un itérateur. Autrement dit, l'objet renvoyé doit posséder une méthode <code>next()</code>.</p> +Les itérables spécifiques (_custom iterables_) peuvent être créés en implémentant la méthode {{jsxref("Symbol.iterator")}}. En implémentant cette méthode, il faut s'assurer que la valeur renvoyée est un objet qui est un itérateur. Autrement dit, l'objet renvoyé doit posséder une méthode `next()`. -<pre class="brush: js example-bad">const monIterableVide = { +```js example-bad +const monIterableVide = { [Symbol.iterator]() { return [] // [] est un iterable mais pas un itérateur // car il n'a pas de méthode next @@ -104,26 +109,25 @@ for (let x of generate(1,2)) } Array.from(monIterableVide); // TypeError: monIterableVide is not iterable -</pre> +``` -<p>Voici une implémentation correcte :</p> +Voici une implémentation correcte : -<pre class="brush: js example-good">const monIterableVide = { +```js example-good +const monIterableVide = { [Symbol.iterator]() { return [][Symbol.iterator]() } } Array.from(monIterableVide); // [] -</pre> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_«_itérable_»">Le protocole itérable</a></li> - <li>{{jsxref("Object.keys")}}</li> - <li>{{jsxref("Object.entries")}}</li> - <li>{{jsxref("Map")}}</li> - <li><a href="/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs#Générateurs">Les générateurs</a></li> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of">for…of</a></code></li> -</ul> +``` + +## Voir aussi + +- [Le protocole itérable](/fr/docs/Web/JavaScript/Reference/Les_protocoles_iteration#Le_protocole_«_itérable_») +- {{jsxref("Object.keys")}} +- {{jsxref("Object.entries")}} +- {{jsxref("Map")}} +- [Les générateurs](/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs#Générateurs) +- [`for…of`](/fr/docs/Web/JavaScript/Reference/Instructions/for...of) diff --git a/files/fr/web/javascript/reference/errors/json_bad_parse/index.md b/files/fr/web/javascript/reference/errors/json_bad_parse/index.md index 800d8fd05f..870dc1812b 100644 --- a/files/fr/web/javascript/reference/errors/json_bad_parse/index.md +++ b/files/fr/web/javascript/reference/errors/json_bad_parse/index.md @@ -10,104 +10,110 @@ tags: translation_of: Web/JavaScript/Reference/Errors/JSON_bad_parse original_slug: Web/JavaScript/Reference/Erreurs/JSON_bad_parse --- -<div>{{jsSidebar("Errors")}}</div> - -<h2 id="Message">Message</h2> - -<pre class="syntaxbox">SyntaxError: JSON.parse: unterminated string literal -SyntaxError: JSON.parse: bad control character in string literal -SyntaxError: JSON.parse: bad character in string literal -SyntaxError: JSON.parse: bad Unicode escape -SyntaxError: JSON.parse: bad escape character -SyntaxError: JSON.parse: unterminated string -SyntaxError: JSON.parse: no number after minus sign -SyntaxError: JSON.parse: unexpected non-digit -SyntaxError: JSON.parse: missing digits after decimal point -SyntaxError: JSON.parse: unterminated fractional number -SyntaxError: JSON.parse: missing digits after exponent indicator -SyntaxError: JSON.parse: missing digits after exponent sign -SyntaxError: JSON.parse: exponent part is missing a number -SyntaxError: JSON.parse: unexpected end of data -SyntaxError: JSON.parse: unexpected keyword -SyntaxError: JSON.parse: unexpected character -SyntaxError: JSON.parse: end of data while reading object contents -SyntaxError: JSON.parse: expected property name or '}' -SyntaxError: JSON.parse: end of data when ',' or ']' was expected -SyntaxError: JSON.parse: expected ',' or ']' after array element -SyntaxError: JSON.parse: end of data when property name was expected -SyntaxError: JSON.parse: expected double-quoted property name -SyntaxError: JSON.parse: end of data after property name when ':' was expected -SyntaxError: JSON.parse: expected ':' after property name in object -SyntaxError: JSON.parse: end of data after property value in object -SyntaxError: JSON.parse: expected ',' or '}' after property value in object -SyntaxError: JSON.parse: expected ',' or '}' after property-value pair in object literal -SyntaxError: JSON.parse: property names must be double-quoted strings -SyntaxError: JSON.parse: expected property name or '}' -SyntaxError: JSON.parse: unexpected character -SyntaxError: JSON.parse: unexpected non-whitespace character after JSON data -SyntaxError: JSON.parse Error: Invalid character at position {0} (Edge) -</pre> - -<h2 id="Type_d'erreur">Type d'erreur</h2> - -<p>{{jsxref("SyntaxError")}}</p> - -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> - -<p>Lorsque la méthode {{jsxref("JSON.parse()")}} analyse (<em>parse</em>) une chaîne de caractères en JSON, cette chaîne doit être du JSON valide et une exception sera levée si la syntaxe est incorrecte.</p> - -<h2 id="Exemples">Exemples</h2> - -<h3 id="JSON.parse()_n'accepte_pas_les_virgules_en_fin_de_tableau"><code>JSON.parse()</code> n'accepte pas les virgules en fin de tableau</h3> - -<p>Les deux lignes qui suivent déclencheront une exception <code>SyntaxError</code> :</p> - -<pre class="brush: js example-bad">JSON.parse('[1, 2, 3, 4, ]'); +{{jsSidebar("Errors")}} + +## Message + + SyntaxError: JSON.parse: unterminated string literal + SyntaxError: JSON.parse: bad control character in string literal + SyntaxError: JSON.parse: bad character in string literal + SyntaxError: JSON.parse: bad Unicode escape + SyntaxError: JSON.parse: bad escape character + SyntaxError: JSON.parse: unterminated string + SyntaxError: JSON.parse: no number after minus sign + SyntaxError: JSON.parse: unexpected non-digit + SyntaxError: JSON.parse: missing digits after decimal point + SyntaxError: JSON.parse: unterminated fractional number + SyntaxError: JSON.parse: missing digits after exponent indicator + SyntaxError: JSON.parse: missing digits after exponent sign + SyntaxError: JSON.parse: exponent part is missing a number + SyntaxError: JSON.parse: unexpected end of data + SyntaxError: JSON.parse: unexpected keyword + SyntaxError: JSON.parse: unexpected character + SyntaxError: JSON.parse: end of data while reading object contents + SyntaxError: JSON.parse: expected property name or '}' + SyntaxError: JSON.parse: end of data when ',' or ']' was expected + SyntaxError: JSON.parse: expected ',' or ']' after array element + SyntaxError: JSON.parse: end of data when property name was expected + SyntaxError: JSON.parse: expected double-quoted property name + SyntaxError: JSON.parse: end of data after property name when ':' was expected + SyntaxError: JSON.parse: expected ':' after property name in object + SyntaxError: JSON.parse: end of data after property value in object + SyntaxError: JSON.parse: expected ',' or '}' after property value in object + SyntaxError: JSON.parse: expected ',' or '}' after property-value pair in object literal + SyntaxError: JSON.parse: property names must be double-quoted strings + SyntaxError: JSON.parse: expected property name or '}' + SyntaxError: JSON.parse: unexpected character + SyntaxError: JSON.parse: unexpected non-whitespace character after JSON data + SyntaxError: JSON.parse Error: Invalid character at position {0} (Edge) + +## Type d'erreur + +{{jsxref("SyntaxError")}} + +## Quel est le problème ? + +Lorsque la méthode {{jsxref("JSON.parse()")}} analyse (_parse_) une chaîne de caractères en JSON, cette chaîne doit être du JSON valide et une exception sera levée si la syntaxe est incorrecte. + +## Exemples + +### `JSON.parse()` n'accepte pas les virgules en fin de tableau + +Les deux lignes qui suivent déclencheront une exception `SyntaxError` : + +```js example-bad +JSON.parse('[1, 2, 3, 4, ]'); JSON.parse('{"foo" : 1, }'); // SyntaxError JSON.parse: unexpected character // at line 1 column 14 of the JSON data -</pre> +``` -<p>Pour que la méthode puisse analyser le JSON correctement, on évitera les virgules en fin de tableau :</p> +Pour que la méthode puisse analyser le JSON correctement, on évitera les virgules en fin de tableau : -<pre class="brush: js example-good">JSON.parse('[1, 2, 3, 4 ]'); -JSON.parse('{"foo" : 1 }');</pre> +```js example-good +JSON.parse('[1, 2, 3, 4 ]'); +JSON.parse('{"foo" : 1 }'); +``` -<h3 id="Les_noms_des_propriétés_doivent_être_entre_double_quotes">Les noms des propriétés doivent être entre double quotes</h3> +### Les noms des propriétés doivent être entre double quotes -<p>On ne peut pas utiliser de quotes simples pour indiquer le nom d'une propriété (ex. <code>'toto'</code>).</p> +On ne peut pas utiliser de quotes simples pour indiquer le nom d'une propriété (ex. `'toto'`). -<pre class="brush: js example-bad">JSON.parse("{'toto' : 1 }"); +```js example-bad +JSON.parse("{'toto' : 1 }"); // SyntaxError: JSON.parse: expected property name or '}' -// at line 1 column 2 of the JSON data</pre> +// at line 1 column 2 of the JSON data +``` -<p>À la place, on écrira <code>"toto"</code> :</p> +À la place, on écrira `"toto"` : -<pre class="brush: js example-good">JSON.parse('{"toto" : 1 }');</pre> +```js example-good +JSON.parse('{"toto" : 1 }'); +``` -<h3 id="Zéros_en_début_de_nombres_et_points_décimaux">Zéros en début de nombres et points décimaux</h3> +### Zéros en début de nombres et points décimaux -<p>On ne peut pas utiliser de zéros en début de nombre (ex. 01). Par ailleurs, les nombres décimaux doivent avoir une partie décimale, on ne peut pas terminer un nombre par un point.</p> +On ne peut pas utiliser de zéros en début de nombre (ex. 01). Par ailleurs, les nombres décimaux doivent avoir une partie décimale, on ne peut pas terminer un nombre par un point. -<pre class="brush: js example-bad">JSON.parse('{"toto" : 01 }'); +```js example-bad +JSON.parse('{"toto" : 01 }'); // SyntaxError: JSON.parse: expected ',' or '}' after property value // in object at line 1 column 2 of the JSON data JSON.parse('{"toto" : 1. }'); // SyntaxError: JSON.parse: unterminated fractional number // at line 1 column 2 of the JSON data -</pre> +``` -<p>Pour que cela fonctionne, on écrira simplement 1 sans 0 devant et au moins un chiffre après le séparateur décimal :</p> +Pour que cela fonctionne, on écrira simplement 1 sans 0 devant et au moins un chiffre après le séparateur décimal : -<pre class="brush: js example-good">JSON.parse('{"toto" : 1 }'); +```js example-good +JSON.parse('{"toto" : 1 }'); JSON.parse('{"toto" : 1.0 }'); -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("JSON")}}</li> - <li>{{jsxref("JSON.parse()")}}</li> - <li>{{jsxref("JSON.stringify()")}}</li> -</ul> +- {{jsxref("JSON")}} +- {{jsxref("JSON.parse()")}} +- {{jsxref("JSON.stringify()")}} diff --git a/files/fr/web/javascript/reference/errors/malformed_formal_parameter/index.md b/files/fr/web/javascript/reference/errors/malformed_formal_parameter/index.md index a06f5cc5c9..bc5d9e5ba0 100644 --- a/files/fr/web/javascript/reference/errors/malformed_formal_parameter/index.md +++ b/files/fr/web/javascript/reference/errors/malformed_formal_parameter/index.md @@ -8,33 +8,33 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Malformed_formal_parameter original_slug: Web/JavaScript/Reference/Erreurs/Malformed_formal_parameter --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: Expected {x} (Edge) -SyntaxError: malformed formal parameter (Firefox) -</pre> + SyntaxError: Expected {x} (Edge) + SyntaxError: malformed formal parameter (Firefox) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}</p> +{{jsxref("SyntaxError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>La méthode {{jsxref("Function()")}} a été utilisée avec au moins deux arguments. Le dernier argument correspond au code source de la nouvelle fonction qui est créée. Les autres arguments sont la liste des arguments passés à la fonction.</p> +La méthode {{jsxref("Function()")}} a été utilisée avec au moins deux arguments. Le dernier argument correspond au code source de la nouvelle fonction qui est créée. Les autres arguments sont la liste des arguments passés à la fonction. -<p>C'est cette liste d'arguments qui est, pour une certaine raison, invalide. Il s'agit peut-être d'un mot-clé (<code>if</code> ou <code>var</code> par exemple) utilisé comme un nom d'argument, ou d'un signe de ponctuation mal placé. Il peut également s'agir d'une valeur invalide comme un nombre ou un objet.</p> +C'est cette liste d'arguments qui est, pour une certaine raison, invalide. Il s'agit peut-être d'un mot-clé (`if` ou `var` par exemple) utilisé comme un nom d'argument, ou d'un signe de ponctuation mal placé. Il peut également s'agir d'une valeur invalide comme un nombre ou un objet. -<h2 id="OK_mais_pourquoi_cette_formulation_étrange">OK mais pourquoi cette formulation étrange ?</h2> +## OK mais pourquoi cette formulation étrange ? -<p>En effet, "Formal parameter" est une manière étrange de dire « argument de fonction ». Le mot "malformed" (malformé) est utilisé car les ingénieurs travaillant sur Firefox engineers apprécient énormément les romans gothiques du XIXe.</p> +En effet, "Formal parameter" est une manière étrange de dire « argument de fonction ». Le mot "malformed" (malformé) est utilisé car les ingénieurs travaillant sur Firefox engineers apprécient énormément les romans gothiques du XIXe. -<h2 id="Examples">Examples</h2> +## Examples -<h3 id="Exemples_invalides">Exemples invalides</h3> +### Exemples invalides -<pre class="brush: js example-bad">var f = Function("x y", "return x + y;"); +```js example-bad +var f = Function("x y", "return x + y;"); // SyntaxError (virgule manquante) var f = Function("x,", "return x;"); @@ -42,11 +42,12 @@ var f = Function("x,", "return x;"); var f = Function(37, "console.log('OK')"); // SyntaxError (des nombres ne peuvent être des noms) -</pre> +``` -<h3 id="Exemples_valides">Exemples valides</h3> +### Exemples valides -<pre class="brush: js example-good"> // Ponctuation correcte +```js example-good + // Ponctuation correcte var f = Function("x, y", "return x + y;"); var f = Function("x", "return x;"); @@ -54,12 +55,10 @@ var f = Function("x", "return x;"); // Voici une alternative plus rapide // si vous pouvez éviter Function var f = function (x) { return x; }; -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("Function()")}}</li> - <li><a href="/fr/docs/Web/JavaScript/Guide/Fonctions">Le chapitre du Guide JavaScript sur les fonctions</a></li> - <li><a href="https://www.gutenberg.org/ebooks/84"><em>Frankenstein</em> par Mary Wollstonecraft Shelley</a> ("<em>Cursed (although I curse myself) be the hands that formed you! You have made me wretched beyond expression. You have left me no power to consider whether I am just to you or not. Begone! Relieve me from the sight of your detested form.</em>")</li> -</ul> +- {{jsxref("Function()")}} +- [Le chapitre du Guide JavaScript sur les fonctions](/fr/docs/Web/JavaScript/Guide/Fonctions) +- [_Frankenstein_ par Mary Wollstonecraft Shelley](https://www.gutenberg.org/ebooks/84) ("_Cursed (although I curse myself) be the hands that formed you! You have made me wretched beyond expression. You have left me no power to consider whether I am just to you or not. Begone! Relieve me from the sight of your detested form._") diff --git a/files/fr/web/javascript/reference/errors/malformed_uri/index.md b/files/fr/web/javascript/reference/errors/malformed_uri/index.md index dfe037e1aa..3a4c4f4d08 100644 --- a/files/fr/web/javascript/reference/errors/malformed_uri/index.md +++ b/files/fr/web/javascript/reference/errors/malformed_uri/index.md @@ -8,60 +8,63 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Malformed_URI original_slug: Web/JavaScript/Reference/Erreurs/Malformed_URI --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">URIError: The URI to be encoded contains invalid character (Edge) -URIError: malformed URI sequence (Firefox) -URIError: URI malformed (Chrome) -</pre> + URIError: The URI to be encoded contains invalid character (Edge) + URIError: malformed URI sequence (Firefox) + URIError: URI malformed (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("URIError")}}</p> +{{jsxref("URIError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Il y a eu une erreur lors de l'encodage ou du décodage de l'URI. Un argument fourni à {{jsxref("decodeURI")}}, {{jsxref("encodeURI")}}, {{jsxref("encodeURIComponent")}} ou à {{jsxref("decodeURIComponent")}} n'était pas valide et la fonction concernée n'a pas pu encoder ou décoder la valeur correctement.</p> +Il y a eu une erreur lors de l'encodage ou du décodage de l'URI. Un argument fourni à {{jsxref("decodeURI")}}, {{jsxref("encodeURI")}}, {{jsxref("encodeURIComponent")}} ou à {{jsxref("decodeURIComponent")}} n'était pas valide et la fonction concernée n'a pas pu encoder ou décoder la valeur correctement. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Encodage">Encodage</h3> +### Encodage -<p>L'encodage permet de remplacer certains caractères par une, deux, trois voire quatre séquences d'échappement qui représente l'encodage UTF-8 du caractère. Une exception {{jsxref("URIError")}} sera levée si on tente d'encoder un caractère <em>surrogate</em> qui ne fait pas partie d'une paire de codets :</p> +L'encodage permet de remplacer certains caractères par une, deux, trois voire quatre séquences d'échappement qui représente l'encodage UTF-8 du caractère. Une exception {{jsxref("URIError")}} sera levée si on tente d'encoder un caractère _surrogate_ qui ne fait pas partie d'une paire de codets : -<pre class="brush: js example-bad">encodeURI('\uD800'); +```js example-bad +encodeURI('\uD800'); // "URIError: malformed URI sequence" encodeURI('\uDFFF'); // "URIError: malformed URI sequence" -</pre> +``` -<p>En revanche, si on dispose de la paire de codets :</p> +En revanche, si on dispose de la paire de codets : -<pre class="brush: js example-good">encodeURI('\uD800\uDFFF'); -// "%F0%90%8F%BF"</pre> +```js example-good +encodeURI('\uD800\uDFFF'); +// "%F0%90%8F%BF" +``` -<h3 id="Décodage">Décodage</h3> +### Décodage -<p>Le décodage permet de remplacer chaque séquence d'échappement dans le composant encodé par le caractère qu'elle représente. S'il n'existe aucun caractère correspondant, une exception sera déclenchée :</p> +Le décodage permet de remplacer chaque séquence d'échappement dans le composant encodé par le caractère qu'elle représente. S'il n'existe aucun caractère correspondant, une exception sera déclenchée : -<pre class="brush: js example-bad">decodeURIComponent('%E0%A4%A'); +```js example-bad +decodeURIComponent('%E0%A4%A'); // "URIError: malformed URI sequence" -</pre> +``` -<p>Avec la valeur d'entrée correcte, on a généralement quelque chose qui ressemble à :</p> +Avec la valeur d'entrée correcte, on a généralement quelque chose qui ressemble à : -<pre class="brush: js example-good">decodeURIComponent('JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B'); -// "JavaScript_шеллы"</pre> +```js example-good +decodeURIComponent('JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B'); +// "JavaScript_шеллы" +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("URIError")}}</li> - <li>{{jsxref("decodeURI")}}</li> - <li>{{jsxref("encodeURI")}}</li> - <li>{{jsxref("encodeURIComponent")}}</li> - <li>{{jsxref("decodeURIComponent")}}</li> -</ul> +- {{jsxref("URIError")}} +- {{jsxref("decodeURI")}} +- {{jsxref("encodeURI")}} +- {{jsxref("encodeURIComponent")}} +- {{jsxref("decodeURIComponent")}} diff --git a/files/fr/web/javascript/reference/errors/missing_bracket_after_list/index.md b/files/fr/web/javascript/reference/errors/missing_bracket_after_list/index.md index c51fef7551..1aa8577010 100644 --- a/files/fr/web/javascript/reference/errors/missing_bracket_after_list/index.md +++ b/files/fr/web/javascript/reference/errors/missing_bracket_after_list/index.md @@ -9,26 +9,26 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Missing_bracket_after_list original_slug: Web/JavaScript/Reference/Erreurs/Missing_bracket_after_list --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: missing ] after element list -</pre> + SyntaxError: missing ] after element list -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}.</p> +{{jsxref("SyntaxError")}}. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Il y a une erreur dans le littéral de tableau qui est uilisé. Il manque un crochet fermant ("<code>]</code>") ou une virgule qui sépare les éléments.</p> +Il y a une erreur dans le littéral de tableau qui est uilisé. Il manque un crochet fermant ("`]`") ou une virgule qui sépare les éléments. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Littéraux_de_tableaux_incomplets">Littéraux de tableaux incomplets</h3> +### Littéraux de tableaux incomplets -<pre class="brush: js example-bad">var liste = [1, 2, +```js example-bad +var liste = [1, 2, var instruments = [ "Ukulele", @@ -37,11 +37,12 @@ var instruments = [ }; var data = [{toto: "truc"} {titi: "bidule"}]; -</pre> +``` -<p>Les versions correctes seraient :</p> +Les versions correctes seraient : -<pre class="brush: js example-good">var liste = [1, 2]; +```js example-good +var liste = [1, 2]; var instruments = [ "Ukulele", @@ -49,10 +50,9 @@ var instruments = [ "Piano" ]; -var data = [{toto: "truc"}, {titi: "bidule"}];</pre> +var data = [{toto: "truc"}, {titi: "bidule"}]; +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("Array")}}</li> -</ul> +- {{jsxref("Array")}} diff --git a/files/fr/web/javascript/reference/errors/missing_colon_after_property_id/index.md b/files/fr/web/javascript/reference/errors/missing_colon_after_property_id/index.md index 9e6595726c..d5170353ac 100644 --- a/files/fr/web/javascript/reference/errors/missing_colon_after_property_id/index.md +++ b/files/fr/web/javascript/reference/errors/missing_colon_after_property_id/index.md @@ -8,71 +8,77 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Missing_colon_after_property_id original_slug: Web/JavaScript/Reference/Erreurs/Missing_colon_after_property_id --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: Expected ':' (Edge) -SyntaxError: missing : after property id (Firefox) -</pre> + SyntaxError: Expected ':' (Edge) + SyntaxError: missing : after property id (Firefox) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}</p> +{{jsxref("SyntaxError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Lorsqu'on crée un objet en utilisant un <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet">initialisateur d'objet</a>, il faut utiliser un deux-points ( : ) afin de séparer les clés des valeurs pour les propriétés de l'objet.</p> +Lorsqu'on crée un objet en utilisant un [initialisateur d'objet](/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet), il faut utiliser un deux-points ( : ) afin de séparer les clés des valeurs pour les propriétés de l'objet. -<pre class="brush: js">var obj = { cleDeLaPropriete: 'valeur' }; -</pre> +```js +var obj = { cleDeLaPropriete: 'valeur' }; +``` -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Deux-points_et_signe_égal">Deux-points et signe égal</h3> +### Deux-points et signe égal -<p>Le code qui suit provoquera une erreur car on utilise un signe égal (=) à la place du deux-points.</p> +Le code qui suit provoquera une erreur car on utilise un signe égal (=) à la place du deux-points. -<pre class="brush: js example-bad">var obj = { cleDeLaPropriete = 'valeur' }; +```js example-bad +var obj = { cleDeLaPropriete = 'valeur' }; // SyntaxError: missing : after property id -</pre> +``` -<p>Pour corriger ce problème, on peut utiliser un deux-points ou bien affecter la nouvelle propriété après avoir créé l'objet :</p> +Pour corriger ce problème, on peut utiliser un deux-points ou bien affecter la nouvelle propriété après avoir créé l'objet : -<pre class="brush: js example-good">var obj = { cleDeLaPropriete: 'valeur' }; +```js example-good +var obj = { cleDeLaPropriete: 'valeur' }; // ou encore : var obj = { }; obj['cleDeLaPropriete'] = 'valeur'; -</pre> +``` -<h3 id="Propriétés_vides">Propriétés vides</h3> +### Propriétés vides -<p>On ne peut pas créer de propriétés vides de cette façon :</p> +On ne peut pas créer de propriétés vides de cette façon : -<pre class="brush: js example-bad">var obj = { cleDeLaPropriete; }; +```js example-bad +var obj = { cleDeLaPropriete; }; // SyntaxError: missing : after property id -</pre> +``` -<p>Si vous souhaitez définir une propriété sans valeur, vous pouvez utiliser le mot-clé {{jsxref("null")}} :</p> +Si vous souhaitez définir une propriété sans valeur, vous pouvez utiliser le mot-clé {{jsxref("null")}} : -<pre class="brush: js example-good">var obj = { cleDeLaPropriete: null };</pre> +```js example-good +var obj = { cleDeLaPropriete: null }; +``` -<h3 id="Propriétés_calculées">Propriétés calculées</h3> +### Propriétés calculées -<p>Si vous souhaitez créer une clé de propriété à partir d'une expression, il faudra utiliser des crochets pour encadrer l'expression (sinon le nom de la propriété ne pourra pas être calculé) :</p> +Si vous souhaitez créer une clé de propriété à partir d'une expression, il faudra utiliser des crochets pour encadrer l'expression (sinon le nom de la propriété ne pourra pas être calculé) : -<pre class="brush: js example-bad">var obj = { 'tr'+'uc': 'toto' }; +```js example-bad +var obj = { 'tr'+'uc': 'toto' }; // SyntaxError: missing : after property id -</pre> +``` -<p>Pour corriger l'erreur, il faudra placer l'expression entre crochets :</p> +Pour corriger l'erreur, il faudra placer l'expression entre crochets : -<pre class="brush: js example-good">var obj = { ['tr'+'uc']: 'toto' };</pre> +```js example-good +var obj = { ['tr'+'uc']: 'toto' }; +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet">Initialisateur d'objet</a></li> -</ul> +- [Initialisateur d'objet](/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet) diff --git a/files/fr/web/javascript/reference/errors/missing_curly_after_function_body/index.md b/files/fr/web/javascript/reference/errors/missing_curly_after_function_body/index.md index c8ee04b3c8..89f612ede3 100644 --- a/files/fr/web/javascript/reference/errors/missing_curly_after_function_body/index.md +++ b/files/fr/web/javascript/reference/errors/missing_curly_after_function_body/index.md @@ -8,61 +8,64 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Missing_curly_after_function_body original_slug: Web/JavaScript/Reference/Erreurs/Missing_curly_after_function_body --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: Expected '}' (Edge) -SyntaxError: missing } after function body (Firefox) -</pre> + SyntaxError: Expected '}' (Edge) + SyntaxError: missing } after function body (Firefox) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}</p> +{{jsxref("SyntaxError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Il y a une erreur de syntaxe près d'une création de fonction. Dans ce cas, il est préférable de vérifier que les parenthèses et accolades fermantes sont bien présentes et dans le bon ordre. Indenter et formater le code peut vous aider à vous y retrouver parmi les éventuels différents niveaux d'imbrication.</p> +Il y a une erreur de syntaxe près d'une création de fonction. Dans ce cas, il est préférable de vérifier que les parenthèses et accolades fermantes sont bien présentes et dans le bon ordre. Indenter et formater le code peut vous aider à vous y retrouver parmi les éventuels différents niveaux d'imbrication. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Oubli_d'une_accolade_fermante">Oubli d'une accolade fermante</h3> +### Oubli d'une accolade fermante -<p>La plupart du temps, il s'agit d'une accolade manquante dans le code de la fonction :</p> +La plupart du temps, il s'agit d'une accolade manquante dans le code de la fonction : -<pre class="brush: js example-bad">var charge = function() { +```js example-bad +var charge = function() { if (soleil) { utiliserPanneauSolaire(); } else { utiliserVelo(); }; -</pre> +``` -<p>La forme correcte est :</p> +La forme correcte est : -<pre class="brush: js example-good">var charge = function() { +```js example-good +var charge = function() { if (soleil) { utiliserPanneauSolaire(); } else { utiliserVelo(); } -};</pre> +}; +``` -<p>Une erreur de ce type peut être moins visible lorsqu'on utilise les fonctions qui sont appelées immédiatement, <a href="/fr/docs/Web/JavaScript/Closures">les fermetures</a> ou d'autres formes qui utilisent de nombreuses parenthèses et/ou accolades comme par exemple :</p> +Une erreur de ce type peut être moins visible lorsqu'on utilise les fonctions qui sont appelées immédiatement, [les fermetures](/fr/docs/Web/JavaScript/Closures) ou d'autres formes qui utilisent de nombreuses parenthèses et/ou accolades comme par exemple : -<pre class="brush: js example-bad">(function() { if (true) { return false; } ); -</pre> +```js example-bad +(function() { if (true) { return false; } ); +``` -<p>Généralement, mettre en forme et vérifier l'indentation permet de repérer ces erreurs.</p> +Généralement, mettre en forme et vérifier l'indentation permet de repérer ces erreurs. -<pre class="brush: js example-good">(function() { +```js example-good +(function() { if (true) { return false; } -});</pre> +}); +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Guide/Fonctions">Les fonctions</a></li> -</ul> +- [Les fonctions](/fr/docs/Web/JavaScript/Guide/Fonctions) diff --git a/files/fr/web/javascript/reference/errors/missing_curly_after_property_list/index.md b/files/fr/web/javascript/reference/errors/missing_curly_after_property_list/index.md index f845a673c6..720e6c5cd4 100644 --- a/files/fr/web/javascript/reference/errors/missing_curly_after_property_list/index.md +++ b/files/fr/web/javascript/reference/errors/missing_curly_after_property_list/index.md @@ -8,46 +8,45 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Missing_curly_after_property_list original_slug: Web/JavaScript/Reference/Erreurs/Missing_curly_after_property_list --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: Expected '}' (Edge) -SyntaxError: missing } after property list (Firefox) -</pre> + SyntaxError: Expected '}' (Edge) + SyntaxError: missing } after property list (Firefox) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}</p> +{{jsxref("SyntaxError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Il y a une coquille dans le <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet">littéral objet</a> utilisé. Cela peut être dû à une accolade manquante ou à une virgule manquante. Il est aussi utile de vérifier que les accolades et les parenthèses sont bien ordonnées. Pour ce type d'erreur, une bonne indentation permet de repérer plus facilement la coquille parmi les lignes de code.</p> +Il y a une coquille dans le [littéral objet](/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet) utilisé. Cela peut être dû à une accolade manquante ou à une virgule manquante. Il est aussi utile de vérifier que les accolades et les parenthèses sont bien ordonnées. Pour ce type d'erreur, une bonne indentation permet de repérer plus facilement la coquille parmi les lignes de code. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Une_virgule_oubliée">Une virgule oubliée</h3> +### Une virgule oubliée -<p>Il arrive parfois que ce soit une virgule absente dans le littéral qui entraîne cette erreur :</p> +Il arrive parfois que ce soit une virgule absente dans le littéral qui entraîne cette erreur : -<pre class="brush: js example-bad">var obj = { +```js example-bad +var obj = { a: 1, b: { maProp: 2 } c: 3 }; -</pre> +``` -<p>La version correcte correspondante est :</p> +La version correcte correspondante est : -<pre class="brush: js example-good">var obj = { +```js example-good +var obj = { a: 1, b: { maProp: 2 }, c: 3 }; -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet">Les littéraux objets</a></li> -</ul> +- [Les littéraux objets](/fr/docs/Web/JavaScript/Reference/Opérateurs/Initialisateur_objet) diff --git a/files/fr/web/javascript/reference/errors/missing_formal_parameter/index.md b/files/fr/web/javascript/reference/errors/missing_formal_parameter/index.md index e5956f0f04..635c238646 100644 --- a/files/fr/web/javascript/reference/errors/missing_formal_parameter/index.md +++ b/files/fr/web/javascript/reference/errors/missing_formal_parameter/index.md @@ -8,28 +8,28 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Missing_formal_parameter original_slug: Web/JavaScript/Reference/Erreurs/Missing_formal_parameter --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: missing formal parameter (Firefox) -</pre> + SyntaxError: missing formal parameter (Firefox) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}</p> +{{jsxref("SyntaxError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>« <em>Formal parameter</em> » (ou « paramètre formel ») est une façon de désigner un paramètre d'une fonction. Ici, certains des paramètres de la fonction sont invalides. Lorsqu'on déclare une fonction, les paramètres doivent être des identifiants et non des valeurs (telles que des nombres, des chaînes de caractères ou des objets). La déclaration et l'appel de la fonction forment deux étapes distinctes. Les déclarations utilisent uniquement des identifiants comme paramètres. Lorsqu'on appelle une fonction, on fournit les valeurs à utiliser.</p> +« _Formal parameter_ » (ou « paramètre formel ») est une façon de désigner un paramètre d'une fonction. Ici, certains des paramètres de la fonction sont invalides. Lorsqu'on déclare une fonction, les paramètres doivent être des identifiants et non des valeurs (telles que des nombres, des chaînes de caractères ou des objets). La déclaration et l'appel de la fonction forment deux étapes distinctes. Les déclarations utilisent uniquement des identifiants comme paramètres. Lorsqu'on appelle une fonction, on fournit les valeurs à utiliser. -<p>En JavaScript, les identifiants peuvent contenir n'importe quel caractère alphanumérique (ou "$" or "_") et ne doivent pas commencer par un nombre. Un identifiant n'est pas une chaîne de caractères, une chaîne de caractères est une donnée alors qu'un identifiant fait partie du code.</p> +En JavaScript, les identifiants peuvent contenir n'importe quel caractère alphanumérique (ou "$" or "\_") et ne doivent pas commencer par un nombre. Un identifiant n'est pas une chaîne de caractères, une chaîne de caractères est une donnée alors qu'un identifiant fait partie du code. -<h2 id="Exemples">Exemples</h2> +## Exemples -<p>Lorsqu'on définit une fonction, les paramètres doivent être des identifiants. Aucune des fonctions suivantes ne répond à ce critère (elles lèvent donc toutes une erreur) car elles utilisent des valeurs :</p> +Lorsqu'on définit une fonction, les paramètres doivent être des identifiants. Aucune des fonctions suivantes ne répond à ce critère (elles lèvent donc toutes une erreur) car elles utilisent des valeurs : -<pre class="brush: js example-bad highlight:[1,6,11]">function carre(3) { +```js example-bad +function carre(3) { return nombre * nombre; }; // SyntaxError: missing formal parameter @@ -43,11 +43,12 @@ function log({ obj: "value"}) { console.log(arg) }; // SyntaxError: missing formal parameter -</pre> +``` -<p>Il faut utiliser des identifiants lors de la déclaration des fonctions :</p> +Il faut utiliser des identifiants lors de la déclaration des fonctions : -<pre class="brush: js example-good highlight:[1,5,9]">function carre(nombre) { +```js example-good +function carre(nombre) { return nombre * nombre; }; @@ -57,22 +58,20 @@ function salutation(salut) { function log(arg) { console.log(arg) -};</pre> +}; +``` -<p>Ensuite, on pourra appeler ces fonctions avec les arguments voulus :</p> +Ensuite, on pourra appeler ces fonctions avec les arguments voulus : -<pre class="brush: js">carre(2); // 4 +```js +carre(2); // 4 salutation("Coucou"); // "Coucou" log({obj: "value"}); // Object { obj: "value" } -</pre> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>Les autres erreurs relatives aux paramètres formels : - <ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Errors/Malformed_formal_parameter">SyntaxError: Malformed formal parameter</a></li> - <li><a href="/fr/docs/Web/JavaScript/Reference/Errors/Redeclared_parameter">SyntaxError: redeclaration of formal parameter "x"</a></li> - </ul> - </li> -</ul> +``` + +## Voir aussi + +- Les autres erreurs relatives aux paramètres formels : + + - [SyntaxError: Malformed formal parameter](/fr/docs/Web/JavaScript/Reference/Errors/Malformed_formal_parameter) + - [SyntaxError: redeclaration of formal parameter "x"](/fr/docs/Web/JavaScript/Reference/Errors/Redeclared_parameter) diff --git a/files/fr/web/javascript/reference/errors/missing_initializer_in_const/index.md b/files/fr/web/javascript/reference/errors/missing_initializer_in_const/index.md index e368d0982c..5110b755a0 100644 --- a/files/fr/web/javascript/reference/errors/missing_initializer_in_const/index.md +++ b/files/fr/web/javascript/reference/errors/missing_initializer_in_const/index.md @@ -8,53 +8,55 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Missing_initializer_in_const original_slug: Web/JavaScript/Reference/Erreurs/Missing_initializer_in_const --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: Const must be initalized (Edge) -SyntaxError: missing = in const declaration (Firefox) -SyntaxError: Missing initializer in const declaration (Chrome) -</pre> + SyntaxError: Const must be initalized (Edge) + SyntaxError: missing = in const declaration (Firefox) + SyntaxError: Missing initializer in const declaration (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}</p> +{{jsxref("SyntaxError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Une constante est une valeur qui ne peut pas être modifiée par le programme pendant l'exécution. Elle ne peut pas être changée avec une réaffectation ou une redéclaration. En JavaScript, les constantes sont déclarées grâce au mot-clé <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/const">const</a></code>. Il est également nécessaire de fournir une valeur d'initialisation dans l'instruction où on déclare la constante (ce qui est logique vu qu'on ne peut pas la modifier ensuite).</p> +Une constante est une valeur qui ne peut pas être modifiée par le programme pendant l'exécution. Elle ne peut pas être changée avec une réaffectation ou une redéclaration. En JavaScript, les constantes sont déclarées grâce au mot-clé [`const`](/fr/docs/Web/JavaScript/Reference/Instructions/const). Il est également nécessaire de fournir une valeur d'initialisation dans l'instruction où on déclare la constante (ce qui est logique vu qu'on ne peut pas la modifier ensuite). -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Valeur_d'initialisation_manquante">Valeur d'initialisation manquante</h3> +### Valeur d'initialisation manquante -<p>À la différence de <code>var</code> ou de <code>let</code>, il est nécessaire d'indiquer une valeur lors de la déclaration. Si aucune valeur n'est indiquée, une exception sera levée :</p> +À la différence de `var` ou de `let`, il est nécessaire d'indiquer une valeur lors de la déclaration. Si aucune valeur n'est indiquée, une exception sera levée : -<pre class="brush: js example-bad">const COLUMNS; -// SyntaxError: missing = in const declaration</pre> +```js example-bad +const COLUMNS; +// SyntaxError: missing = in const declaration +``` -<h3 id="Résoudre_le_problème">Résoudre le problème</h3> +### Résoudre le problème -<p>On a le choix entre plusieurs options pour résoudre ce problème. Il faut comprendre le rôle de la constante en question.</p> +On a le choix entre plusieurs options pour résoudre ce problème. Il faut comprendre le rôle de la constante en question. -<h4 id="Ajouter_une_valeur_constante">Ajouter une valeur constante</h4> +#### Ajouter une valeur constante -<p>On peut indiquer la valeur de la constante dans la même instruction :</p> +On peut indiquer la valeur de la constante dans la même instruction : -<pre class="brush: js example-good">const COLONNES = 80;</pre> +```js example-good +const COLONNES = 80; +``` -<h4 id="const_let_ou_var"><code>const</code>, <code>let</code> ou <code>var</code> ?</h4> +#### `const`, `let` ou `var` ? -<p><code>const</code> ne doit pas être utilisé si on ne souhaite pas déclarer de constante. Peut-être qu'on souhaite simplement déclarer une variable avec une portée de bloc grâce à <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/let">let</a></code> ou une variable globale avec <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code>. Ces deux instructions ne nécessitent pas de valeur initiale.</p> +`const` ne doit pas être utilisé si on ne souhaite pas déclarer de constante. Peut-être qu'on souhaite simplement déclarer une variable avec une portée de bloc grâce à [`let`](/fr/docs/Web/JavaScript/Reference/Instructions/let) ou une variable globale avec [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var). Ces deux instructions ne nécessitent pas de valeur initiale. -<pre class="brush: js example-good">let colonnes; -</pre> +```js example-good +let colonnes; +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/const">const</a></code></li> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/let">let</a></code></li> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code></li> -</ul> +- [`const`](/fr/docs/Web/JavaScript/Reference/Instructions/const) +- [`let`](/fr/docs/Web/JavaScript/Reference/Instructions/let) +- [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var) diff --git a/files/fr/web/javascript/reference/errors/missing_name_after_dot_operator/index.md b/files/fr/web/javascript/reference/errors/missing_name_after_dot_operator/index.md index d46591c96f..d777c273e3 100644 --- a/files/fr/web/javascript/reference/errors/missing_name_after_dot_operator/index.md +++ b/files/fr/web/javascript/reference/errors/missing_name_after_dot_operator/index.md @@ -8,28 +8,28 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Missing_name_after_dot_operator original_slug: Web/JavaScript/Reference/Erreurs/Missing_name_after_dot_operator --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: missing name after . operator -</pre> + SyntaxError: missing name after . operator -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}</p> +{{jsxref("SyntaxError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>L'opérateur <code>.</code> (le point) est utilisé pour <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres">accéder aux propriétés d'un objet</a>. Il est nécessaire d'indiquer le nom de la propriété à laquelle on souhaite accéder. Pour les propriétés dont le nom est calculé, il est préférable d'utiliser les crochets pour encadrer le nom. Cela permet de calculer une expression dont le résultat sera le nom de la propriété recherchée. Peut-être cherchiez-vous à utiliser l'opérateur de concaténation ? C'est l'opérateur <code>+</code> qu'il faut utiliser dans ce cas. Pour plus de détails, voir les exemples ci-après.</p> +L'opérateur `.` (le point) est utilisé pour [accéder aux propriétés d'un objet](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres). Il est nécessaire d'indiquer le nom de la propriété à laquelle on souhaite accéder. Pour les propriétés dont le nom est calculé, il est préférable d'utiliser les crochets pour encadrer le nom. Cela permet de calculer une expression dont le résultat sera le nom de la propriété recherchée. Peut-être cherchiez-vous à utiliser l'opérateur de concaténation ? C'est l'opérateur `+` qu'il faut utiliser dans ce cas. Pour plus de détails, voir les exemples ci-après. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Accéder_à_une_propriété">Accéder à une propriété</h3> +### Accéder à une propriété -<p><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres">Pour accéder à une propriété</a> en JavaScript, on utilise le point (.) ou les crochets (<code>[]</code>) mais pas une combinaison des deux. Les crochets sont notamment utiles lorsqu'on souhaite accéder à des propriétés dont le nom est calculé.</p> +[Pour accéder à une propriété](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres) en JavaScript, on utilise le point (.) ou les crochets (`[]`) mais pas une combinaison des deux. Les crochets sont notamment utiles lorsqu'on souhaite accéder à des propriétés dont le nom est calculé. -<pre class="brush: js example-bad">var obj = { toto: { truc: "bidule", machin2: "bidule2" } }; +```js example-bad +var obj = { toto: { truc: "bidule", machin2: "bidule2" } }; var i = 2; obj.[toto].[truc] @@ -37,11 +37,12 @@ obj.[toto].[truc] obj.toto."machin"+i; // SyntaxError: missing name after . operator -</pre> +``` -<p>Pour corriger ce fragment de code, on pourra accéder aux propriétés de la façon suivante :</p> +Pour corriger ce fragment de code, on pourra accéder aux propriétés de la façon suivante : -<pre class="brush: js example-good">obj.toto.truc; // "bidule" +```js example-good +obj.toto.truc; // "bidule" // ou autrement obj["toto"]["truc"]; // "bidule" @@ -49,22 +50,24 @@ obj["toto"]["truc"]; // "bidule" // nom est calculé, il faut les // crochets obj.toto["machin" + i]; // "bidule2" -</pre> +``` -<h3 id="Accéder_à_une_propriété_ou_concaténer">Accéder à une propriété ou concaténer ?</h3> +### Accéder à une propriété ou concaténer ? -<p>Si vous avez l'habitude de développer en utilisant un autre langage de programmation tel que {{Glossary("PHP")}}, il est possible de mélanger certains opérateurs et d'utiliser le point comme opérateur de concaténation, qui est l'opérateur <code>+</code> en JavaScript :</p> +Si vous avez l'habitude de développer en utilisant un autre langage de programmation tel que {{Glossary("PHP")}}, il est possible de mélanger certains opérateurs et d'utiliser le point comme opérateur de concaténation, qui est l'opérateur `+` en JavaScript : -<pre class="brush: js example-bad">console.log("Coucou " . "monde"); +```js example-bad +console.log("Coucou " . "monde"); -// SyntaxError: missing name after . operator</pre> +// SyntaxError: missing name after . operator +``` -<p>À la place, on écrira :</p> +À la place, on écrira : -<pre class="brush: js example-good">console.log("Coucou " + "monde");</pre> +```js example-good +console.log("Coucou " + "monde"); +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres">Les accesseurs de propriété</a></li> -</ul> +- [Les accesseurs de propriété](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres) diff --git a/files/fr/web/javascript/reference/errors/missing_parenthesis_after_argument_list/index.md b/files/fr/web/javascript/reference/errors/missing_parenthesis_after_argument_list/index.md index f59707b152..b9bf2d9afb 100644 --- a/files/fr/web/javascript/reference/errors/missing_parenthesis_after_argument_list/index.md +++ b/files/fr/web/javascript/reference/errors/missing_parenthesis_after_argument_list/index.md @@ -8,50 +8,53 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Missing_parenthesis_after_argument_list original_slug: Web/JavaScript/Reference/Erreurs/Missing_parenthesis_after_argument_list --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: Expected ')' (Edge) -SyntaxError: missing ) after argument list (Firefox) -</pre> + SyntaxError: Expected ')' (Edge) + SyntaxError: missing ) after argument list (Firefox) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}.</p> +{{jsxref("SyntaxError")}}. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p> </p> -<p>Il y a une erreur avec la façon dont une fonction est appelée . Cela peut être une faute de frappe, un opérateur manquant, ou une chaîne non-échappée, par exemple .</p> -<h2 id="Exemple">Exemple</h2> +Il y a une erreur avec la façon dont une fonction est appelée . Cela peut être une faute de frappe, un opérateur manquant, ou une chaîne non-échappée, par exemple . -<p>Parce qu'il n'y a pas d'opérateur "+" pour concaténer la chaîne de caractères, JavaScript s'attend à trouver une parenthèse après "PI : ", qu'il considère comme l'argument de la fonction <code>log. </code></p> +## Exemple -<pre class="brush: js example-bad">console.log("PI: " Math.PI); +Parce qu'il n'y a pas d'opérateur "+" pour concaténer la chaîne de caractères, JavaScript s'attend à trouver une parenthèse après "PI : ", qu'il considère comme l'argument de la fonction `log. ` + +```js example-bad +console.log("PI: " Math.PI); // SyntaxError: missing ) after argument list -</pre> +``` -<p>La fonction <code>log</code> peut être corrigée en ajoutant un opérateur "+".</p> +La fonction `log` peut être corrigée en ajoutant un opérateur "+". -<pre class="brush: js example-good">console.log("PI: " + Math.PI); -// "PI: 3.141592653589793"</pre> +```js example-good +console.log("PI: " + Math.PI); +// "PI: 3.141592653589793" +``` -<h3 id="Chaînes_non_terminées">Chaînes non terminées</h3> +### Chaînes non terminées -<pre class="brush: js example-bad">console.log('"Java" + "Script" = \"' + 'Java' + 'Script\"); -// SyntaxError: missing ) after argument list</pre> +```js example-bad +console.log('"Java" + "Script" = \"' + 'Java' + 'Script\"); +// SyntaxError: missing ) after argument list +``` -<p>Dans cet exemple, le moteur JavaScript considère qu'on souhaitait avoir <code>);</code> dans la chaîne de caractères et l'ignore. Aussi, le moteur considère que l'appelle à <code>console.log</code> n'est pas terminé et qu'il manque une parenthèse fermante. Pour corriger ce problème, on peut rajouter une quote <code>'</code> après la chaîne de caractères <code>"Script"</code> :</p> +Dans cet exemple, le moteur JavaScript considère qu'on souhaitait avoir `);` dans la chaîne de caractères et l'ignore. Aussi, le moteur considère que l'appelle à `console.log` n'est pas terminé et qu'il manque une parenthèse fermante. Pour corriger ce problème, on peut rajouter une quote `'` après la chaîne de caractères `"Script"` : -<pre class="brush: js example-good">console.log('"Java" + "Script" = \"' + 'Java' + 'Script\"'); +```js example-good +console.log('"Java" + "Script" = \"' + 'Java' + 'Script\"'); // '"Java" + "Script" = "JavaScript"' -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Guide/Functions">Functions</a></li> -</ul> +- [Functions](/fr/docs/Web/JavaScript/Guide/Functions) diff --git a/files/fr/web/javascript/reference/errors/missing_parenthesis_after_condition/index.md b/files/fr/web/javascript/reference/errors/missing_parenthesis_after_condition/index.md index 52018f1d8d..f1afdee5d9 100644 --- a/files/fr/web/javascript/reference/errors/missing_parenthesis_after_condition/index.md +++ b/files/fr/web/javascript/reference/errors/missing_parenthesis_after_condition/index.md @@ -8,64 +8,67 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Missing_parenthesis_after_condition original_slug: Web/JavaScript/Reference/Erreurs/Missing_parenthesis_after_condition --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: Expected ')' (Edge) -SyntaxError: missing ) after condition (Firefox) -</pre> + SyntaxError: Expected ')' (Edge) + SyntaxError: missing ) after condition (Firefox) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}</p> +{{jsxref("SyntaxError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Il y a une erreur pour la condition écrite dans l'instruction <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/if...else">if</a></code>. Pour chaque langage de programmation, on utilise des instructions pour choisir quel bloc d'instructions exécuter selon les différentes entrées. L'instruction <code>if</code> permet d'exécuter une instruction si une condition donnée est vérifiée. En JavaScript, il faut que cette condition apparaisse entre parenthèses après le mot-clé <code>if</code> :</p> +Il y a une erreur pour la condition écrite dans l'instruction [`if`](/fr/docs/Web/JavaScript/Reference/Instructions/if...else). Pour chaque langage de programmation, on utilise des instructions pour choisir quel bloc d'instructions exécuter selon les différentes entrées. L'instruction `if` permet d'exécuter une instruction si une condition donnée est vérifiée. En JavaScript, il faut que cette condition apparaisse entre parenthèses après le mot-clé `if` : -<pre class="brush: js">if (condition) { +```js +if (condition) { // faire quelque chose si la condition est vraie -}</pre> +} +``` -<h2 id="Exemples">Exemples</h2> +## Exemples -<p>Il s'agit peut-être simplement d'une coquille et il suffit alors de vérifier les parenthèses (ou plutôt leur absence) :</p> +Il s'agit peut-être simplement d'une coquille et il suffit alors de vérifier les parenthèses (ou plutôt leur absence) : -<pre class="brush: js example-bad">if (3 > Math.PI { +```js example-bad +if (3 > Math.PI { console.log("Pardon ?"); } // SyntaxError: missing ) after condition -</pre> +``` -<p>Pour corriger ce fragment de code, on ajoutera une parenthèse pour fermer la condition :</p> +Pour corriger ce fragment de code, on ajoutera une parenthèse pour fermer la condition : -<pre class="brush: js example-good">if (3 > Math.PI) { +```js example-good +if (3 > Math.PI) { console.log("Pardon ?"); -}</pre> +} +``` -<p>Si vous avez l'habitude d'utiliser un autre langage de programmation, peut-être avez-vous utilisé un mot-clé qui n'existe pas en JavaScript ?</p> +Si vous avez l'habitude d'utiliser un autre langage de programmation, peut-être avez-vous utilisé un mot-clé qui n'existe pas en JavaScript ? -<pre class="brush: js example-bad">if (done is true) { +```js example-bad +if (done is true) { console.log("we are done!"); } // SyntaxError: missing ) after condition -</pre> +``` -<p>Pour corriger cette erreur, on utilisera <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison">un opérateur de comparaison</a> correct :</p> +Pour corriger cette erreur, on utilisera [un opérateur de comparaison](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison) correct : -<pre class="brush: js example-good">if (done === true) { +```js example-good +if (done === true) { console.log("Et voilà !"); -}</pre> +} +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/if...else">if...else</a></code></li> - <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison">Les opérateurs de comparaisons</a></li> - <li> - <p><a href="/fr/docs/Learn/JavaScript/Building_blocks/conditionals">Choisir quel code exécuter : les structures conditionnelles</a></p> - </li> -</ul> +- [`if...else`](/fr/docs/Web/JavaScript/Reference/Instructions/if...else) +- [Les opérateurs de comparaisons](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison) +- [Choisir quel code exécuter : les structures conditionnelles](/fr/docs/Learn/JavaScript/Building_blocks/conditionals) diff --git a/files/fr/web/javascript/reference/errors/missing_semicolon_before_statement/index.md b/files/fr/web/javascript/reference/errors/missing_semicolon_before_statement/index.md index cb9e5c0312..9ef0310199 100644 --- a/files/fr/web/javascript/reference/errors/missing_semicolon_before_statement/index.md +++ b/files/fr/web/javascript/reference/errors/missing_semicolon_before_statement/index.md @@ -9,76 +9,82 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Missing_semicolon_before_statement original_slug: Web/JavaScript/Reference/Erreurs/Missing_semicolon_before_statement --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: Expected ';' (Edge) -SyntaxError: missing ; before statement (Firefox) -</pre> + SyntaxError: Expected ';' (Edge) + SyntaxError: missing ; before statement (Firefox) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}.</p> +{{jsxref("SyntaxError")}}. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Un point-virgule est absent quelque part. En JavaScript, <a href="/fr/docs/Web/JavaScript/Reference/Instructions">les instructions doivent se terminer par des points-virgules</a>. Certaines de ces instructions sont traitées par <a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Insertion_automatique_de_points-virgules">l'insertion automatique de point-virgule (<em>ASI</em> pour <em>Automatic Semicolon Insertion)</em></a>, mais pour le code qui provoque l'erreur, un point-virgule est nécessaire afin que le moteur JavaScript puisse analyser le code source correctement.</p> +Un point-virgule est absent quelque part. En JavaScript, [les instructions doivent se terminer par des points-virgules](/fr/docs/Web/JavaScript/Reference/Instructions). Certaines de ces instructions sont traitées par [l'insertion automatique de point-virgule (_ASI_ pour _Automatic Semicolon Insertion)_](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Insertion_automatique_de_points-virgules), mais pour le code qui provoque l'erreur, un point-virgule est nécessaire afin que le moteur JavaScript puisse analyser le code source correctement. -<p>La plupart du temps, cette erreur est la conséquence d'une autre erreur : ne pas « fermer » les chaînes de caractères correctement ou utiliser <code>var</code> de façon incorrecte. Il peut également y avoir trop de parenthèses à un endroit. Lorsque cette erreur apparaît, faites attention à la syntaxe du code environnant.</p> +La plupart du temps, cette erreur est la conséquence d'une autre erreur : ne pas « fermer » les chaînes de caractères correctement ou utiliser `var` de façon incorrecte. Il peut également y avoir trop de parenthèses à un endroit. Lorsque cette erreur apparaît, faites attention à la syntaxe du code environnant. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Les_chaînes_laissées_ouvertes">Les chaînes laissées ouvertes</h3> +### Les chaînes laissées ouvertes -<p>Cette erreur est parfois simplement provoquée par une chaîne dont les quotes ne sont pas échappées correctement ou qui ne sont pas correctement délimitées. Le moteur JavaScript s'attend donc à trouver la fin de la chaîne. Par exemple :</p> +Cette erreur est parfois simplement provoquée par une chaîne dont les quotes ne sont pas échappées correctement ou qui ne sont pas correctement délimitées. Le moteur JavaScript s'attend donc à trouver la fin de la chaîne. Par exemple : -<pre class="brush: js example-bad">var toto = 'Ouvrir l'œil'; -// SyntaxError: missing ; before statement</pre> +```js example-bad +var toto = 'Ouvrir l'œil'; +// SyntaxError: missing ; before statement +``` -<p>Pour éviter cela, on pourra utiliser des doubles quotes ou échapper l'apostrophe :</p> +Pour éviter cela, on pourra utiliser des doubles quotes ou échapper l'apostrophe : -<pre class="brush: js example-good">var toto = "Ouvrir l'œil"; +```js example-good +var toto = "Ouvrir l'œil"; var toto = 'Ouvrir l\'œil'; -</pre> +``` -<h3 id="Déclarer_des_propriétés_avec_var">Déclarer des propriétés avec <code>var</code></h3> +### Déclarer des propriétés avec `var` -<p>On <strong>ne peut pas</strong> déclarer de propriétés sur un objet ou un tableau avec une déclaration <code>var</code>.</p> +On **ne peut pas** déclarer de propriétés sur un objet ou un tableau avec une déclaration `var`. -<pre class="brush: js example-bad">var obj = {}; +```js example-bad +var obj = {}; var obj.toto = "coucou"; // SyntaxError missing ; before statement var array = []; var array[0] = "monde"; // SyntaxError missing ; before statement -</pre> +``` -<p>Pour éviter cela, on n'utilisera pas le mot-clé <code>var</code> qui est inutile dans ces cas :</p> +Pour éviter cela, on n'utilisera pas le mot-clé `var` qui est inutile dans ces cas : -<pre class="brush: js example-good">var obj = {}; +```js example-good +var obj = {}; obj.toto = "coucou"; var array = []; array[0] = "monde"; -</pre> +``` -<h3 id="Mauvais_mots-clés">Mauvais mots-clés</h3> +### Mauvais mots-clés -<p>Il peut arriver, notamment lorsqu'on provient d'un autre langage de programmation, d'utiliser des mots-clés qui n'ont pas du tout le même sens en JavaScript :</p> +Il peut arriver, notamment lorsqu'on provient d'un autre langage de programmation, d'utiliser des mots-clés qui n'ont pas du tout le même sens en JavaScript : -<pre class="brush: js example-bad">def print(info){ +```js example-bad +def print(info){ console.log(info); -}; // SyntaxError missing ; before statement</pre> +}; // SyntaxError missing ; before statement +``` -<p>À la place de <code>def</code>, on utilisera le mot-clé <code>function</code> :</p> +À la place de `def`, on utilisera le mot-clé `function` : -<pre class="brush: js example-good">function print(info){ +```js example-good +function print(info){ console.log(info); -};</pre> +}; +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Insertion_automatique_de_points-virgules">L'insertion automatique de points-virgules</a></li> - <li><a href="/fr/docs/Web/JavaScript/Reference/Instructions">Les instructions JavaScript</a></li> -</ul> +- [L'insertion automatique de points-virgules](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Insertion_automatique_de_points-virgules) +- [Les instructions JavaScript](/fr/docs/Web/JavaScript/Reference/Instructions) diff --git a/files/fr/web/javascript/reference/errors/more_arguments_needed/index.md b/files/fr/web/javascript/reference/errors/more_arguments_needed/index.md index 3417499581..7175be5198 100644 --- a/files/fr/web/javascript/reference/errors/more_arguments_needed/index.md +++ b/files/fr/web/javascript/reference/errors/more_arguments_needed/index.md @@ -8,43 +8,43 @@ tags: translation_of: Web/JavaScript/Reference/Errors/More_arguments_needed original_slug: Web/JavaScript/Reference/Erreurs/More_arguments_needed --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: argument is not an Object and is not null (Edge) -TypeError: Object.create requires at least 1 argument, but only 0 were passed -TypeError: Object.setPrototypeOf requires at least 2 arguments, but only 0 were passed -TypeError: Object.defineProperties requires at least 1 argument, but only 0 were passed -</pre> + TypeError: argument is not an Object and is not null (Edge) + TypeError: Object.create requires at least 1 argument, but only 0 were passed + TypeError: Object.setPrototypeOf requires at least 2 arguments, but only 0 were passed + TypeError: Object.defineProperties requires at least 1 argument, but only 0 were passed -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}.</p> +{{jsxref("TypeError")}}. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Lors de l'appel de la fonction, il y a eu une erreur due au manque d'argument. La fonction doit recevoir plus de paramètres afin de pouvoir fonctionner.</p> +Lors de l'appel de la fonction, il y a eu une erreur due au manque d'argument. La fonction doit recevoir plus de paramètres afin de pouvoir fonctionner. -<h2 id="Exemples">Exemples</h2> +## Exemples -<p>La méthode {{jsxref("Object.create()")}} nécessite au moins un argument et {{jsxref("Object.setPrototypeOf()")}} requiert deux paramètres :</p> +La méthode {{jsxref("Object.create()")}} nécessite au moins un argument et {{jsxref("Object.setPrototypeOf()")}} requiert deux paramètres : -<pre class="brush: js example-bad">var obj = Object.create(); +```js example-bad +var obj = Object.create(); // TypeError: Object.create requires more than 0 arguments var obj = Object.setPrototypeOf({}); // TypeError: Object.setPrototypeOf requires more than 1 argument -</pre> +``` -<p>On peut corriger cet exemple en utilisant {{jsxref("null")}} comme prototype :</p> +On peut corriger cet exemple en utilisant {{jsxref("null")}} comme prototype : -<pre class="brush: js example-good">var obj = Object.create(null); +```js example-good +var obj = Object.create(null); -var obj = Object.setPrototypeOf({}, null);</pre> +var obj = Object.setPrototypeOf({}, null); +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Guide/Fonctions">Les fonctions</a></li> -</ul> +- [Les fonctions](/fr/docs/Web/JavaScript/Guide/Fonctions) diff --git a/files/fr/web/javascript/reference/errors/negative_repetition_count/index.md b/files/fr/web/javascript/reference/errors/negative_repetition_count/index.md index 2b653b11f0..e4f0865fbe 100644 --- a/files/fr/web/javascript/reference/errors/negative_repetition_count/index.md +++ b/files/fr/web/javascript/reference/errors/negative_repetition_count/index.md @@ -8,39 +8,39 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Negative_repetition_count original_slug: Web/JavaScript/Reference/Erreurs/Negative_repetition_count --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">RangeError: argument out of range (Edge) -RangeError: repeat count must be non-negative (Firefox) -RangeError: Invalid count value (Chrome) -</pre> + RangeError: argument out of range (Edge) + RangeError: repeat count must be non-negative (Firefox) + RangeError: Invalid count value (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("RangeError")}}</p> +{{jsxref("RangeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>La méthode {{jsxref("String.prototype.repeat()")}} a été utilisée avec un argument négatif. Or, cet argument doit être compris dans l'intervalle [0, +∞).</p> +La méthode {{jsxref("String.prototype.repeat()")}} a été utilisée avec un argument négatif. Or, cet argument doit être compris dans l'intervalle \[0, +∞). -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Exemples_invalides">Exemples invalides</h3> +### Exemples invalides -<pre class="brush: js example-bad">'abc'.repeat(-1); // RangeError </pre> +```js example-bad +'abc'.repeat(-1); // RangeError +``` -<h3 id="Exemples_valides">Exemples valides</h3> +### Exemples valides -<pre class="brush: js example-good">'abc'.repeat(0); // '' +```js example-good +'abc'.repeat(0); // '' 'abc'.repeat(1); // 'abc' 'abc'.repeat(2); // 'abcabc' 'abc'.repeat(3.5); // 'abcabcabc' (converti en entier) -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("String.prototype.repeat()")}}</li> -</ul> +- {{jsxref("String.prototype.repeat()")}} diff --git a/files/fr/web/javascript/reference/errors/no_non-null_object/index.md b/files/fr/web/javascript/reference/errors/no_non-null_object/index.md index 2dd59d1667..d635131c4b 100644 --- a/files/fr/web/javascript/reference/errors/no_non-null_object/index.md +++ b/files/fr/web/javascript/reference/errors/no_non-null_object/index.md @@ -8,60 +8,62 @@ tags: translation_of: Web/JavaScript/Reference/Errors/No_non-null_object original_slug: Web/JavaScript/Reference/Erreurs/No_non-null_object --- -<div>{{JSSidebar("Errors")}}</div> +{{JSSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: Invalid descriptor for property {x} (Edge) -TypeError: "x" is not a non-null object (Firefox) -TypeError: Property description must be an object: "x" (Chrome) -TypeError: Invalid value used in weak set (Chrome) -</pre> + TypeError: Invalid descriptor for property {x} (Edge) + TypeError: "x" is not a non-null object (Firefox) + TypeError: Property description must be an object: "x" (Chrome) + TypeError: Invalid value used in weak set (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}</p> +{{jsxref("TypeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Un objet devrait être trouvé et n'est pas fourni. La valeur {{jsxref("null")}} n'est pas un objet et ne fonctionnera pas, il est nécessaire de fournir un véritable objet pour que le code en question fonctionne.</p> +Un objet devrait être trouvé et n'est pas fourni. La valeur {{jsxref("null")}} n'est pas un objet et ne fonctionnera pas, il est nécessaire de fournir un véritable objet pour que le code en question fonctionne. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Absence_d'un_descripteur_de_propriété">Absence d'un descripteur de propriété</h3> +### Absence d'un descripteur de propriété -<p>Lorsqu'on utilise des méthodes telles que {{jsxref("Object.create()")}}, {{jsxref("Object.defineProperty()")}} ou {{jsxref("Object.defineProperties()")}}, le paramètre optionnel de description des propriétés doit être un descripteur sous la forme d'un objet. Si la valeur fournie n'est pas un objet (mais par exemple un nombre), l'appel à la méthode déclenchera une erreur :</p> +Lorsqu'on utilise des méthodes telles que {{jsxref("Object.create()")}}, {{jsxref("Object.defineProperty()")}} ou {{jsxref("Object.defineProperties()")}}, le paramètre optionnel de description des propriétés doit être un descripteur sous la forme d'un objet. Si la valeur fournie n'est pas un objet (mais par exemple un nombre), l'appel à la méthode déclenchera une erreur : -<pre class="brush: js example-bad">Object.defineProperty({}, 'cle', 1); +```js example-bad +Object.defineProperty({}, 'cle', 1); // TypeError: 1 is not a non-null object Object.defineProperty({}, 'cle', null); // TypeError: null is not a non-null object -</pre> +``` -<p>Un descripteur de propriété valide aura la structure suivante :</p> +Un descripteur de propriété valide aura la structure suivante : -<pre class="brush: js example-good">Object.defineProperty({}, 'cle', { value: 'toto', writable: false }); -</pre> +```js example-good +Object.defineProperty({}, 'cle', { value: 'toto', writable: false }); +``` -<h3 id="Les_clés_de_WeakMap_et_WeakSet_sont_des_objets">Les clés de <code>WeakMap</code> et <code>WeakSet</code> sont des objets</h3> +### Les clés de `WeakMap` et `WeakSet` sont des objets -<p>Les objets {{jsxref("WeakMap")}} et {{jsxref("WeakSet")}} utilisent des objets comme clé. On ne peut pas utiliser d'autres types de valeurs pour les clés de ces objets.</p> +Les objets {{jsxref("WeakMap")}} et {{jsxref("WeakSet")}} utilisent des objets comme clé. On ne peut pas utiliser d'autres types de valeurs pour les clés de ces objets. -<pre class="brush: js example-bad">var ws = new WeakSet(); +```js example-bad +var ws = new WeakSet(); ws.add('toto'); -// TypeError: "toto" is not a non-null object</pre> +// TypeError: "toto" is not a non-null object +``` -<p>À la place, on utilisera des objets :</p> +À la place, on utilisera des objets : -<pre class="brush: js example-good">ws.add({toto: 'truc'}); +```js example-good +ws.add({toto: 'truc'}); ws.add(window); -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("Object.create()")}}</li> - <li>{{jsxref("Object.defineProperty()")}}, {{jsxref("Object.defineProperties()")}}</li> - <li>{{jsxref("WeakMap")}}, {{jsxref("WeakSet")}}</li> -</ul> +- {{jsxref("Object.create()")}} +- {{jsxref("Object.defineProperty()")}}, {{jsxref("Object.defineProperties()")}} +- {{jsxref("WeakMap")}}, {{jsxref("WeakSet")}} diff --git a/files/fr/web/javascript/reference/errors/no_properties/index.md b/files/fr/web/javascript/reference/errors/no_properties/index.md index d45bd65c93..8309c98d5e 100644 --- a/files/fr/web/javascript/reference/errors/no_properties/index.md +++ b/files/fr/web/javascript/reference/errors/no_properties/index.md @@ -9,35 +9,33 @@ tags: translation_of: Web/JavaScript/Reference/Errors/No_properties original_slug: Web/JavaScript/Reference/Erreurs/No_properties --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: Unable to get property {x} of undefined or null reference (Edge) -TypeError: null has no properties (Firefox) -TypeError: undefined has no properties (Firefox) -</pre> + TypeError: Unable to get property {x} of undefined or null reference (Edge) + TypeError: null has no properties (Firefox) + TypeError: undefined has no properties (Firefox) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}.</p> +{{jsxref("TypeError")}}. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Les valeurs {{jsxref("null")}} et {{jsxref("undefined")}} n'ont aucunes propriétés auxquelles accéder.</p> +Les valeurs {{jsxref("null")}} et {{jsxref("undefined")}} n'ont aucunes propriétés auxquelles accéder. -<h2 id="Exemples">Exemples</h2> +## Exemples -<pre class="brush: js example-bad">null.toto; +```js example-bad +null.toto; // TypeError: null has no properties undefined.truc; // TypeError: undefined has no properties -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("null")}}</li> - <li>{{jsxref("undefined")}}</li> -</ul> +- {{jsxref("null")}} +- {{jsxref("undefined")}} diff --git a/files/fr/web/javascript/reference/errors/no_variable_name/index.md b/files/fr/web/javascript/reference/errors/no_variable_name/index.md index 035c83faa9..def7f7fc2f 100644 --- a/files/fr/web/javascript/reference/errors/no_variable_name/index.md +++ b/files/fr/web/javascript/reference/errors/no_variable_name/index.md @@ -8,77 +8,85 @@ tags: translation_of: Web/JavaScript/Reference/Errors/No_variable_name original_slug: Web/JavaScript/Reference/Erreurs/No_variable_name --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: missing variable name (Firefox) -SyntaxError: Unexpected token = (Chrome)</pre> + SyntaxError: missing variable name (Firefox) + SyntaxError: Unexpected token = (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}</p> +{{jsxref("SyntaxError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Il manque un nom pour une variable. Cela est probablement dû à une erreur de syntaxe dans le code. Peut-être qu'une variable est placée au mauvais endroit ou peut-être qu'il manque un nom car on n'a pas trouvé de nom pertinent… (ce qui est souvent assez difficile).</p> +Il manque un nom pour une variable. Cela est probablement dû à une erreur de syntaxe dans le code. Peut-être qu'une variable est placée au mauvais endroit ou peut-être qu'il manque un nom car on n'a pas trouvé de nom pertinent… (ce qui est souvent assez difficile). -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Absence_d'un_nom_pour_une_variable">Absence d'un nom pour une variable</h3> +### Absence d'un nom pour une variable -<pre class="brush: js example-bad">var = "toto"; -</pre> +```js example-bad +var = "toto"; +``` -<p>Il est souvent compliqué de trouver le bon nom pour une variable…</p> +Il est souvent compliqué de trouver le bon nom pour une variable… -<pre class="brush: js example-good">var àDéfautDeMieux = "toto";</pre> +```js example-good +var àDéfautDeMieux = "toto"; +``` -<h3 id="Les_mots-clés_réservés_ne_peuvent_pas_être_utilisés_comme_noms_de_variables">Les mots-clés réservés ne peuvent pas être utilisés comme noms de variables</h3> +### Les mots-clés réservés ne peuvent pas être utilisés comme noms de variables -<p>Quelques mots-clés sont <a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Mots-clés">réservés</a> et ne peuvent pas être utilisés comme noms de variable :</p> +Quelques mots-clés sont [réservés](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Mots-clés) et ne peuvent pas être utilisés comme noms de variable : -<pre class="brush: js example-bad">var debugger = "zuuuuut"; +```js example-bad +var debugger = "zuuuuut"; // SyntaxError: missing variable name -</pre> +``` -<h3 id="Déclarer_plusieurs_variables">Déclarer plusieurs variables</h3> +### Déclarer plusieurs variables -<p>Attention aux virgules lorsqu'on déclare plusieurs variables… Y a-t-il plus de virgules que nécessairee ? Une virgule est-elle utilisée à la place d'un point-virgule ?</p> +Attention aux virgules lorsqu'on déclare plusieurs variables… Y a-t-il plus de virgules que nécessairee ? Une virgule est-elle utilisée à la place d'un point-virgule ? -<pre class="brush: js example-bad">var x, y = "toto", +```js example-bad +var x, y = "toto", var x, = "toto" var un = document.getElementById('un'), var deux = document.getElementById('deux'), // SyntaxError: missing variable name -</pre> +``` -<p>Voici une version corrigée :</p> +Voici une version corrigée : -<pre class="brush: js example-good">var x, y = "toto"; +```js example-good +var x, y = "toto"; var x = "toto"; var un = document.getElementById('un'); -var deux = document.getElementById('deux');</pre> +var deux = document.getElementById('deux'); +``` -<h3 id="Tableaux">Tableaux</h3> +### Tableaux -<p>Pour former un littéral de tableau ({{jsxref("Array")}}), il est nécessaire d'ajouter des crochets autour des valeurs des éléments. Le fragment de code suivant ne fonctionnera pas :</p> +Pour former un littéral de tableau ({{jsxref("Array")}}), il est nécessaire d'ajouter des crochets autour des valeurs des éléments. Le fragment de code suivant ne fonctionnera pas : -<pre class="brush: js example-bad">var arr = 1,2,3,4,5; +```js example-bad +var arr = 1,2,3,4,5; // SyntaxError: missing variable name -</pre> +``` -<p>Voici la forme équivalente correcte :</p> +Voici la forme équivalente correcte : -<pre class="brush: js example-good">var arr = [1,2,3,4,5];</pre> +```js example-good +var arr = [1,2,3,4,5]; +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="http://wiki.c2.com/?GoodVariableNames">Choisir de bons noms de variable (en anglais)</a></li> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code></li> - <li><a href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Déclarations">Guide JavaScript : Les déclarations de variable</a></li> -</ul> +- [Choisir de bons noms de variable (en anglais)](http://wiki.c2.com/?GoodVariableNames) +- [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var) +- [Guide JavaScript : Les déclarations de variable](/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Déclarations) diff --git a/files/fr/web/javascript/reference/errors/non_configurable_array_element/index.md b/files/fr/web/javascript/reference/errors/non_configurable_array_element/index.md index bbb5b3569c..720a30d67c 100644 --- a/files/fr/web/javascript/reference/errors/non_configurable_array_element/index.md +++ b/files/fr/web/javascript/reference/errors/non_configurable_array_element/index.md @@ -9,76 +9,77 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Non_configurable_array_element original_slug: Web/JavaScript/Reference/Erreurs/Non_configurable_array_element --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: can't delete non-configurable array element (Firefox) -TypeError: Cannot delete property '2' of [object Array] (Chrome) -</pre> + TypeError: can't delete non-configurable array element (Firefox) + TypeError: Cannot delete property '2' of [object Array] (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}</p> +{{jsxref("TypeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>On a voulu <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/length#Tronquer_un_tableau">raccourcir la longueur d'un tableau</a> mais l'un des éléments de ce tableau est <a href="/fr/docs/Web/JavaScript/Structures_de_données#Propriétés">non-configurable</a>. Lorsqu'on tronque un tableau, les éléments situés au-delà de la nouvelle longueur seront supprimés. Dans ce cas, c'est cette suppression qui n'a pas pu être effectuée.</p> +On a voulu [raccourcir la longueur d'un tableau](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array/length#Tronquer_un_tableau) mais l'un des éléments de ce tableau est [non-configurable](/fr/docs/Web/JavaScript/Structures_de_données#Propriétés). Lorsqu'on tronque un tableau, les éléments situés au-delà de la nouvelle longueur seront supprimés. Dans ce cas, c'est cette suppression qui n'a pas pu être effectuée. -<p>L'attribut <code>configurable</code> permet de contrôler si la propriété peut être supprimée d'un objet et si ses attributs (en dehors de <code>writable</code>) peuvent être modifiés.</p> +L'attribut `configurable` permet de contrôler si la propriété peut être supprimée d'un objet et si ses attributs (en dehors de `writable`) peuvent être modifiés. -<p>La plupart du temps, les propriétés d'un objet créé avec <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array#Syntaxe">un littéral de tableau</a> sont configurables. Toutefois, si on utilise {{jsxref("Object.defineProperty()")}} par exemple, la propriété n'est pas configurable par défaut.</p> +La plupart du temps, les propriétés d'un objet créé avec [un littéral de tableau](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Array#Syntaxe) sont configurables. Toutefois, si on utilise {{jsxref("Object.defineProperty()")}} par exemple, la propriété n'est pas configurable par défaut. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Propriétés_non-configurables_créées_avec_Object.defineProperty">Propriétés non-configurables créées avec <code>Object.defineProperty</code></h3> +### Propriétés non-configurables créées avec `Object.defineProperty` -<p>Par défaut, la méthode {{jsxref("Object.defineProperty()")}} crée des propriétés non-configurables si on n'indique pas expressément le contraire :</p> +Par défaut, la méthode {{jsxref("Object.defineProperty()")}} crée des propriétés non-configurables si on n'indique pas expressément le contraire : -<pre class="brush: js example-bad">var arr = []; +```js example-bad +var arr = []; Object.defineProperty(arr, 0, {value: 0}); Object.defineProperty(arr, 1, {value: "1"}); arr.length = 1; // TypeError: can't delete non-configurable array element -</pre> +``` -<p>Si on veut tronquer le tableau, il faut que les éléments excédants soient configurables :</p> +Si on veut tronquer le tableau, il faut que les éléments excédants soient configurables : -<pre class="brush: js example-good">var arr = []; +```js example-good +var arr = []; Object.defineProperty(arr, 0, {value: 0, configurable: true}); Object.defineProperty(arr, 1, {value: "1", configurable: true}); arr.length = 1; -</pre> +``` -<h3 id="Tableaux_scellés_(seal)">Tableaux scellés (<code>seal</code>)</h3> +### Tableaux scellés (`seal`) -<p>La méthode {{jsxref("Object.seal()")}} permet de marquer l'ensemble des propriétés (ici les éléments du tableau) comme non-configurables :</p> +La méthode {{jsxref("Object.seal()")}} permet de marquer l'ensemble des propriétés (ici les éléments du tableau) comme non-configurables : -<pre class="brush: js example-bad">var arr = [1,2,3]; +```js example-bad +var arr = [1,2,3]; Object.seal(arr); arr.length = 1; // TypeError: can't delete non-configurable array element -</pre> +``` -<p>Pour corriger l'erreur, il faut retirer l'appel à {{jsxref("Object.seal()")}} ou réaliser une copie du tableau. Dans ce dernier cas, on notera que tronquer la copie du tableau ne modifie pas la longueur du tableau original.</p> +Pour corriger l'erreur, il faut retirer l'appel à {{jsxref("Object.seal()")}} ou réaliser une copie du tableau. Dans ce dernier cas, on notera que tronquer la copie du tableau ne modifie pas la longueur du tableau original. -<pre class="brush: js example-good">var arr = [1,2,3]; +```js example-good +var arr = [1,2,3]; Object.seal(arr); // On copie le tableau initial pour tronquer cette copie var copie = Array.from(arr); copie.length = 1; // arr.length == 3 -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Structures_de_données#Propriétés">La propriété interne <code>[[Configurable]]</code></a></li> - <li>{{jsxref("Array.length")}}</li> - <li>{{jsxref("Object.defineProperty()")}}</li> - <li>{{jsxref("Object.seal()")}}</li> -</ul> +- [La propriété interne `[[Configurable]]`](/fr/docs/Web/JavaScript/Structures_de_données#Propriétés) +- {{jsxref("Array.length")}} +- {{jsxref("Object.defineProperty()")}} +- {{jsxref("Object.seal()")}} diff --git a/files/fr/web/javascript/reference/errors/not_a_codepoint/index.md b/files/fr/web/javascript/reference/errors/not_a_codepoint/index.md index 2da0d021ee..5f8bcf650b 100644 --- a/files/fr/web/javascript/reference/errors/not_a_codepoint/index.md +++ b/files/fr/web/javascript/reference/errors/not_a_codepoint/index.md @@ -8,50 +8,50 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Not_a_codepoint original_slug: Web/JavaScript/Reference/Erreurs/Not_a_codepoint --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">RangeError: Invalid code point {0} (Edge) -RangeError: {0} is not a valid code point (Firefox) -RangeError: Invalid code point {0} (Chrome) -</pre> + RangeError: Invalid code point {0} (Edge) + RangeError: {0} is not a valid code point (Firefox) + RangeError: Invalid code point {0} (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("RangeError")}}</p> +{{jsxref("RangeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>La méthode {{jsxref("String.fromCodePoint()")}} a été utilisée mais elle n'accepte que les points de code valides (<em>code points</em>) et la valeur fournie en argument n'est pas un point de code valide (ex. <code>NaN</code>, <code>-1</code>).</p> +La méthode {{jsxref("String.fromCodePoint()")}} a été utilisée mais elle n'accepte que les points de code valides (_code points_) et la valeur fournie en argument n'est pas un point de code valide (ex. `NaN`, `-1`). -<p>Un <a href="https://fr.wikipedia.org/wiki/Point_de_code">point de code</a> est une valeur de code Unicode et s'inscrit dans un intervalle allant de <code>0</code> à <code>0x10FFFF</code>.</p> +Un [point de code](https://fr.wikipedia.org/wiki/Point_de_code) est une valeur de code Unicode et s'inscrit dans un intervalle allant de `0` à `0x10FFFF`. -<p>Les valeurs {{jsxref("NaN")}}, les entiers négatifs (<code>-1</code>), les flottants (<code>3.14</code>) ou les valeur supérieures à <code>0x10FFFF</code> (<code>1114111</code>) ne peuvent pas être utilisées avec cette méthode.</p> +Les valeurs {{jsxref("NaN")}}, les entiers négatifs (`-1`), les flottants (`3.14`) ou les valeur supérieures à `0x10FFFF` (`1114111`) ne peuvent pas être utilisées avec cette méthode. -<h2 id="Examples">Examples</h2> +## Examples -<h3 id="Exemples_invalides">Exemples invalides</h3> +### Exemples invalides -<pre class="brush: js example-bad">String.fromCodePoint('_'); // RangeError +```js example-bad +String.fromCodePoint('_'); // RangeError String.fromCodePoint(Infinity); // RangeError String.fromCodePoint(-1); // RangeError String.fromCodePoint(3.14); // RangeError String.fromCodePoint(3e-2); // RangeError -String.fromCodePoint(NaN); // RangeError</pre> +String.fromCodePoint(NaN); // RangeError +``` -<h3 id="Exemples_valides">Exemples valides</h3> +### Exemples valides -<pre class="brush: js example-good">String.fromCodePoint(42); // "*" +```js example-good +String.fromCodePoint(42); // "*" String.fromCodePoint(65, 90); // "AZ" String.fromCodePoint(0x404); // "\u0404" String.fromCodePoint(0x2F804); // "\uD87E\uDC04" String.fromCodePoint(194564); // "\uD87E\uDC04" String.fromCodePoint(0x1D306, 0x61, 0x1D307) // "\uD834\uDF06a\uD834\uDF07" -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("String.fromCodePoint()")}}</li> -</ul> +- {{jsxref("String.fromCodePoint()")}} diff --git a/files/fr/web/javascript/reference/errors/not_a_constructor/index.md b/files/fr/web/javascript/reference/errors/not_a_constructor/index.md index 211e4e952c..a6c6372d7d 100644 --- a/files/fr/web/javascript/reference/errors/not_a_constructor/index.md +++ b/files/fr/web/javascript/reference/errors/not_a_constructor/index.md @@ -8,39 +8,39 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Not_a_constructor original_slug: Web/JavaScript/Reference/Erreurs/Not_a_constructor --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: Object doesn't support this action (Edge) -TypeError: "x" is not a constructor + TypeError: Object doesn't support this action (Edge) + TypeError: "x" is not a constructor -TypeError: Math is not a constructor -TypeError: JSON is not a constructor -TypeError: Symbol is not a constructor -TypeError: Reflect is not a constructor -TypeError: Intl is not a constructor -TypeError: SIMD is not a constructor -TypeError: Atomics is not a constructor -</pre> + TypeError: Math is not a constructor + TypeError: JSON is not a constructor + TypeError: Symbol is not a constructor + TypeError: Reflect is not a constructor + TypeError: Intl is not a constructor + TypeError: SIMD is not a constructor + TypeError: Atomics is not a constructor -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}</p> +{{jsxref("TypeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Une variable ou un objet a été utilisé comme un constructeur alors que cet objet ou cette variable n'est pas un constructeur. Pour plus d'informations sur les constructeurs, voir la page sur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new">l'opérateur <code>new</code></a>.</p> +Une variable ou un objet a été utilisé comme un constructeur alors que cet objet ou cette variable n'est pas un constructeur. Pour plus d'informations sur les constructeurs, voir la page sur [l'opérateur `new`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new). -<p>De nombreux objets globaux tels que {{jsxref("String")}} ou {{jsxref("Array")}}, sont constructibles avec <code>new</code>. Cependant, d'autres objets globaux ne le sont pas (leurs propriétés et méthodes sont statiques). Les objets standards natifs suivants ne sont pas des constructeur : {{jsxref("Math")}}, {{jsxref("JSON")}}, {{jsxref("Symbol")}}, {{jsxref("Reflect")}}, {{jsxref("Intl")}}, {{jsxref("SIMD")}}, {{jsxref("Atomics")}}.</p> +De nombreux objets globaux tels que {{jsxref("String")}} ou {{jsxref("Array")}}, sont constructibles avec `new`. Cependant, d'autres objets globaux ne le sont pas (leurs propriétés et méthodes sont statiques). Les objets standards natifs suivants ne sont pas des constructeur : {{jsxref("Math")}}, {{jsxref("JSON")}}, {{jsxref("Symbol")}}, {{jsxref("Reflect")}}, {{jsxref("Intl")}}, {{jsxref("SIMD")}}, {{jsxref("Atomics")}}. -<p><a href="/fr/docs/Web/JavaScript/Reference/Instructions/function*">Les fonctions génératrices</a> ne peuvent pas non plus être utilisées comme des constructeurs.</p> +[Les fonctions génératrices](/fr/docs/Web/JavaScript/Reference/Instructions/function*) ne peuvent pas non plus être utilisées comme des constructeurs. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Exemples_invalides">Exemples invalides</h3> +### Exemples invalides -<pre class="brush: js example-bad">var Voiture = 1; +```js example-bad +var Voiture = 1; new Voiture(); // TypeError: Voiture is not a constructor @@ -53,45 +53,48 @@ new Symbol(); function* f() {}; var obj = new f; // TypeError: f is not a constructor -</pre> +``` -<h3 id="Créer_un_constructeur_voiture">Créer un constructeur <code>voiture</code></h3> +### Créer un constructeur `voiture` -<p>Imaginons qu'on veuille représenter des voitures sous forme d'objets. On appellera ce type <code>voiture</code> et on lui ajoutera des propriétés pour le fabricant, le modèle et l'année. Pour cela, on pourra écrire la fonction suivante :</p> +Imaginons qu'on veuille représenter des voitures sous forme d'objets. On appellera ce type `voiture` et on lui ajoutera des propriétés pour le fabricant, le modèle et l'année. Pour cela, on pourra écrire la fonction suivante : -<pre class="brush: js">function Voiture(fabriquant, modèle, année) { +```js +function Voiture(fabriquant, modèle, année) { this.fabriquant = fabriquant; this.modèle = modèle; this.année = année; } -</pre> +``` -<p>On peut désormais créer un objet <code>maVoiture</code> comme ceci :</p> +On peut désormais créer un objet `maVoiture` comme ceci : -<pre class="brush: js">var maVoiture = new Voiture("Renault", "Twingo", 2006);</pre> +```js +var maVoiture = new Voiture("Renault", "Twingo", 2006); +``` -<h3 id="Avec_les_promesses">Avec les promesses</h3> +### Avec les promesses -<p>Lorsqu'on renvoie une promesse immédiatement tenue ou rompue, il n'est pas nécessaire d'utiliser <code>new Promise()</code> pour la manipuler. Il faut plutôt utiliser les méthodes statiques {{jsxref("Promise.resolve()")}} ou {{jsxref("Promise.reject()")}} :</p> +Lorsqu'on renvoie une promesse immédiatement tenue ou rompue, il n'est pas nécessaire d'utiliser `new Promise()` pour la manipuler. Il faut plutôt utiliser les méthodes statiques {{jsxref("Promise.resolve()")}} ou {{jsxref("Promise.reject()")}} : -<pre class="brush: js example-bad">// Dans ce cas on aura une exception +```js example-bad +// Dans ce cas on aura une exception // "this is not a constructor" return new Promise.resolve(true); -</pre> +``` -<pre class="brush: js">// Cette formulation fonctionne mais +```js +// Cette formulation fonctionne mais // est inutilement longue -return new Promise((resolve, reject) => { resolve(true); }); +return new Promise((resolve, reject) => { resolve(true); }); // On pourra autrement utiliser les // méthodes statiques return Promise.resolve(true); return Promise.reject(false); -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{Glossary("constructor")}}</li> - <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new">L'opérateur <code>new</code></a></li> -</ul> +- {{Glossary("constructor")}} +- [L'opérateur `new`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_new) diff --git a/files/fr/web/javascript/reference/errors/not_a_function/index.md b/files/fr/web/javascript/reference/errors/not_a_function/index.md index 8675a249ae..e6b948eebe 100644 --- a/files/fr/web/javascript/reference/errors/not_a_function/index.md +++ b/files/fr/web/javascript/reference/errors/not_a_function/index.md @@ -8,82 +8,82 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Not_a_function original_slug: Web/JavaScript/Reference/Erreurs/Not_a_function --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: Object doesn't support property or method {x} (Edge) -TypeError: "x" is not a function -</pre> + TypeError: Object doesn't support property or method {x} (Edge) + TypeError: "x" is not a function -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}.</p> +{{jsxref("TypeError")}}. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Une valeur a été utilisée pour un appel de fonction alors que cette valeur n'est pas une fonction. Autrement dit, un fragment de code attendait une fonction mais a reçu des valeurs d'un autre type.</p> +Une valeur a été utilisée pour un appel de fonction alors que cette valeur n'est pas une fonction. Autrement dit, un fragment de code attendait une fonction mais a reçu des valeurs d'un autre type. -<p>Il est possible qu'il y ait une coquille dans le nom de la fonction. Peut être que l'objet sur lequel la méthode est invoquée ne possède pas cette fonction (par exemple, les objets <code>Array</code> possèdent une fonction <code>map()</code> mais d'autres objets ne l'ont pas).</p> +Il est possible qu'il y ait une coquille dans le nom de la fonction. Peut être que l'objet sur lequel la méthode est invoquée ne possède pas cette fonction (par exemple, les objets `Array` possèdent une fonction `map()` mais d'autres objets ne l'ont pas). -<p>Il existe de nombreuses fonctions natives qui fonctionnent à l'aide d'une fonction (<em>callback</em>) passée en argument :</p> +Il existe de nombreuses fonctions natives qui fonctionnent à l'aide d'une fonction (_callback_) passée en argument : -<ul> - <li>Pour les objets {{jsxref("Array")}} ou {{jsxref("TypedArray")}}, voici les fonctions qui utilisent une fonction en argument : - <ul> - <li>{{jsxref("Array.prototype.every()")}}, {{jsxref("Array.prototype.some()")}}, {{jsxref("Array.prototype.forEach()")}}, {{jsxref("Array.prototype.map()")}}, {{jsxref("Array.prototype.filter()")}}, {{jsxref("Array.prototype.reduce()")}}, {{jsxref("Array.prototype.reduceRight()")}}, {{jsxref("Array.prototype.find()")}}</li> - </ul> - </li> - <li>Pour les objets {{jsxref("Map")}} et {{jsxref("Set")}}, voici les méthodes concernées : - <ul> - <li>{{jsxref("Map.prototype.forEach()")}} and {{jsxref("Set.prototype.forEach()")}}</li> - </ul> - </li> -</ul> +- Pour les objets {{jsxref("Array")}} ou {{jsxref("TypedArray")}}, voici les fonctions qui utilisent une fonction en argument : -<h2 id="Exemples">Exemples</h2> + - {{jsxref("Array.prototype.every()")}}, {{jsxref("Array.prototype.some()")}}, {{jsxref("Array.prototype.forEach()")}}, {{jsxref("Array.prototype.map()")}}, {{jsxref("Array.prototype.filter()")}}, {{jsxref("Array.prototype.reduce()")}}, {{jsxref("Array.prototype.reduceRight()")}}, {{jsxref("Array.prototype.find()")}} -<h3 id="Une_coquille_dans_le_nom_de_la_fonction">Une coquille dans le nom de la fonction</h3> +- Pour les objets {{jsxref("Map")}} et {{jsxref("Set")}}, voici les méthodes concernées : -<p>Dans ce cas, qui arrive bien trop souvent, il y a une faute d'orthographe dans le nom de la fonction utilisée :</p> + - {{jsxref("Map.prototype.forEach()")}} and {{jsxref("Set.prototype.forEach()")}} -<pre class="brush: js example-bad">var x = document.getElementByID("toto"); +## Exemples + +### Une coquille dans le nom de la fonction + +Dans ce cas, qui arrive bien trop souvent, il y a une faute d'orthographe dans le nom de la fonction utilisée : + +```js example-bad +var x = document.getElementByID("toto"); // TypeError: document.getElementByID is not a function -</pre> +``` -<p>Le nom de la fonction est (dans cet exemple) <code>getElementByI<strong>d</strong></code> (attention à la casse pour les noms en JavaScript) :</p> +Le nom de la fonction est (dans cet exemple) `getElementById` (attention à la casse pour les noms en JavaScript) : -<pre class="brush: js example-good">var x = document.getElementById("toto"); -</pre> +```js example-good +var x = document.getElementById("toto"); +``` -<h3 id="Appeler_une_fonction_sur_le_mauvais_objet">Appeler une fonction sur le mauvais objet</h3> +### Appeler une fonction sur le mauvais objet -<p>Certaines méthodes ne fonctionnent que pour certains types d'objet et utilisent une fonction en argument. Ainsi, dans cet exemple, on utilise {{jsxref("Array.prototype.map()")}} qui ne fonctionne que sur les objets {{jsxref("Array")}}.</p> +Certaines méthodes ne fonctionnent que pour certains types d'objet et utilisent une fonction en argument. Ainsi, dans cet exemple, on utilise {{jsxref("Array.prototype.map()")}} qui ne fonctionne que sur les objets {{jsxref("Array")}}. -<pre class="brush: js example-bad">var obj = { a: 13, b: 37, c: 42 }; +```js example-bad +var obj = { a: 13, b: 37, c: 42 }; obj.map(function(num) { return num * 2; }); -// TypeError: obj.map is not a function</pre> +// TypeError: obj.map is not a function +``` -<p>Il faudra utiliser un tableau à la place :</p> +Il faudra utiliser un tableau à la place : -<pre class="brush: js example-good">var nombres = [1, 4, 9]; +```js example-good +var nombres = [1, 4, 9]; nombres.map(function(num) { return num * 2; }); // Array [ 2, 8, 18 ] -</pre> +``` -<h3 id="Utiliser_le_même_nom_pour_une_méthode_et_une_propriété">Utiliser le même nom pour une méthode et une propriété</h3> +### Utiliser le même nom pour une méthode et une propriété -<p>Lorsqu'on écrit une classe, on peut malheureusement utiliser le même nom pour une propriété et une méthode. Lorsqu'on appellera la fonction, celle-ci aura été remplacée par la propriété et cela déclenchera une erreur :</p> +Lorsqu'on écrit une classe, on peut malheureusement utiliser le même nom pour une propriété et une méthode. Lorsqu'on appellera la fonction, celle-ci aura été remplacée par la propriété et cela déclenchera une erreur : -<pre class="brush: js example-bad">var Chien = function () { +```js example-bad +var Chien = function () { this.age = 11; this.couleur = "noir"; this.nom = "Ralph"; @@ -98,11 +98,12 @@ Chien.prototype.nom = function(nom) { var monNouveauChien = new Chien(); monNouveauChien.nom("Cassidy"); // Uncaught TypeError: monNouveauChien.nom is not a function -</pre> +``` -<p>Pour résoudre le problème, on utilisera deux noms distincts pour la propriété et la méthode :</p> +Pour résoudre le problème, on utilisera deux noms distincts pour la propriété et la méthode : -<pre class="brush: js example-good">var Chien = function () { +```js example-good +var Chien = function () { this.age = 11; this.couleur = "noir"; this.nomChien = "Ralph"; @@ -117,40 +118,45 @@ Chien.prototype.nom = function(nom) { var monNouveauChien = new Chien(); monNouveauChien.nom("Cassidy"); // Chien { age: 11, couleur: "noir", nomChien: "Cassidy" } -</pre> +``` -<h3 id="Utiliser_des_parenthèses_pour_la_multiplication">Utiliser des parenthèses pour la multiplication</h3> +### Utiliser des parenthèses pour la multiplication -<p>En notation mathématique, on peut écrire 2(3+5) pour indiquer qu'on souhaite multiplier 2 par 3 + 5. Toutefois, une telle écriture n'est pas valide en JavaScript car il faut préciser l'opérateur de multiplication :</p> +En notation mathématique, on peut écrire 2(3+5) pour indiquer qu'on souhaite multiplier 2 par 3 + 5. Toutefois, une telle écriture n'est pas valide en JavaScript car il faut préciser l'opérateur de multiplication : -<pre class="js example-bad">var seize = 2(3 + 5); +```js example-bad +var seize = 2(3 + 5); console.log('2 x (3 + 5) vaut ' + String(seize)); -// Uncaught TypeError: 2 is not a function</pre> +// Uncaught TypeError: 2 is not a function +``` -<p>Pour corriger, il suffit d'ajouter l'opérateur <code>*</code> :</p> +Pour corriger, il suffit d'ajouter l'opérateur `*` : -<pre class="js example-good">var seize = 2 * (3 + 5); +```js example-good +var seize = 2 * (3 + 5); console.log('2 x (3 + 5) is ' + String(seize)); //2 x (3 + 5) is 16 -</pre> +``` -<h3 id="Importer_un_module_exporté_correctement">Importer un module exporté correctement</h3> +### Importer un module exporté correctement -<p>Assurez-vous d'importer le module correctement. Si par exemple, on dispose d'une bibliothèque <code>helpers.js</code> avec le code suivant :</p> +Assurez-vous d'importer le module correctement. Si par exemple, on dispose d'une bibliothèque `helpers.js` avec le code suivant : -<pre class="brush: js">let helpers = function () { }; +```js +let helpers = function () { }; helpers.log = function(msg) { console.log(msg); }; -export default helpers;</pre> +export default helpers; +``` -<p>Pour l'importer côté application, on écrira :</p> +Pour l'importer côté application, on écrira : -<pre class="brush: js">import helpers from './helpers'</pre> +```js +import helpers from './helpers' +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Fonctions">Les fonctions</a></li> -</ul> +- [Les fonctions](/fr/docs/Web/JavaScript/Reference/Fonctions) diff --git a/files/fr/web/javascript/reference/errors/not_defined/index.md b/files/fr/web/javascript/reference/errors/not_defined/index.md index d88edd4f04..51fa9d1bff 100644 --- a/files/fr/web/javascript/reference/errors/not_defined/index.md +++ b/files/fr/web/javascript/reference/errors/not_defined/index.md @@ -9,63 +9,65 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Not_defined original_slug: Web/JavaScript/Reference/Erreurs/Not_defined --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">ReferenceError: "x" is not defined -</pre> + ReferenceError: "x" is not defined -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("ReferenceError")}}.</p> +{{jsxref("ReferenceError")}}. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Une variable qui n'existe pas est référencée quelque part. Cette variable doit être déclarée ou il faut vérifier qu'elle est disponible dans le script concerné ou dans la portée utilisée.</p> +Une variable qui n'existe pas est référencée quelque part. Cette variable doit être déclarée ou il faut vérifier qu'elle est disponible dans le script concerné ou dans la portée utilisée. -<div class="note"> -<p><strong>Note :</strong> Lors du chargement d'une bibliothèque comme jQuery, assurez-vous de bien charger la bibliothèque avant d'accéder aux variables comme <code>$</code>. La balise {{HTMLElement("script")}} utilisée pour charger la bibliothèque doit être présente avant le code qui l'utilise.</p> -</div> +> **Note :** Lors du chargement d'une bibliothèque comme jQuery, assurez-vous de bien charger la bibliothèque avant d'accéder aux variables comme `$`. La balise {{HTMLElement("script")}} utilisée pour charger la bibliothèque doit être présente avant le code qui l'utilise. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Exemple_de_variable_non_déclarée">Exemple de variable non déclarée</h3> +### Exemple de variable non déclarée -<pre class="brush: js example-bad">toto.substring(1); // ReferenceError: toto is not defined -</pre> +```js example-bad +toto.substring(1); // ReferenceError: toto is not defined +``` -<p>La variable <code>toto</code> n'est définie nulle part. De plus, il faut qu'elle soit une chaîne de caractères afin que la méthode {{jsxref("String.prototype.substring()")}} puisse fonctionner.</p> +La variable `toto` n'est définie nulle part. De plus, il faut qu'elle soit une chaîne de caractères afin que la méthode {{jsxref("String.prototype.substring()")}} puisse fonctionner. -<pre class="brush: js example-good">var toto = "truc"; -toto.substring(1); // "ruc"</pre> +```js example-good +var toto = "truc"; +toto.substring(1); // "ruc" +``` -<h3 id="Exemple_de_portée_invalide">Exemple de portée invalide</h3> +### Exemple de portée invalide -<p>Une variable doit être disponible dans le contexte d'exécution où elle est utilisée. Les variables définies au sein d'une fonction ne peuvent pas être utilisées en dehors de cette fonction car la variable appartient à la <em>portée</em> de la fonction.</p> +Une variable doit être disponible dans le contexte d'exécution où elle est utilisée. Les variables définies au sein d'une fonction ne peuvent pas être utilisées en dehors de cette fonction car la variable appartient à la _portée_ de la fonction. -<pre class="brush: js example-bad">function numbers () { +```js example-bad +function numbers () { var num1 = 2, num2 = 3; return num1 + num2; } -console.log(num1); // ReferenceError num1 is not defined.</pre> +console.log(num1); // ReferenceError num1 is not defined. +``` -<p>Toutefois, une fonction peut accéder aux variables et aux fonctions définies dans la portée dans laquelle elle s'inscrit. Ainsi, une fonction définie dans la portée globale peut utiliser toutes les variables définies dans la portée globale.</p> +Toutefois, une fonction peut accéder aux variables et aux fonctions définies dans la portée dans laquelle elle s'inscrit. Ainsi, une fonction définie dans la portée globale peut utiliser toutes les variables définies dans la portée globale. -<pre class="brush: js example-good">var num1 = 2, +```js example-good +var num1 = 2, num2 = 3; function numbers () { return num1 + num2; } -console.log(num1); // 2</pre> +console.log(num1); // 2 +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Déclaration_de_variables">La déclaration de variables dans le guide JavaScript</a></li> - <li><a href="/fr/docs/Web/JavaScript/Guide/Fonctions#Portée_d'une_fonction">Les notions de portées dans le guide JavaScript</a></li> -</ul> +- [La déclaration de variables dans le guide JavaScript](/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Déclaration_de_variables) +- [Les notions de portées dans le guide JavaScript](/fr/docs/Web/JavaScript/Guide/Fonctions#Portée_d'une_fonction) diff --git a/files/fr/web/javascript/reference/errors/precision_range/index.md b/files/fr/web/javascript/reference/errors/precision_range/index.md index 52adf5bcd1..7b5ee16527 100644 --- a/files/fr/web/javascript/reference/errors/precision_range/index.md +++ b/files/fr/web/javascript/reference/errors/precision_range/index.md @@ -8,66 +8,43 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Precision_range original_slug: Web/JavaScript/Reference/Erreurs/Precision_range --- -<div>{{jsSidebar("Errors")}}</div> - -<h2 id="Message">Message</h2> - -<pre class="syntaxbox">RangeError: The number of fractional digits is out of range (Edge) -RangeError: The precision is out of range (Edge) -RangeError: precision {0} out of range (Firefox) -RangeError: toExponential() argument must be between 0 and 20 (Chrome) -RangeError: toFixed() digits argument must be between 0 and 20 (Chrome) -RangeError: toPrecision() argument must be between 1 and 21 (Chrome) -</pre> - -<h2 id="Type_d'erreur">Type d'erreur</h2> - -<p>{{jsxref("RangeError")}}</p> - -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> - -<p>Un argument dont la précision est en dehors de l'intervalle valide, prévu par le moteur JavaScript, a été utilisé pour une de ces méthodes :</p> - -<ul> - <li>{{jsxref("Number.prototype.toExponential()")}}</li> - <li>{{jsxref("Number.prototype.toFixed()")}}</li> - <li>{{jsxref("Number.prototype.toPrecision()")}}</li> -</ul> - -<p>Généralement, ces méthodes acceptent des arguments de précision compris entre 0 et 20 (voire 21). Cependant, la spécification ECMAScript permet de gérer des valeurs en dehors de cet intervalle.</p> - -<table class="standard-table"> - <thead> - <tr> - <th scope="col">Méthode</th> - <th scope="col">Firefox (SpiderMonkey)</th> - <th scope="col">Chrome, Opera (V8)</th> - </tr> - </thead> - <tbody> - <tr> - <td>{{jsxref("Number.prototype.toExponential()")}}</td> - <td>0 to 100</td> - <td>0 to 20</td> - </tr> - <tr> - <td>{{jsxref("Number.prototype.toFixed()")}}</td> - <td>-20 to 100</td> - <td>0 to 20</td> - </tr> - <tr> - <td>{{jsxref("Number.prototype.toPrecision()")}}</td> - <td>1 to 100</td> - <td>1 to 21</td> - </tr> - </tbody> -</table> - -<h2 id="Exemples">Exemples</h2> - -<h3 id="Exemples_invalides">Exemples invalides</h3> - -<pre class="brush: js example-bad">77.1234.toExponential(-1); // RangeError +{{jsSidebar("Errors")}} + +## Message + + RangeError: The number of fractional digits is out of range (Edge) + RangeError: The precision is out of range (Edge) + RangeError: precision {0} out of range (Firefox) + RangeError: toExponential() argument must be between 0 and 20 (Chrome) + RangeError: toFixed() digits argument must be between 0 and 20 (Chrome) + RangeError: toPrecision() argument must be between 1 and 21 (Chrome) + +## Type d'erreur + +{{jsxref("RangeError")}} + +## Quel est le problème ? + +Un argument dont la précision est en dehors de l'intervalle valide, prévu par le moteur JavaScript, a été utilisé pour une de ces méthodes : + +- {{jsxref("Number.prototype.toExponential()")}} +- {{jsxref("Number.prototype.toFixed()")}} +- {{jsxref("Number.prototype.toPrecision()")}} + +Généralement, ces méthodes acceptent des arguments de précision compris entre 0 et 20 (voire 21). Cependant, la spécification ECMAScript permet de gérer des valeurs en dehors de cet intervalle. + +| Méthode | Firefox (SpiderMonkey) | Chrome, Opera (V8) | +| ------------------------------------------------------------ | ---------------------- | ------------------ | +| {{jsxref("Number.prototype.toExponential()")}} | 0 to 100 | 0 to 20 | +| {{jsxref("Number.prototype.toFixed()")}} | -20 to 100 | 0 to 20 | +| {{jsxref("Number.prototype.toPrecision()")}} | 1 to 100 | 1 to 21 | + +## Exemples + +### Exemples invalides + +```js example-bad +77.1234.toExponential(-1); // RangeError 77.1234.toExponential(101); // RangeError 2.34.toFixed(-100); // RangeError @@ -75,11 +52,12 @@ RangeError: toPrecision() argument must be between 1 and 21 (Chrome) 1234.5.toPrecision(-1); // RangeError 1234.5.toPrecision(101); // RangeError -</pre> +``` -<h3 id="Exemples_valides">Exemples valides</h3> +### Exemples valides -<pre class="brush: js example-good">77.1234.toExponential(4); // 7.7123e+1 +```js example-good +77.1234.toExponential(4); // 7.7123e+1 77.1234.toExponential(2); // 7.71e+1 2.34.toFixed(1); // 2.3 @@ -88,12 +66,10 @@ RangeError: toPrecision() argument must be between 1 and 21 (Chrome) 5.123456.toPrecision(5); // 5.1235 5.123456.toPrecision(2); // 5.1 5.123456.toPrecision(1); // 5 -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("Number.prototype.toExponential()")}}</li> - <li>{{jsxref("Number.prototype.toFixed()")}}</li> - <li>{{jsxref("Number.prototype.toPrecision()")}}</li> -</ul> +- {{jsxref("Number.prototype.toExponential()")}} +- {{jsxref("Number.prototype.toFixed()")}} +- {{jsxref("Number.prototype.toPrecision()")}} diff --git a/files/fr/web/javascript/reference/errors/property_access_denied/index.md b/files/fr/web/javascript/reference/errors/property_access_denied/index.md index cb7818d3c3..2e8b3fc24d 100644 --- a/files/fr/web/javascript/reference/errors/property_access_denied/index.md +++ b/files/fr/web/javascript/reference/errors/property_access_denied/index.md @@ -9,40 +9,39 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Property_access_denied original_slug: Web/JavaScript/Reference/Erreurs/Property_access_denied --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">Error: Permission denied to access property "x" -</pre> + Error: Permission denied to access property "x" -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("Error")}}.</p> +{{jsxref("Error")}}. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p><span class="seoSummary">Il y a eu une tentative d'accès non-autorisée à un objet sur lequel vous n'avez pas de permissions. Généralement, cela se produit lorsqu'un élément {{HTMLElement("iframe")}} est chargée depuis un domaine différent et que <a href="/fr/docs/Web/JavaScript/Same_origin_policy_for_JavaScript">la condition de même origine</a> n'est pas respectée.</span></p> +Il y a eu une tentative d'accès non-autorisée à un objet sur lequel vous n'avez pas de permissions. Généralement, cela se produit lorsqu'un élément {{HTMLElement("iframe")}} est chargée depuis un domaine différent et que [la condition de même origine](/fr/docs/Web/JavaScript/Same_origin_policy_for_JavaScript) n'est pas respectée. -<h2 id="Exemples">Exemples</h2> +## Exemples -<pre class="brush: html"><!DOCTYPE html> -<html> - <head> - <iframe id="myframe" src="http://www1.w3c-test.org/common/blank.html"></iframe> - <script> +```html +<!DOCTYPE html> +<html> + <head> + <iframe id="myframe" src="http://www1.w3c-test.org/common/blank.html"></iframe> + <script> onload = function() { console.log(frames[0].document); // Error: Permission denied to access property "document" } - </script> - </head> - <body></body> -</html></pre> + </script> + </head> + <body></body> +</html> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{HTMLElement("iframe")}}</li> - <li><a href="/fr/docs/Web/JavaScript/Same_origin_policy_for_JavaScript">Condition d'origine (<em>same-origin policy</em>)</a></li> -</ul> +- {{HTMLElement("iframe")}} +- [Condition d'origine (_same-origin policy_)](/fr/docs/Web/JavaScript/Same_origin_policy_for_JavaScript) diff --git a/files/fr/web/javascript/reference/errors/read-only/index.md b/files/fr/web/javascript/reference/errors/read-only/index.md index d46e5a80e7..e207e6dc2a 100644 --- a/files/fr/web/javascript/reference/errors/read-only/index.md +++ b/files/fr/web/javascript/reference/errors/read-only/index.md @@ -8,34 +8,34 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Read-only original_slug: Web/JavaScript/Reference/Erreurs/Read-only --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: Assignment to read-only properties is not allowed in strict mode (Edge) -TypeError: "x" is read-only (Firefox) -TypeError: 0 is read-only (Firefox) -TypeError: Cannot assign to read only property 'x' of #<Object> (Chrome) -TypeError: Cannot assign to read only property '0' of [object Array] (Chrome) -</pre> + TypeError: Assignment to read-only properties is not allowed in strict mode (Edge) + TypeError: "x" is read-only (Firefox) + TypeError: 0 is read-only (Firefox) + TypeError: Cannot assign to read only property 'x' of #<Object> (Chrome) + TypeError: Cannot assign to read only property '0' of [object Array] (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}</p> +{{jsxref("TypeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>La variable globale ou la propriété ne peut pas recevoir de valeur ou être modifiée car elle est en lecture seule (d'un point de vue technique, il s'agit d'<a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/defineProperty#Attribut_writable">une propriété de donnée en lecture seule</a>).</p> +La variable globale ou la propriété ne peut pas recevoir de valeur ou être modifiée car elle est en lecture seule (d'un point de vue technique, il s'agit d'[une propriété de donnée en lecture seule](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Object/defineProperty#Attribut_writable)). -<p>Cette erreur ne se produit qu'avec <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">le mode strict</a>. En mode non-strict, l'affectation est ignorée silencieusement.</p> +Cette erreur ne se produit qu'avec [le mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode). En mode non-strict, l'affectation est ignorée silencieusement. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Exemples_invalides">Exemples invalides</h3> +### Exemples invalides -<p>Les propriétés en lecture seule ne sont pas fréquemment utilisées mais on peut en créer en utilisant les méthodes {{jsxref("Object.defineProperty()")}} ou {{jsxref("Object.freeze()")}}.</p> +Les propriétés en lecture seule ne sont pas fréquemment utilisées mais on peut en créer en utilisant les méthodes {{jsxref("Object.defineProperty()")}} ou {{jsxref("Object.freeze()")}}. -<pre class="brush: js example-bad">"use strict"; +```js example-bad +"use strict"; var obj = Object.freeze({name: "Elsa", score: 157}); obj.score = 0; // TypeError @@ -46,24 +46,27 @@ NB_POUMONS = 3; // TypeError "use strict"; var frozenArray = Object.freeze([0, 1, 2]); frozenArray[0]++; // TypeError -</pre> +``` -<p>Quelques propriétés natives JavaScript sont également en lecture seule. Par exemple, on obtient cette erreur lorsqu'on souhaite redéfinir une constante mathématique.</p> +Quelques propriétés natives JavaScript sont également en lecture seule. Par exemple, on obtient cette erreur lorsqu'on souhaite redéfinir une constante mathématique. -<pre class="brush: js example-bad">"use strict"; +```js example-bad +"use strict"; Math.PI = 4; // TypeError -</pre> +``` -<p>La variable globale <code>undefined</code> est également en lecture seule. On ne peut donc pas faire disparaître la fameuse erreur "<em>undefined is not a function</em>" avec ce code :</p> +La variable globale `undefined` est également en lecture seule. On ne peut donc pas faire disparaître la fameuse erreur "_undefined is not a function_" avec ce code : -<pre class="brush: js example-bad">"use strict"; +```js example-bad +"use strict"; undefined = function () {}; // TypeError: "undefined" is read-only -</pre> +``` -<h3 id="Exemples_valides">Exemples valides</h3> +### Exemples valides -<pre class="brush: js example-good">"use strict"; +```js example-good +"use strict"; var obj = Object.freeze({name: "Score", points: 157}); obj = {name: obj.name, points: 0}; // En changeant d'objet, ça fonctionne @@ -71,11 +74,9 @@ obj = {name: obj.name, points: 0}; "use strict"; var NB_POUMONS = 2; // `var` fonctionne NB_POUMONS = 3; // ok -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("Object.defineProperty()")}}</li> - <li>{{jsxref("Object.freeze()")}}</li> -</ul> +- {{jsxref("Object.defineProperty()")}} +- {{jsxref("Object.freeze()")}} diff --git a/files/fr/web/javascript/reference/errors/redeclared_parameter/index.md b/files/fr/web/javascript/reference/errors/redeclared_parameter/index.md index 55c0e38653..947a60aae8 100644 --- a/files/fr/web/javascript/reference/errors/redeclared_parameter/index.md +++ b/files/fr/web/javascript/reference/errors/redeclared_parameter/index.md @@ -8,56 +8,53 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Redeclared_parameter original_slug: Web/JavaScript/Reference/Erreurs/Redeclared_parameter --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: Let/Const redeclaration (Edge) -SyntaxError: redeclaration of formal parameter "x" (Firefox) -SyntaxError: Identifier "x" has already been declared (Chrome) -</pre> + SyntaxError: Let/Const redeclaration (Edge) + SyntaxError: redeclaration of formal parameter "x" (Firefox) + SyntaxError: Identifier "x" has already been declared (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}</p> +{{jsxref("SyntaxError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Le même nom de variable est présent comme paramètre de la fonction et dans une affectation <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/let">let</a></code> au sein du corps de cette fonction et il n'est pas possible de redéclarer la même variable dans la même fonction ou dans le même bloc avec <code>let</code>.</p> +Le même nom de variable est présent comme paramètre de la fonction et dans une affectation [`let`](/fr/docs/Web/JavaScript/Reference/Instructions/let) au sein du corps de cette fonction et il n'est pas possible de redéclarer la même variable dans la même fonction ou dans le même bloc avec `let`. -<h2 id="Exemples">Exemples</h2> +## Exemples -<p>Dans le fragment de code qui suit, la variable <code>arg</code> redéclare l'argument passé à la fonction.</p> +Dans le fragment de code qui suit, la variable `arg` redéclare l'argument passé à la fonction. -<pre class="brush: js example-bad">function f(arg) { +```js example-bad +function f(arg) { let arg = "toto"; } // SyntaxError: redeclaration of formal parameter "arg" -</pre> +``` -<p>Si on souhaite changer la valeur de <code>arg</code> dans le corps de la fonction, c'est possible mais il ne faut pas la redéclarer. Autrement dit, on peut retirer le mot-clé <code>let</code>. Si on souhaite plutôt créer une nouvelle variable, mieux vaudra utiliser un autre nom afin d'éviter les conflits avec les noms des paramètres existants.</p> +Si on souhaite changer la valeur de `arg` dans le corps de la fonction, c'est possible mais il ne faut pas la redéclarer. Autrement dit, on peut retirer le mot-clé `let`. Si on souhaite plutôt créer une nouvelle variable, mieux vaudra utiliser un autre nom afin d'éviter les conflits avec les noms des paramètres existants. -<pre class="brush: js example-good">function f(arg) { +```js example-good +function f(arg) { arg = "toto"; } function f(arg) { let truc = "toto"; } -</pre> +``` -<h2 id="Notes_de_compatibilité">Notes de compatibilité</h2> +## Notes de compatibilité -<ul> - <li>Avant Firefox 49 {{geckoRelease(49)}}, cela provoquait une exception {{jsxref("TypeError")}} ({{bug(1275240)}}).</li> -</ul> +- Avant Firefox 49 {{geckoRelease(49)}}, cela provoquait une exception {{jsxref("TypeError")}} ({{bug(1275240)}}). -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/let">let</a></code></li> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/const">const</a></code></li> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code></li> - <li><a href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Déclarations">Déclarer des variables</a> dans le <a href="/fr/docs/Web/JavaScript/Guide">guide JavaScript</a></li> -</ul> +- [`let`](/fr/docs/Web/JavaScript/Reference/Instructions/let) +- [`const`](/fr/docs/Web/JavaScript/Reference/Instructions/const) +- [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var) +- [Déclarer des variables](/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Déclarations) dans le [guide JavaScript](/fr/docs/Web/JavaScript/Guide) diff --git a/files/fr/web/javascript/reference/errors/reduce_of_empty_array_with_no_initial_value/index.md b/files/fr/web/javascript/reference/errors/reduce_of_empty_array_with_no_initial_value/index.md index 4afa3f08ed..aae211ac07 100644 --- a/files/fr/web/javascript/reference/errors/reduce_of_empty_array_with_no_initial_value/index.md +++ b/files/fr/web/javascript/reference/errors/reduce_of_empty_array_with_no_initial_value/index.md @@ -9,81 +9,81 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Reduce_of_empty_array_with_no_initial_value original_slug: Web/JavaScript/Reference/Erreurs/Reduce_of_empty_array_with_no_initial_value --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: reduce of empty array with no initial value -</pre> + TypeError: reduce of empty array with no initial value -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}</p> +{{jsxref("TypeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>En JavaScript, il existe plusieurs fonctions qui permettent de réduire un tableau :</p> +En JavaScript, il existe plusieurs fonctions qui permettent de réduire un tableau : -<ul> - <li>{{jsxref("Array.prototype.reduce()")}}, {{jsxref("Array.prototype.reduceRight()")}} ainsi que</li> - <li>{{jsxref("TypedArray.prototype.reduce()")}}, {{jsxref("TypedArray.prototype.reduceRight()")}}).</li> -</ul> +- {{jsxref("Array.prototype.reduce()")}}, {{jsxref("Array.prototype.reduceRight()")}} ainsi que +- {{jsxref("TypedArray.prototype.reduce()")}}, {{jsxref("TypedArray.prototype.reduceRight()")}}). -<p>Ces fonctions utilisent un argument optionnel <code>valeurInitiale</code> (qui sera utilisée comme premier argument pour le premier appel du <code>callback</code>). Toutefois, si aucune valeur initiale explicite est fournie, la méthode utilisera le premier élément de l'objet {{jsxref("Array")}} / {{jsxref("TypedArray")}} comme valeur initiale. Cette exception est déclenchée lorsqu'on souhaite réduire un tableau vide car aucune valeur initiale n'a été fournie.</p> +Ces fonctions utilisent un argument optionnel `valeurInitiale` (qui sera utilisée comme premier argument pour le premier appel du `callback`). Toutefois, si aucune valeur initiale explicite est fournie, la méthode utilisera le premier élément de l'objet {{jsxref("Array")}} / {{jsxref("TypedArray")}} comme valeur initiale. Cette exception est déclenchée lorsqu'on souhaite réduire un tableau vide car aucune valeur initiale n'a été fournie. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Exemples_invalides">Exemples invalides</h3> +### Exemples invalides -<p>Ce problème se produit lorsqu'on combine une méthode de filtrage ({{jsxref("Array.prototype.filter()")}}, {{jsxref("TypedArray.prototype.filter()")}}) qui retire tous les éléments du tableau. Si on applique ensuite une réduction, il n'y aura pas de valeur initiale.</p> +Ce problème se produit lorsqu'on combine une méthode de filtrage ({{jsxref("Array.prototype.filter()")}}, {{jsxref("TypedArray.prototype.filter()")}}) qui retire tous les éléments du tableau. Si on applique ensuite une réduction, il n'y aura pas de valeur initiale. -<pre class="brush: js example-bad">var ints = [0, -1, -2, -3, -4, -5]; -ints.filter(x => x > 0) // cet appel retire tous les éléments - .reduce((x, y) => x + y) // aucun ne peut alors être utilisé comme valeur initiale</pre> +```js example-bad +var ints = [0, -1, -2, -3, -4, -5]; +ints.filter(x => x > 0) // cet appel retire tous les éléments + .reduce((x, y) => x + y) // aucun ne peut alors être utilisé comme valeur initiale +``` -<p>Cela peut également se produire si on utilise un sélecteur avec une coquille ou que la liste contient un nombre d'élément inattendu:</p> +Cela peut également se produire si on utilise un sélecteur avec une coquille ou que la liste contient un nombre d'élément inattendu: -<pre class="brush: js example-bad">var names = document.getElementsByClassName("names"); -var name_list = Array.prototype.reduce.call(names, (acc, name) => acc + ", " + name); -</pre> +```js example-bad +var names = document.getElementsByClassName("names"); +var name_list = Array.prototype.reduce.call(names, (acc, name) => acc + ", " + name); +``` -<h3 id="Exemples_valides">Exemples valides</h3> +### Exemples valides -<p>On peut résoudre ces problèmes de deux façons.</p> +On peut résoudre ces problèmes de deux façons. -<p>On peut fournir une valeur initiale qui soit l'élément neutre de la réduction (par exemple 0 si on additionne, 1 si on multiplie ou la chaîne vide si on concatène du texte).</p> +On peut fournir une valeur initiale qui soit l'élément neutre de la réduction (par exemple 0 si on additionne, 1 si on multiplie ou la chaîne vide si on concatène du texte). -<pre class="brush: js example-good">var ints = [0, -1, -2, -3, -4, -5]; -ints.filter(x => x > 0) // removes all elements - .reduce((x, y) => x + y, 0) // the initial value is the neutral element of the addition -</pre> +```js example-good +var ints = [0, -1, -2, -3, -4, -5]; +ints.filter(x => x > 0) // removes all elements + .reduce((x, y) => x + y, 0) // the initial value is the neutral element of the addition +``` -<p>On peut également gérer le cas où le tableau est vide, avant d'appeler <code>reduce</code> ou dans le <em>callback</em> après avoir ajouté une valeur initiale.</p> +On peut également gérer le cas où le tableau est vide, avant d'appeler `reduce` ou dans le _callback_ après avoir ajouté une valeur initiale. -<pre class="brush: js example-good">var names = document.getElementsByClassName("names"); +```js example-good +var names = document.getElementsByClassName("names"); var nameList1 = ""; -if (names1.length >= 1) - nameList1 = Array.prototype.reduce.call(names, (acc, name) => acc + ", " + name); +if (names1.length >= 1) + nameList1 = Array.prototype.reduce.call(names, (acc, name) => acc + ", " + name); // nameList1 == "" lorsque names est vide -var nameList2 = Array.prototype.reduce.call(names, (acc, name) => { +var nameList2 = Array.prototype.reduce.call(names, (acc, name) => { if (acc == "") // la valeur initiale return name; return acc + ", " + name; }, ""); // nameList2 == "" lorsque names est vide -</pre> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("Array.prototype.reduce()")}}</li> - <li>{{jsxref("Array.prototype.reduceRight()")}}</li> - <li>{{jsxref("TypedArray.prototype.reduce()")}}</li> - <li>{{jsxref("TypedArray.prototype.reduceRight()")}}</li> - <li>{{jsxref("Array")}}</li> - <li>{{jsxref("TypedArray")}}</li> - <li>{{jsxref("Array.prototype.filter()")}}</li> - <li>{{jsxref("TypedArray.prototype.filter()")}}</li> -</ul> +``` + +## Voir aussi + +- {{jsxref("Array.prototype.reduce()")}} +- {{jsxref("Array.prototype.reduceRight()")}} +- {{jsxref("TypedArray.prototype.reduce()")}} +- {{jsxref("TypedArray.prototype.reduceRight()")}} +- {{jsxref("Array")}} +- {{jsxref("TypedArray")}} +- {{jsxref("Array.prototype.filter()")}} +- {{jsxref("TypedArray.prototype.filter()")}} diff --git a/files/fr/web/javascript/reference/errors/reserved_identifier/index.md b/files/fr/web/javascript/reference/errors/reserved_identifier/index.md index f632ea336e..e911418f06 100644 --- a/files/fr/web/javascript/reference/errors/reserved_identifier/index.md +++ b/files/fr/web/javascript/reference/errors/reserved_identifier/index.md @@ -8,75 +8,74 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Reserved_identifier original_slug: Web/JavaScript/Reference/Erreurs/Reserved_identifier --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: The use of a future reserved word for an identifier is invalid (Edge) -SyntaxError: "x" is a reserved identifier (Firefox) -SyntaxError: Unexpected reserved word (Chrome)</pre> + SyntaxError: The use of a future reserved word for an identifier is invalid (Edge) + SyntaxError: "x" is a reserved identifier (Firefox) + SyntaxError: Unexpected reserved word (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}</p> +{{jsxref("SyntaxError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p><a href="/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Mots-clés_réservés_selon_ECMAScript_2015">Les mots-clés réservés</a> lèveront une exception s'ils sont utilisés en tant qu'identifiants. Voici les mots-clés réservés en mode strict et en mode <em>sloppy</em> :</p> +[Les mots-clés réservés](/fr/docs/Web/JavaScript/Reference/Grammaire_lexicale#Mots-clés_réservés_selon_ECMAScript_2015) lèveront une exception s'ils sont utilisés en tant qu'identifiants. Voici les mots-clés réservés en mode strict et en mode _sloppy_ : -<ul> - <li><code>enum</code></li> -</ul> +- `enum` -<p>Voici les mots-clés uniquement réservés en mode strict :</p> +Voici les mots-clés uniquement réservés en mode strict : -<ul class="threecolumns"> - <li><code>implements</code></li> - <li><code>interface</code></li> - <li>{{jsxref("Statements/let", "let")}}</li> - <li><code>package</code></li> - <li><code>private</code></li> - <li><code>protected</code></li> - <li><code>public</code></li> - <li><code>static</code></li> -</ul> +- `implements` +- `interface` +- {{jsxref("Statements/let", "let")}} +- `package` +- `private` +- `protected` +- `public` +- `static` -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Mots-clés_réservés_en_modes_strict_et_non-strict">Mots-clés réservés en modes strict et non-strict</h3> +### Mots-clés réservés en modes strict et non-strict -<p>L'identifiant <code>enum</code> est réservé dans les différents cas :</p> +L'identifiant `enum` est réservé dans les différents cas : -<pre class="brush: js example-bad">var enum = { RED: 0, GREEN: 1, BLUE: 2 }; +```js example-bad +var enum = { RED: 0, GREEN: 1, BLUE: 2 }; // SyntaxError: enum is a reserved identifier -</pre> +``` -<p>En mode strict, d'autres mots-clés sont réservés :</p> +En mode strict, d'autres mots-clés sont réservés : -<pre class="brush: js example-bad">"use strict"; +```js example-bad +"use strict"; var package = ["pomme", "poire", "pêches"]; // SyntaxError: package is a reserved identifier -</pre> +``` -<p>Pour ne pas avoir l'erreur, il faudra renommer les variables :</p> +Pour ne pas avoir l'erreur, il faudra renommer les variables : -<pre class="brush: js example-good">var enumCouleurs = { RED: 0, GREEN: 1, BLUE: 2 }; -var liste = ["pomme", "poire", "pêches"];</pre> +```js example-good +var enumCouleurs = { RED: 0, GREEN: 1, BLUE: 2 }; +var liste = ["pomme", "poire", "pêches"]; +``` -<h3 id="Mettre_à_jour_les_anciens_navigateurs">Mettre à jour les anciens navigateurs</h3> +### Mettre à jour les anciens navigateurs -<p>Si vous utilisez un ancien navigateur qui n'implémente pas <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/let">let</a></code> ou <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/class">class</a></code>, vous devrez mettre à jour votre navigateur :</p> +Si vous utilisez un ancien navigateur qui n'implémente pas [`let`](/fr/docs/Web/JavaScript/Reference/Instructions/let) ou [`class`](/fr/docs/Web/JavaScript/Reference/Instructions/class), vous devrez mettre à jour votre navigateur : -<pre class="brush: js">"use strict"; +```js +"use strict"; class DocArchiver {} // SyntaxError: class is a reserved identifier // (lève une exception dans les anciens navigateurs // tels que Firefox 44 et les versions antérieures) -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="https://wiki.c2.com/?GoodVariableNames">Utiliser de bons noms de variable</a></li> -</ul> +- [Utiliser de bons noms de variable](https://wiki.c2.com/?GoodVariableNames) diff --git a/files/fr/web/javascript/reference/errors/resulting_string_too_large/index.md b/files/fr/web/javascript/reference/errors/resulting_string_too_large/index.md index 78ad63d9f3..1c4eddce51 100644 --- a/files/fr/web/javascript/reference/errors/resulting_string_too_large/index.md +++ b/files/fr/web/javascript/reference/errors/resulting_string_too_large/index.md @@ -8,43 +8,42 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Resulting_string_too_large original_slug: Web/JavaScript/Reference/Erreurs/Resulting_string_too_large --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">RangeError: argument out of range (Edge) -RangeError: repeat count must be less than infinity and not overflow maximum string size (Firefox) -RangeError: Invalid count value (Chrome) -</pre> + RangeError: argument out of range (Edge) + RangeError: repeat count must be less than infinity and not overflow maximum string size (Firefox) + RangeError: Invalid count value (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("RangeError")}}</p> +{{jsxref("RangeError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>La méthode {{jsxref("String.prototype.repeat()")}}, qui permet de répéter une chaîne de caractères, a été utilisée avec un argument qui n'est pas compris entre 0 et {{jsxref("Infinity")}} (exclue) (ce qui correspond à l'intervalle [0, +∞))</p> +La méthode {{jsxref("String.prototype.repeat()")}}, qui permet de répéter une chaîne de caractères, a été utilisée avec un argument qui n'est pas compris entre 0 et {{jsxref("Infinity")}} (exclue) (ce qui correspond à l'intervalle \[0, +∞)) -<p>La chaîne de caractères crée par cette méthode ne doit pas dépasser la taille maximale d'une chaîne. Cette taille varie selon le moteur JavaScript. Pour Firefox (SpiderMonkey), la taille maximale d'une chaîne de caractères vaut 2^28-1 (<code>0xFFFFFFF</code>).</p> +La chaîne de caractères crée par cette méthode ne doit pas dépasser la taille maximale d'une chaîne. Cette taille varie selon le moteur JavaScript. Pour Firefox (SpiderMonkey), la taille maximale d'une chaîne de caractères vaut 2^28-1 (`0xFFFFFFF`). -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Exemples_invalides">Exemples invalides</h3> +### Exemples invalides -<pre class="brush: js example-bad">'abc'.repeat(Infinity); // RangeError +```js example-bad +'abc'.repeat(Infinity); // RangeError 'a'.repeat(2**28); // RangeError -</pre> +``` -<h3 id="Exemples_valides">Exemples valides</h3> +### Exemples valides -<pre class="brush: js example-good">'abc'.repeat(0); // '' +```js example-good +'abc'.repeat(0); // '' 'abc'.repeat(1); // 'abc' 'abc'.repeat(2); // 'abcabc' 'abc'.repeat(3.5); // 'abcabcabc' (count will be converted to integer) -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("String.prototype.repeat()")}}</li> -</ul> +- {{jsxref("String.prototype.repeat()")}} diff --git a/files/fr/web/javascript/reference/errors/stmt_after_return/index.md b/files/fr/web/javascript/reference/errors/stmt_after_return/index.md index 4d506a6285..0105e66e3a 100644 --- a/files/fr/web/javascript/reference/errors/stmt_after_return/index.md +++ b/files/fr/web/javascript/reference/errors/stmt_after_return/index.md @@ -7,44 +7,40 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Stmt_after_return original_slug: Web/JavaScript/Reference/Erreurs/Stmt_after_return --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">Warning: unreachable code after return statement (Firefox) -</pre> + Warning: unreachable code after return statement (Firefox) -<h2 id="Type_derreur">Type d'erreur</h2> +## Type d'erreur -<p>Avertissement</p> +Avertissement -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Ce problème peut avoir deux origines :</p> +Ce problème peut avoir deux origines : -<ul> - <li>Une expression a été utilisée après l'instruction {{jsxref("Instructions/return", "return")}}</li> - <li>Une instruction <code>return</code> a été utilisée sans point virgule mais une expression suivait cette instruction.</li> -</ul> +- Une expression a été utilisée après l'instruction {{jsxref("Instructions/return", "return")}} +- Une instruction `return` a été utilisée sans point virgule mais une expression suivait cette instruction. -<p>Lorsqu'une expression existe après une instruction <code>return</code> valide, un avertissement est produit pour alerter qu'une portion du code ne peut pas être atteinte et ne sera donc jamais lue et exécutée.</p> +Lorsqu'une expression existe après une instruction `return` valide, un avertissement est produit pour alerter qu'une portion du code ne peut pas être atteinte et ne sera donc jamais lue et exécutée. -<p>Pourquoi est-il préférable d'ajouter des points-virgules après les instructions <code>return</code> ? Si on utilise une instruction <code>return</code> sans point-virgule, cela peut créer une ambiguïté : est-ce que le développeur souhaite que le code qui suit sur la ligne d'après soit exécuté ou non ? L'avertissement relève cette ambiguïté afin de mieux la percevoir pour la lever.</p> +Pourquoi est-il préférable d'ajouter des points-virgules après les instructions `return` ? Si on utilise une instruction `return` sans point-virgule, cela peut créer une ambiguïté : est-ce que le développeur souhaite que le code qui suit sur la ligne d'après soit exécuté ou non ? L'avertissement relève cette ambiguïté afin de mieux la percevoir pour la lever. -<p>Les avertissements ne seront pas affichés pour les <code>return</code> sans point-virgule si ces instructions suivent :</p> +Les avertissements ne seront pas affichés pour les `return` sans point-virgule si ces instructions suivent : -<ul> - <li>{{jsxref("Instructions/throw", "throw")}}</li> - <li>{{jsxref("Instructions/break", "break")}}</li> - <li>{{jsxref("Instructions/var", "var")}}</li> - <li>{{jsxref("Instructions/function", "function")}}</li> -</ul> +- {{jsxref("Instructions/throw", "throw")}} +- {{jsxref("Instructions/break", "break")}} +- {{jsxref("Instructions/var", "var")}} +- {{jsxref("Instructions/function", "function")}} -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Exemples_invalides">Exemples invalides</h3> +### Exemples invalides -<pre class="brush: js example-bad">function f() { +```js example-bad +function f() { var x = 3; x += 4; return x; // return permet de finir la fonction sur le champ @@ -55,11 +51,12 @@ function f() { return // Cette instruction est traitée `return;` 3 + 4; // La fonction termine et cette ligne n'est jamais traitée } -</pre> +``` -<h3 id="Exemples_valides">Exemples valides</h3> +### Exemples valides -<pre class="brush: js example-good">function f() { +```js example-good +function f() { var x = 3; x += 4; x -= 3; @@ -71,10 +68,8 @@ function f() { return 3 + 4 // OK : un return sans point-virgule // avec une expression sur la même ligne } -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("Instructions/return", "L'ajout automatique de point-virgule", "#Ajout_automatique_de_point-virgule", 1)}}</li> -</ul> +- {{jsxref("Instructions/return", "L'ajout automatique de point-virgule", "#Ajout_automatique_de_point-virgule", 1)}} diff --git a/files/fr/web/javascript/reference/errors/strict_non_simple_params/index.md b/files/fr/web/javascript/reference/errors/strict_non_simple_params/index.md index 26abbf3a40..22d30809a4 100644 --- a/files/fr/web/javascript/reference/errors/strict_non_simple_params/index.md +++ b/files/fr/web/javascript/reference/errors/strict_non_simple_params/index.md @@ -9,108 +9,109 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Strict_Non_Simple_Params original_slug: Web/JavaScript/Reference/Erreurs/Strict_Non_Simple_Params --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">Edge: -Cannot apply strict mode on functions with non-simple parameter list + Edge: + Cannot apply strict mode on functions with non-simple parameter list -Firefox: -SyntaxError: "use strict" not allowed in function with default parameter -SyntaxError: "use strict" not allowed in function with rest parameter -SyntaxError: "use strict" not allowed in function with destructuring parameter + Firefox: + SyntaxError: "use strict" not allowed in function with default parameter + SyntaxError: "use strict" not allowed in function with rest parameter + SyntaxError: "use strict" not allowed in function with destructuring parameter -Chrome: -SyntaxError: Illegal 'use strict' directive in function with non-simple parameter list -</pre> + Chrome: + SyntaxError: Illegal 'use strict' directive in function with non-simple parameter list -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}.</p> +{{jsxref("SyntaxError")}}. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Une directive <code>"use strict"</code> apparaît au début d'une fonction qui possède l'un des paramètres suivants :</p> +Une directive `"use strict"` apparaît au début d'une fonction qui possède l'un des paramètres suivants : -<ul> - <li>{{jsxref("Fonctions/Valeurs_par_défaut_des_arguments", "Des paramètres par défaut", "", 1)}}</li> - <li>{{jsxref("Fonctions/paramètres_du_reste", "Des paramètres du reste", "", 1)}}</li> - <li>{{jsxref("Opérateurs/Affecter_par_décomposition", "Des paramètres décomposés", "", 1)}}</li> -</ul> +- {{jsxref("Fonctions/Valeurs_par_défaut_des_arguments", "Des paramètres par défaut", "", 1)}} +- {{jsxref("Fonctions/paramètres_du_reste", "Des paramètres du reste", "", 1)}} +- {{jsxref("Opérateurs/Affecter_par_décomposition", "Des paramètres décomposés", "", 1)}} -<p>Selon la spécification ECMAScript, une directive <code>"use strict"</code> ne peut pas être utilisée pour de telles fonctions.</p> +Selon la spécification ECMAScript, une directive `"use strict"` ne peut pas être utilisée pour de telles fonctions. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Déclaration_de_fonction">Déclaration de fonction</h3> +### Déclaration de fonction -<p>Dans l'exemple qui suit, la fonction <code>somme</code> possède deux paramètres par défaut <code>a=1</code> et <code>b=2</code>.</p> +Dans l'exemple qui suit, la fonction `somme` possède deux paramètres par défaut `a=1` et `b=2`. -<pre class="brush: js example-bad">function somme(a = 1, b = 2) { +```js example-bad +function somme(a = 1, b = 2) { // SyntaxError: "use strict" not allowed in function with default parameter "use strict"; return a + b; } -</pre> +``` -<p>Si on veut que la fonction soit en mode strict et que le script entier ou que la fonction englobante peut être en mode strict, il suffira de déplacer l'instruction <code>"use strict"</code> en dehors du corps de la méthode.</p> +Si on veut que la fonction soit en mode strict et que le script entier ou que la fonction englobante peut être en mode strict, il suffira de déplacer l'instruction `"use strict"` en dehors du corps de la méthode. -<pre class="brush: js example-good">"use strict"; +```js example-good +"use strict"; function somme(a = 1, b = 2) { return a + b; } -</pre> +``` -<h3 id="Expression_de_fonction">Expression de fonction</h3> +### Expression de fonction -<p>Il est également possible d'utiliser les expressions de fonction pour résoudre ce problème :</p> +Il est également possible d'utiliser les expressions de fonction pour résoudre ce problème : -<pre class="brush: js example-bad">var somme = function somme([a, b]) { +```js example-bad +var somme = function somme([a, b]) { // SyntaxError: "use strict" not allowed in function with destructuring parameter "use strict"; return a + b; }; -</pre> +``` -<p>On peut convertir le fragment de code précédent avec l'expression suivante :</p> +On peut convertir le fragment de code précédent avec l'expression suivante : -<pre class="brush: js example-good">var somme = (function() { +```js example-good +var somme = (function() { "use strict"; return function somme([a, b]) { return a + b; }; })(); -</pre> +``` -<h3 id="Fonction_fléchée">Fonction fléchée</h3> +### Fonction fléchée -<p>Si on a une fonction fléchée qui doit accéder à la variable <code>this</code> on peut utiliser une fonction fléchée comme fonction englobante :</p> +Si on a une fonction fléchée qui doit accéder à la variable `this` on peut utiliser une fonction fléchée comme fonction englobante : -<pre class="brush: js example-bad">var callback = (...args) => { +```js example-bad +var callback = (...args) => { // SyntaxError: "use strict" not allowed in function with rest parameter "use strict"; return this.run(args); }; -</pre> +``` -<p>This can be converted into following expression.</p> +This can be converted into following expression. -<pre class="brush: js example-good">var callback = (() => { +```js example-good +var callback = (() => { "use strict"; - return (...args) => { + return (...args) => { return this.run(args); }; })(); -</pre> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("Strict_mode", "Le mode strict", "", 1)}}</li> - <li>{{jsxref("Instructions/function", "L'instruction function", "", 1)}}</li> - <li>{{jsxref("Op%C3%A9rateurs/L_op%C3%A9rateur_function", "Les expressions de fonction", "", 1)}}</li> - <li>{{jsxref("Fonctions/Valeurs_par_d%C3%A9faut_des_arguments", "Les paramètres par défaut", "", 1)}}</li> - <li>{{jsxref("Fonctions/paramètres_du_reste", "Les paramètres du reste", "", 1)}}</li> - <li>{{jsxref("Opérateurs/Affecter_par_décomposition", "Les paramètres décomposés", "", 1)}}</li> -</ul> +``` + +## Voir aussi + +- {{jsxref("Strict_mode", "Le mode strict", "", 1)}} +- {{jsxref("Instructions/function", "L'instruction function", "", 1)}} +- {{jsxref("Op%C3%A9rateurs/L_op%C3%A9rateur_function", "Les expressions de fonction", "", 1)}} +- {{jsxref("Fonctions/Valeurs_par_d%C3%A9faut_des_arguments", "Les paramètres par défaut", "", 1)}} +- {{jsxref("Fonctions/paramètres_du_reste", "Les paramètres du reste", "", 1)}} +- {{jsxref("Opérateurs/Affecter_par_décomposition", "Les paramètres décomposés", "", 1)}} diff --git a/files/fr/web/javascript/reference/errors/too_much_recursion/index.md b/files/fr/web/javascript/reference/errors/too_much_recursion/index.md index 097eff25b7..62e269f74a 100644 --- a/files/fr/web/javascript/reference/errors/too_much_recursion/index.md +++ b/files/fr/web/javascript/reference/errors/too_much_recursion/index.md @@ -9,62 +9,64 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Too_much_recursion original_slug: Web/JavaScript/Reference/Erreurs/Too_much_recursion --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">Error: Out of stack space (Edge) -InternalError: too much recursion (Firefox) -RangeError: Maximum call stack size exceeded (Chrome) -</pre> + Error: Out of stack space (Edge) + InternalError: too much recursion (Firefox) + RangeError: Maximum call stack size exceeded (Chrome) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("InternalError")}}.</p> +{{jsxref("InternalError")}}. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Une fonction qui s'appelle elle-même est une fonction <em>recursive</em>. Lorsqu'une certaine condition est respectée, la fonction arrête de s'appeler elle-même, c'est ce qu'on appelle le cas initial.</p> +Une fonction qui s'appelle elle-même est une fonction _recursive_. Lorsqu'une certaine condition est respectée, la fonction arrête de s'appeler elle-même, c'est ce qu'on appelle le cas initial. -<p>D'une certaine façon, une récursion est semblable à une boucle. Les deux exécutent le même code plusieurs fois, et les deux ont besoin d'une condition d'arrêt afin d'éviter une boucle infinie ou une récursion infinie. Lorsqu'il y a trop de niveaux de récursion ou une récursion infinie, JavaScript lèvera cette erreur.</p> +D'une certaine façon, une récursion est semblable à une boucle. Les deux exécutent le même code plusieurs fois, et les deux ont besoin d'une condition d'arrêt afin d'éviter une boucle infinie ou une récursion infinie. Lorsqu'il y a trop de niveaux de récursion ou une récursion infinie, JavaScript lèvera cette erreur. -<h2 id="Exemples">Exemples</h2> +## Exemples -<p>Cette fonction récursive est exécutée 10 fois comme l'indique la condition de sortie :</p> +Cette fonction récursive est exécutée 10 fois comme l'indique la condition de sortie : -<pre class="brush: js">function loop(x) { - if (x >= 10) // "x >= 10" is the exit condition +```js +function loop(x) { + if (x >= 10) // "x >= 10" is the exit condition return; // do stuff loop(x + 1); // the recursive call } -loop(0);</pre> +loop(0); +``` -<p>Si la condition d'arrêt est beaucoup trop grande, cela ne fonctionnera pas :</p> +Si la condition d'arrêt est beaucoup trop grande, cela ne fonctionnera pas : -<pre class="brush: js example-bad">function loop(x) { - if (x >= 1000000000000) +```js example-bad +function loop(x) { + if (x >= 1000000000000) return; // do stuff loop(x + 1); } loop(0); -// InternalError: too much recursion</pre> +// InternalError: too much recursion +``` -<p>Si la fonction récursive ne possède pas de cas initial, il n'y aura pas de condition de sortie et la fonction continuera de s'appeler indéfiniment.</p> +Si la fonction récursive ne possède pas de cas initial, il n'y aura pas de condition de sortie et la fonction continuera de s'appeler indéfiniment. -<pre class="brush: js example-bad">function boucle(x) { +```js example-bad +function boucle(x) { boucle(x + 1); // il n'y a pas de cas initial } boucle(0); -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{Glossary("Récursion")}}</li> - <li><a href="/fr/docs/Web/JavaScript/Guide/Fonctions#La_récursivité">Les fonctions récursives</a></li> -</ul> +- {{Glossary("Récursion")}} +- [Les fonctions récursives](/fr/docs/Web/JavaScript/Guide/Fonctions#La_récursivité) diff --git a/files/fr/web/javascript/reference/errors/undeclared_var/index.md b/files/fr/web/javascript/reference/errors/undeclared_var/index.md index 26293dc271..8344607e21 100644 --- a/files/fr/web/javascript/reference/errors/undeclared_var/index.md +++ b/files/fr/web/javascript/reference/errors/undeclared_var/index.md @@ -8,60 +8,58 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Undeclared_var original_slug: Web/JavaScript/Reference/Erreurs/Undeclared_var --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">ReferenceError: assignment to undeclared variable "x" (Firefox) -ReferenceError: "x" is not defined (Chrome) -ReferenceError: Variable undefined in strict mode (Edge) -</pre> + ReferenceError: assignment to undeclared variable "x" (Firefox) + ReferenceError: "x" is not defined (Chrome) + ReferenceError: Variable undefined in strict mode (Edge) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>Une erreur {{jsxref("ReferenceError")}}, uniquement <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">en mode strict</a>.</p> +Une erreur {{jsxref("ReferenceError")}}, uniquement [en mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode). -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Une valeur a été affectée à une variable non-déclarée. Autrement dit, il y a eu une affectation qui n'utilise pas le mot-clé <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code>. Il existe certaines différences entre les variables déclarées et les variables non déclarées ce qui peut entraîner des résultats étranges. C'est pour cette raison que le moteur affiche une erreur en mode strict.</p> +Une valeur a été affectée à une variable non-déclarée. Autrement dit, il y a eu une affectation qui n'utilise pas le mot-clé [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var). Il existe certaines différences entre les variables déclarées et les variables non déclarées ce qui peut entraîner des résultats étranges. C'est pour cette raison que le moteur affiche une erreur en mode strict. -<p>Trois choses à noter lorsqu'on évoque les variables déclarées/non déclarées :</p> +Trois choses à noter lorsqu'on évoque les variables déclarées/non déclarées : -<ul> - <li>Les variables déclarées sont contraintes dans le contexte d'exécution dans lequel elles sont déclarées. Les variables non déclarées sont toujours globales.</li> - <li>Les variables déclarées sont créées avant que le code soit exécuté. Les variables non déclarées n'existent pas tant que le code qui leur est affecté est exécuté.</li> - <li>Les variables déclarées sont des propriétés non-configurables de leur contexte d'exécution (la fonction ou l'espace global). Les variables non-déclarées sont configurables (elles peuvent être supprimées).</li> -</ul> +- Les variables déclarées sont contraintes dans le contexte d'exécution dans lequel elles sont déclarées. Les variables non déclarées sont toujours globales. +- Les variables déclarées sont créées avant que le code soit exécuté. Les variables non déclarées n'existent pas tant que le code qui leur est affecté est exécuté. +- Les variables déclarées sont des propriétés non-configurables de leur contexte d'exécution (la fonction ou l'espace global). Les variables non-déclarées sont configurables (elles peuvent être supprimées). -<p>Pour plus de détails et d'exemple, se référer à la page sur <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code>.</p> +Pour plus de détails et d'exemple, se référer à la page sur [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var). -<p>Les erreurs à propos des affectations sur les variables non déclarées se produisent uniquement <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">en mode strict</a>. En mode non-strict, elles sont ignorées silencieusement.</p> +Les erreurs à propos des affectations sur les variables non déclarées se produisent uniquement [en mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode). En mode non-strict, elles sont ignorées silencieusement. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Exemples_invalides">Exemples invalides</h3> +### Exemples invalides -<p>Ici, la variable <code>truc</code> n'est pas déclarée :</p> +Ici, la variable `truc` n'est pas déclarée : -<pre class="brush: js example-bad">function toto() { +```js example-bad +function toto() { "use strict"; truc = true; } toto(); // ReferenceError: assignment to undeclared variable truc -</pre> +``` -<h3 id="Exemples_valides">Exemples valides</h3> +### Exemples valides -<p>Afin de déclarer <code>truc</code>, on peut ajouter le mot-clé <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code> devant.</p> +Afin de déclarer `truc`, on peut ajouter le mot-clé [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var) devant. -<pre class="brush: js example-good">function toto() { +```js example-good +function toto() { "use strict"; var truc = true; } -toto();</pre> +toto(); +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">Le mode strict</a></li> -</ul> +- [Le mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode) diff --git a/files/fr/web/javascript/reference/errors/undefined_prop/index.md b/files/fr/web/javascript/reference/errors/undefined_prop/index.md index b3b000d302..3577d40eb6 100644 --- a/files/fr/web/javascript/reference/errors/undefined_prop/index.md +++ b/files/fr/web/javascript/reference/errors/undefined_prop/index.md @@ -9,38 +9,39 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Undefined_prop original_slug: Web/JavaScript/Reference/Erreurs/Undefined_prop --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">ReferenceError: reference to undefined property "x" (Firefox) -</pre> + ReferenceError: reference to undefined property "x" (Firefox) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>Uniquement pour Firefox. Une erreur {{jsxref("ReferenceError")}} lancée en avertissement, uniquement si la préférence <code>javascript.options.strict</code> vaut <code>true</code>.</p> +Uniquement pour Firefox. Une erreur {{jsxref("ReferenceError")}} lancée en avertissement, uniquement si la préférence `javascript.options.strict` vaut `true`. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Le code tente d'accéder à une propriété inexistante d'un objet. Il existe deux méthodes pour accéder aux propriétés. Pour plus de détails, on pourra lire la page de la référence sur <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres">les accesseurs de propriété</a>.</p> +Le code tente d'accéder à une propriété inexistante d'un objet. Il existe deux méthodes pour accéder aux propriétés. Pour plus de détails, on pourra lire la page de la référence sur [les accesseurs de propriété](/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_membres). -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Exemples_invalides">Exemples invalides</h3> +### Exemples invalides -<p>Ici, la propriété <code>truc</code> n'est pas une propriété définie et on obtient alors une <code>ReferenceError</code>.</p> +Ici, la propriété `truc` n'est pas une propriété définie et on obtient alors une `ReferenceError`. -<pre class="brush: js example-bad">"use strict"; +```js example-bad +"use strict"; var toto = {}; toto.truc; // ReferenceError: reference to undefined property "bar" -</pre> +``` -<h3 id="Exemples_valides">Exemples valides</h3> +### Exemples valides -<p>Pour éviter cette erreur, il faut que <code>truc</code> soit une variable « définie » ou vérifier son existence avant de l'utiliser (en utilisant par exemple la méthode {{jsxref("Object.prototype.hasOwnProperty()")}}).</p> +Pour éviter cette erreur, il faut que `truc` soit une variable « définie » ou vérifier son existence avant de l'utiliser (en utilisant par exemple la méthode {{jsxref("Object.prototype.hasOwnProperty()")}}). -<pre class="brush: js example-good">"use strict"; +```js example-good +"use strict"; var toto = {}; @@ -49,10 +50,9 @@ console.log(toto.truc); // "lune" if (foo.hasOwnProperty("truc")) { console.log(toto.truc); -}</pre> +} +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("Opérateurs/Opérateurs_de_membres", "Accesseurs de propriété", 0, 1)}}</li> -</ul> +- {{jsxref("Opérateurs/Opérateurs_de_membres", "Accesseurs de propriété", 0, 1)}} diff --git a/files/fr/web/javascript/reference/errors/unexpected_token/index.md b/files/fr/web/javascript/reference/errors/unexpected_token/index.md index 771455c514..f2a9fb865a 100644 --- a/files/fr/web/javascript/reference/errors/unexpected_token/index.md +++ b/files/fr/web/javascript/reference/errors/unexpected_token/index.md @@ -9,70 +9,74 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Unexpected_token original_slug: Web/JavaScript/Reference/Erreurs/Unexpected_token --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: expected expression, got "x" -SyntaxError: expected property name, got "x" -SyntaxError: expected target, got "x" -SyntaxError: expected rest argument name, got "x" -SyntaxError: expected closing parenthesis, got "x" -SyntaxError: expected '=>' after argument list, got "x" -</pre> + SyntaxError: expected expression, got "x" + SyntaxError: expected property name, got "x" + SyntaxError: expected target, got "x" + SyntaxError: expected rest argument name, got "x" + SyntaxError: expected closing parenthesis, got "x" + SyntaxError: expected '=>' after argument list, got "x" -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}</p> +{{jsxref("SyntaxError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>La syntaxe du langage « attendait » un élément mais quelque chose d'autre est écrit à la place dans le script. Cela peut simplement être dû à une coquille dans le code.</p> +La syntaxe du langage « attendait » un élément mais quelque chose d'autre est écrit à la place dans le script. Cela peut simplement être dû à une coquille dans le code. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Expression_attendue">Expression attendue</h3> +### Expression attendue -<p>Lorsqu'on enchaîne des expressions, par exemple, les virgules ne sont pas autorisées en fin d'expression :</p> +Lorsqu'on enchaîne des expressions, par exemple, les virgules ne sont pas autorisées en fin d'expression : -<pre class="brush: js example-bad">for (let i = 0; i < 5,; ++i) { +```js example-bad +for (let i = 0; i < 5,; ++i) { console.log(i); } // SyntaxError: expected expression, got ')' -</pre> +``` -<p>Pour corriger cette erreur, on peut retirer la virgule superflue ou bien ajouter une autre expression :</p> +Pour corriger cette erreur, on peut retirer la virgule superflue ou bien ajouter une autre expression : -<pre class="brush: js example-good">for (let i = 0; i < 5; ++i) { +```js example-good +for (let i = 0; i < 5; ++i) { console.log(i); } -</pre> +``` -<h3 id="Parenthèses_manquantes">Parenthèses manquantes</h3> +### Parenthèses manquantes -<p>Il peut également arriver que des parenthèses manquent autour des instructions <code>if</code> :</p> +Il peut également arriver que des parenthèses manquent autour des instructions `if` : -<pre class="brush: js example-bad">function round(n, upperBound, lowerBound){ - if(n > upperBound) || (n < lowerBound){ +```js example-bad +function round(n, upperBound, lowerBound){ + if(n > upperBound) || (n < lowerBound){ throw 'Number ' + String(n) + ' is more than ' + String(upperBound) + ' or less than ' + String(lowerBound); - }else if(n < ((upperBound + lowerBound)/2)){ + }else if(n < ((upperBound + lowerBound)/2)){ return lowerBound; }else{ return upperBound; } -} // SyntaxError: expected expression, got '||'</pre> +} // SyntaxError: expected expression, got '||' +``` -<p>Si on compte les parenthèses ouvrantes et fermantes, c'est correct mais on peut voir que le OU logique (<code>||</code>) n'est contenu au sein d'aucune paire de parenthèses.</p> +Si on compte les parenthèses ouvrantes et fermantes, c'est correct mais on peut voir que le OU logique (`||`) n'est contenu au sein d'aucune paire de parenthèses. -<p>Pour corriger ce problème, il suffit d'ajouter une paire de parenthèses englobante :</p> +Pour corriger ce problème, il suffit d'ajouter une paire de parenthèses englobante : -<pre class="brush: js example-good">function round(n, upperBound, lowerBound){ - if((n > upperBound) || (n < lowerBound)){ +```js example-good +function round(n, upperBound, lowerBound){ + if((n > upperBound) || (n < lowerBound)){ throw 'Number ' + String(n) + ' is more than ' + String(upperBound) + ' or less than ' + String(lowerBound); - }else if(n < ((upperBound + lowerBound)/2)){ + }else if(n < ((upperBound + lowerBound)/2)){ return lowerBound; }else{ return upperBound; } } -</pre> +``` diff --git a/files/fr/web/javascript/reference/errors/unexpected_type/index.md b/files/fr/web/javascript/reference/errors/unexpected_type/index.md index 6b54febd7b..31477ea2b2 100644 --- a/files/fr/web/javascript/reference/errors/unexpected_type/index.md +++ b/files/fr/web/javascript/reference/errors/unexpected_type/index.md @@ -9,36 +9,36 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Unexpected_type original_slug: Web/JavaScript/Reference/Erreurs/Unexpected_type --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: Unable to get property {x} of undefined or null reference (Edge) -TypeError: "x" is (not) "y" (Firefox) + TypeError: Unable to get property {x} of undefined or null reference (Edge) + TypeError: "x" is (not) "y" (Firefox) -Examples: -TypeError: "x" is undefined -TypeError: "x" is null -TypeError: "undefined" is not an object -TypeError: "x" is not an object or null -TypeError: "x" is not a symbol -</pre> + Examples: + TypeError: "x" is undefined + TypeError: "x" is null + TypeError: "undefined" is not an object + TypeError: "x" is not an object or null + TypeError: "x" is not a symbol -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("TypeError")}}.</p> +{{jsxref("TypeError")}}. -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Un type inattendu a été rencontré. Cela se produit la plupart du temps avec les valeurs {{jsxref("undefined")}} ou {{jsxref("null")}}.</p> +Un type inattendu a été rencontré. Cela se produit la plupart du temps avec les valeurs {{jsxref("undefined")}} ou {{jsxref("null")}}. -<p>Certaines méthodes comme {{jsxref("Object.create()")}} ou {{jsxref("Symbol.keyFor()")}} ont des contraintes sur le type de valeur qui peut être passé en argument.</p> +Certaines méthodes comme {{jsxref("Object.create()")}} ou {{jsxref("Symbol.keyFor()")}} ont des contraintes sur le type de valeur qui peut être passé en argument. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Exemples_invalides">Exemples invalides</h3> +### Exemples invalides -<pre class="brush: js example-bad">// undefined et null : des valeurs +```js example-bad +// undefined et null : des valeurs // sur lesquelles la méthode substring // ne fonctionnera pas var toto = undefined; @@ -55,20 +55,20 @@ Symbol.keyFor(toto); // TypeError: toto is not a symbol var toto = "truc" Object.create(toto); // TypeError: "toto" is not an object or null -</pre> +``` -<h3 id="Résoudre_le_problème">Résoudre le problème</h3> +### Résoudre le problème -<p>Pour résoudre ce problème et écarter les cas où la valeur vaut <code>undefined</code>, on peut par exemple utiliser l'opérateur <code><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof">typeof</a></code>.</p> +Pour résoudre ce problème et écarter les cas où la valeur vaut `undefined`, on peut par exemple utiliser l'opérateur [`typeof`](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_typeof). -<pre class="brush: js">if (typeof toto !== 'undefined') { +```js +if (typeof toto !== 'undefined') { // Désormais, on sait que toto est bien // défini et on peut poursuivre. -}</pre> +} +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("undefined")}}</li> - <li>{{jsxref("null")}}</li> -</ul> +- {{jsxref("undefined")}} +- {{jsxref("null")}} diff --git a/files/fr/web/javascript/reference/errors/unnamed_function_statement/index.md b/files/fr/web/javascript/reference/errors/unnamed_function_statement/index.md index 286bd78e7e..42417c4f4d 100644 --- a/files/fr/web/javascript/reference/errors/unnamed_function_statement/index.md +++ b/files/fr/web/javascript/reference/errors/unnamed_function_statement/index.md @@ -8,82 +8,92 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Unnamed_function_statement original_slug: Web/JavaScript/Reference/Erreurs/Unnamed_function_statement --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">Syntax Error: Expected identifier (Edge) -SyntaxError: function statement requires a name [Firefox] -SyntaxError: Unexpected token ( [Chrome] -</pre> + Syntax Error: Expected identifier (Edge) + SyntaxError: function statement requires a name [Firefox] + SyntaxError: Unexpected token ( [Chrome] -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}</p> +{{jsxref("SyntaxError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p><a href="/fr/docs/Web/JavaScript/Reference/Instructions/function">Une déclaration de fonction</a> présente dans le code requiert un nom. Il faut alors vérifier la façon dont la fonction est définie et s'il est nécessaire de lui fournir un nom ou si la fonction en question est une expression de fonction, une fonction immédiatement invoquée ou si le code de la fonction est simplement bien placé dans son contexte.</p> +[Une déclaration de fonction](/fr/docs/Web/JavaScript/Reference/Instructions/function) présente dans le code requiert un nom. Il faut alors vérifier la façon dont la fonction est définie et s'il est nécessaire de lui fournir un nom ou si la fonction en question est une expression de fonction, une fonction immédiatement invoquée ou si le code de la fonction est simplement bien placé dans son contexte. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Déclaration_Expression">Déclaration / Expression</h3> +### Déclaration / Expression -<p>Une déclaration de fonction requiert un nom. Le fragment de code suivant ne fonctionnera pas :</p> +Une déclaration de fonction requiert un nom. Le fragment de code suivant ne fonctionnera pas : -<pre class="brush: js example-bad">function () { +```js example-bad +function () { return 'Coucou monde :)'; } // SyntaxError: function statement requires a name -</pre> +``` -<p>On peut utiliser <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_function">une expression de fonction</a> à la place :</p> +On peut utiliser [une expression de fonction](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_function) à la place : -<pre class="brush: js example-good">var salutations = function() { +```js example-good +var salutations = function() { return 'Coucou monde :)'; -};</pre> +}; +``` -<p>Si la fonction devait être appelé immédiatement, il suffit d'ajouter des parenthèses autour :</p> +Si la fonction devait être appelé immédiatement, il suffit d'ajouter des parenthèses autour : -<pre class="brush: js example-good">(function () { +```js example-good +(function () { -})();</pre> +})(); +``` -<h3 id="Fonctions_étiquetées">Fonctions étiquetées</h3> +### Fonctions étiquetées -<p>Si vous utilisez des <a href="/fr/docs/Web/JavaScript/Reference/Instructions/label">fonctions étiquetées</a>, il faut toujours fournir un nom après le mot-clé <code>function</code>. Le code suivant ne fonctionnera pas :</p> +Si vous utilisez des [fonctions étiquetées](/fr/docs/Web/JavaScript/Reference/Instructions/label), il faut toujours fournir un nom après le mot-clé `function`. Le code suivant ne fonctionnera pas : -<pre class="brush: js example-bad">function Greeter() { +```js example-bad +function Greeter() { german: function () { return "Moin"; } } // SyntaxError: function statement requires a name -</pre> +``` -<p>En revanche, ceci fonctionnera :</p> +En revanche, ceci fonctionnera : -<pre class="brush: js example-good">function Greeter() { +```js example-good +function Greeter() { german: function g() { return "Moin"; } -}</pre> +} +``` -<h3 id="Méthodes_d'un_objet">Méthodes d'un objet</h3> +### Méthodes d'un objet -<p>Si vous souhaitez construire une méthode d'un objet, il faudra d'abord créer l'objet. Dans ce cas, la syntaxe sans le nom après le mot-clé <code>function</code> sera valide :</p> +Si vous souhaitez construire une méthode d'un objet, il faudra d'abord créer l'objet. Dans ce cas, la syntaxe sans le nom après le mot-clé `function` sera valide : -<pre class="brush: js example-good">var greeter = { +```js example-good +var greeter = { german: function () { return "Moin"; } -};</pre> +}; +``` -<h3 id="Syntaxe_et_fonctions_de_rappel_(callbacks)">Syntaxe et fonctions de rappel (<em>callbacks</em>)</h3> +### Syntaxe et fonctions de rappel (_callbacks_) -<p>Lorsqu'on utilise les <em>callbacks</em>, il est facile de s'emmêler les pinceaux entre les parenthèses et les virgules :</p> +Lorsqu'on utilise les _callbacks_, il est facile de s'emmêler les pinceaux entre les parenthèses et les virgules : -<pre class="brush: js example-bad">promise.then( +```js example-bad +promise.then( function() { console.log("success"); }); @@ -91,11 +101,12 @@ SyntaxError: Unexpected token ( [Chrome] console.log("error"); } // SyntaxError: function statement requires a name -</pre> +``` -<p>La forme correcte serait :</p> +La forme correcte serait : -<pre class="brush: json example-good">promise.then( +```json example-good +promise.then( function() { console.log("success"); }, @@ -103,14 +114,12 @@ SyntaxError: Unexpected token ( [Chrome] console.log("error"); } ); -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Guide/Fonctions">Les fonctions dans le guide JavaScript</a></li> - <li><a href="/fr/docs/Web/JavaScript/Reference/Instructions/function">Les déclarations de fonction</a></li> - <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_function">Les expressions de fonction</a></li> - <li><a href="https://en.wikipedia.org/wiki/Immediately-invoked_function_expression">Les fonctions immédiatement invoquées (ou <em>IIFE</em> en anglais)</a></li> - <li><code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/label">label</a></code></li> -</ul> +- [Les fonctions dans le guide JavaScript](/fr/docs/Web/JavaScript/Guide/Fonctions) +- [Les déclarations de fonction](/fr/docs/Web/JavaScript/Reference/Instructions/function) +- [Les expressions de fonction](/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_function) +- [Les fonctions immédiatement invoquées (ou _IIFE_ en anglais)](https://en.wikipedia.org/wiki/Immediately-invoked_function_expression) +- [`label`](/fr/docs/Web/JavaScript/Reference/Instructions/label) diff --git a/files/fr/web/javascript/reference/errors/unterminated_string_literal/index.md b/files/fr/web/javascript/reference/errors/unterminated_string_literal/index.md index f6ad8afa09..5797276cdb 100644 --- a/files/fr/web/javascript/reference/errors/unterminated_string_literal/index.md +++ b/files/fr/web/javascript/reference/errors/unterminated_string_literal/index.md @@ -9,70 +9,69 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Unterminated_string_literal original_slug: Web/JavaScript/Reference/Erreurs/Unterminated_string_literal --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">SyntaxError: Unterminated string constant (Edge) -SyntaxError: unterminated string literal (Firefox) -</pre> + SyntaxError: Unterminated string constant (Edge) + SyntaxError: unterminated string literal (Firefox) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>{{jsxref("SyntaxError")}}</p> +{{jsxref("SyntaxError")}} -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Une chaîne de caractères ({{jsxref("String")}}) n'est pas bien délimitée quelque part. Les littéraux de chaînes de caractères doivent être délimités par des simples quotes (') ou par des doubles quotes ("). <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/String#Échappement_des_caractères">Les séquences d'échappement</a> permet de représenter dans ces chaînes de caractères. Pour réparer cette erreur :</p> +Une chaîne de caractères ({{jsxref("String")}}) n'est pas bien délimitée quelque part. Les littéraux de chaînes de caractères doivent être délimités par des simples quotes (') ou par des doubles quotes ("). [Les séquences d'échappement](/fr/docs/Web/JavaScript/Reference/Objets_globaux/String#Échappement_des_caractères) permet de représenter dans ces chaînes de caractères. Pour réparer cette erreur : -<ul> - <li>Vérifiez que la chaîne est bien délimitée au début et à la fin par des doubles quotes ou par des simples quotes,</li> - <li>Vérifiez que les caractères spéciaux de la chaîne ont bien été échappés,</li> - <li>Vérifiez que le littéral est bien découpé pour gérer plusieurs lignes (si c'est le cas).</li> -</ul> +- Vérifiez que la chaîne est bien délimitée au début et à la fin par des doubles quotes ou par des simples quotes, +- Vérifiez que les caractères spéciaux de la chaîne ont bien été échappés, +- Vérifiez que le littéral est bien découpé pour gérer plusieurs lignes (si c'est le cas). -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Gérer_plusieurs_lignes">Gérer plusieurs lignes</h3> +### Gérer plusieurs lignes -<p>En JavaScript, on ne peut pas écrire une chaîne simple sur plusieurs lignes comme ceci :</p> +En JavaScript, on ne peut pas écrire une chaîne simple sur plusieurs lignes comme ceci : -<pre class="brush: js example-bad">var longString = "This is a very long string which needs +```js example-bad +var longString = "This is a very long string which needs to wrap across multiple lines because otherwise my code is unreadable."; -// SyntaxError: unterminated string literal</pre> +// SyntaxError: unterminated string literal +``` -<p>Pour écrire une chaîne sur plusieurs lignes, on pourra utiliser :</p> +Pour écrire une chaîne sur plusieurs lignes, on pourra utiliser : -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#Addition_()">L'opérateur +</a>,</li> - <li>Une barre oblique inversée ("\")</li> - <li><a href="/fr/docs/Web/JavaScript/Reference/Littéraux_gabarits">Des littéraux de gabarits</a></li> -</ul> +- [L'opérateur +](</fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#Addition_()>), +- Une barre oblique inversée ("\\") +- [Des littéraux de gabarits](/fr/docs/Web/JavaScript/Reference/Littéraux_gabarits) -<p>Voici la première variante avec l'opérateur de concaténation :</p> +Voici la première variante avec l'opérateur de concaténation : -<pre class="brush: js example-good">var longString = "This is a very long string which needs " + +```js example-good +var longString = "This is a very long string which needs " + "to wrap across multiple lines because " + "otherwise my code is unreadable."; -</pre> +``` -<p>Sinon, on peut utiliser une barre oblique inversée à la fin de chaque ligne pour indiquer qu'elle continue sur la ligne suivante. Attention, il faudra qu'il n'y ait aucun espace ou autre caractère après la barre oblique (il peut bien entendu y avoir un saut de ligne) :</p> +Sinon, on peut utiliser une barre oblique inversée à la fin de chaque ligne pour indiquer qu'elle continue sur la ligne suivante. Attention, il faudra qu'il n'y ait aucun espace ou autre caractère après la barre oblique (il peut bien entendu y avoir un saut de ligne) : -<pre class="brush: js example-good">var longString = "This is a very long string which needs \ +```js example-good +var longString = "This is a very long string which needs \ to wrap across multiple lines because \ otherwise my code is unreadable."; -</pre> +``` -<p>On pourra également utiliser <a href="/fr/docs/Web/JavaScript/Reference/Littéraux_gabarits">les littéraux de gabarits</a> qui sont pris en charge par les environnement ECMAScript 2015 :</p> +On pourra également utiliser [les littéraux de gabarits](/fr/docs/Web/JavaScript/Reference/Littéraux_gabarits) qui sont pris en charge par les environnement ECMAScript 2015 : -<pre class="brush: js example-good">var longString = `This is a very long string which needs +```js example-good +var longString = `This is a very long string which needs to wrap across multiple lines because - otherwise my code is unreadable.`;</pre> + otherwise my code is unreadable.`; +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li>{{jsxref("String")}}</li> - <li><a href="/fr/docs/Web/JavaScript/Reference/Littéraux_gabarits">Les littéraux de gabarits</a></li> -</ul> +- {{jsxref("String")}} +- [Les littéraux de gabarits](/fr/docs/Web/JavaScript/Reference/Littéraux_gabarits) diff --git a/files/fr/web/javascript/reference/errors/var_hides_argument/index.md b/files/fr/web/javascript/reference/errors/var_hides_argument/index.md index dda8687316..8e98669ddf 100644 --- a/files/fr/web/javascript/reference/errors/var_hides_argument/index.md +++ b/files/fr/web/javascript/reference/errors/var_hides_argument/index.md @@ -8,49 +8,48 @@ tags: translation_of: Web/JavaScript/Reference/Errors/Var_hides_argument original_slug: Web/JavaScript/Reference/Erreurs/Var_hides_argument --- -<div>{{jsSidebar("Errors")}}</div> +{{jsSidebar("Errors")}} -<h2 id="Message">Message</h2> +## Message -<pre class="syntaxbox">TypeError: variable "x" redeclares argument (Firefox) -</pre> + TypeError: variable "x" redeclares argument (Firefox) -<h2 id="Type_d'erreur">Type d'erreur</h2> +## Type d'erreur -<p>Une erreur {{jsxref("TypeError")}}, uniquement <a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">en mode strict</a>.</p> +Une erreur {{jsxref("TypeError")}}, uniquement [en mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode). -<h2 id="Quel_est_le_problème">Quel est le problème ?</h2> +## Quel est le problème ? -<p>Le même nom de variable est utilisé comme nom pour un paramètre et comme nom de variable via une affectation <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code>. Cela peut être lié à un conflit de nommage et le moteur envoie un avertissement.</p> +Le même nom de variable est utilisé comme nom pour un paramètre et comme nom de variable via une affectation [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var). Cela peut être lié à un conflit de nommage et le moteur envoie un avertissement. -<p>Cette erreur ne se produit qu'en mode strict. Pour du code non-strict, la redéclaration est ignorée silencieusement..</p> +Cette erreur ne se produit qu'en mode strict. Pour du code non-strict, la redéclaration est ignorée silencieusement.. -<h2 id="Exemples">Exemples</h2> +## Exemples -<h3 id="Exemples_invalides">Exemples invalides</h3> +### Exemples invalides -<p>Ici, la variable <code>arg</code> redéclare l'argument de la fonction :</p> +Ici, la variable `arg` redéclare l'argument de la fonction : -<pre class="brush: js example-bad">"use strict"; +```js example-bad +"use strict"; function f(arg) { var arg = "foo"; } -</pre> +``` -<h3 id="Exemples_valides">Exemples valides</h3> +### Exemples valides -<p>Pour résoudre ce problème, on pourra généralement retirer l'instruction <code><a href="/fr/docs/Web/JavaScript/Reference/Instructions/var">var</a></code> car la variable existe déjà et peut être utilisée. Si on ne veut pas utiliser cette même variable, mieux vaudra renommer le paramètre ou la variable interne afin de lever l'ambiguïté.</p> +Pour résoudre ce problème, on pourra généralement retirer l'instruction [`var`](/fr/docs/Web/JavaScript/Reference/Instructions/var) car la variable existe déjà et peut être utilisée. Si on ne veut pas utiliser cette même variable, mieux vaudra renommer le paramètre ou la variable interne afin de lever l'ambiguïté. -<pre class="brush: js example-good">"use strict"; +```js example-good +"use strict"; function f(arg) { arg = "foo"; } -</pre> +``` -<h2 id="Voir_aussi">Voir aussi</h2> +## Voir aussi -<ul> - <li><a href="/fr/docs/Web/JavaScript/Reference/Strict_mode">Le mode strict</a></li> -</ul> +- [Le mode strict](/fr/docs/Web/JavaScript/Reference/Strict_mode) |