unslug fr: move

49 files changed, 5686 insertions, 0 deletions

diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/arraybuffer/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/arraybuffer/index.html
new file mode 100644
index 0000000000..a0c018f6ed
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/arraybuffer/index.html
@@ -0,0 +1,70 @@
+---
+title: ArrayBuffer.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/ArrayBuffer/prototype
+tags:
+  - ArrayBuffer
+  - JavaScript
+  - Propriété
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer
+translation_of_original: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <strong><code>ArrayBuffer.prototype</code></strong> représente le prototype de l'objet {{jsxref("ArrayBuffer")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Les instances de <code>ArrayBuffer</code> héritent toutes de <code>ArrayBuffer.prototype</code>. Il est donc possible de modifier le protoype du constructeur pour apporter des changements à chacune des instances <code>ArrayBuffer</code>.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt>ArrayBuffer.prototype.constructor</dt>
+ <dd>Définit la fonction qui crée le prototype d'un objet. La valeur initiale correspond au constructeur natif <code>ArrayBuffer</code>.</dd>
+ <dt>{{jsxref("ArrayBuffer.prototype.byteLength")}} {{readonlyInline}}</dt>
+ <dd>La taille du tableau en octets. Cette propriété est déterminée lors de la construction du tableau et ne peut pas être changée. <code>Propriété en lecture seule</code>.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("ArrayBuffer.prototype.slice()")}}</dt>
+ <dd>Renvoie un nouvel <code>ArrayBuffer</code> dont le contenu est une copie des octets contenus dans l'objet <code>ArrayBuffer</code> depuis <code>begin</code> (compris), jusqu'à <code>end</code> (non-compris). Si <code>begin</code> ou <code>end</code> est négatif, cela fait référence à l'indice à partir de la fin du tableau et non à l'indice à partir du début du tableau.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">Statut</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-arraybuffer.prototype', 'ArrayBuffer.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-arraybuffer.prototype', 'ArrayBuffer.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.ArrayBuffer.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("ArrayBuffer")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/boolean/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/boolean/index.html
new file mode 100644
index 0000000000..8aebedeab9
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/boolean/index.html
@@ -0,0 +1,89 @@
+---
+title: Boolean.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/Boolean/prototype
+tags:
+  - Boolean
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Boolean
+translation_of_original: Web/JavaScript/Reference/Global_Objects/Boolean/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <strong><code>Boolean.prototype</code></strong> représente le prototype pour le constructeur {{jsxref("Boolean")}}.</p>
+
+<p>{{js_property_attributes(0,0,0)}}</p>
+
+<div>{{EmbedInteractiveExample("pages/js/boolean-constructor.html")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<h2 id="Description">Description</h2>
+
+<p>Les instances de {{jsxref("Boolean")}} hérite de {{jsxref("Boolean.prototype")}}. Vous pouvez utiliser l'objet prototype du constructeur pour ajouter des propriétés ou des méthodes de toutes les instances <code>Boolean</code>.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>Boolean.prototype.constructor</code></dt>
+ <dd>Renvoie la fonction de création d'un prototype d'instance. Il s'agit de la fonction {{jsxref("Boolean")}} par défaut.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("Boolean.prototype.toSource()")}} {{ Non-standard_inline() }}</dt>
+ <dd>Renvoie une chaine de caractères contenant le code source de l'objet {{jsxref("Boolean")}} ; celle-ci peut être utilisée pour créer un objet équivalent. Remplace la méthode {{jsxref("Object.prototype.toSource()")}}.</dd>
+</dl>
+
+<dl>
+ <dt>{{jsxref("Boolean.prototype.toString()")}}</dt>
+ <dd>Renvoie une chaine de caractères contenant soit « <code>true</code> » soit « <code>false</code> » selon la valeur de l'objet. Remplace la méthode {{jsxref("Object.prototype.toString()")}}.</dd>
+</dl>
+
+<dl>
+ <dt>{{jsxref("Boolean.prototype.valueOf()")}}</dt>
+ <dd>Renvoie la valeur primitive de l'objet {{jsxref("Boolean")}}. Remplace la méthode {{jsxref("Object.prototype.valueOf()")}}.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">Statut</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Définition initiale. Implémentée avec JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.6.3.1', 'Boolean.prototype')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-boolean.prototype', 'Boolean.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-boolean.prototype', 'Boolean.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une<em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.Boolean.prototype")}}</p>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/dataview/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/dataview/index.html
new file mode 100644
index 0000000000..fd20057af1
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/dataview/index.html
@@ -0,0 +1,120 @@
+---
+title: DataView.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/DataView/prototype
+tags:
+  - DataView
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/DataView
+translation_of_original: Web/JavaScript/Reference/Global_Objects/DataView/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>DataView</strong></code><strong><code>.prototype</code></strong> représente le prototype de l'objet {{jsxref("DataView")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Chacune des instances de <code>DataView</code> hérite de <code>DataView.prototype</code>. Comme pour chacun des constructeurs, il est possible de changer le prototype du constructeur afin d'apporter des modifications pour toutes les instances de <code>DataView</code>.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt>{{jsxref("DataView.prototype.constructor")}}</dt>
+ <dd>Définit la fonction qui permet de créer le prototype d'un objet. La valeur initiale correspond au constructeur natif standard <code>DataView</code>.</dd>
+ <dt>{{jsxref("DataView.prototype.buffer")}} {{readonlyInline}}</dt>
+ <dd>L'{{jsxref("ArrayBuffer")}} référencé par cette vue. Cette propriété est fixée lors de la construction de l'objet et est donc en <strong>lecture seule.</strong></dd>
+ <dt>{{jsxref("DataView.prototype.byteLength")}} {{readonlyInline}}</dt>
+ <dd>La longueur, exprimée en octets, de la vue à partir du début de son {{jsxref("ArrayBuffer")}}. Cette propriété est fixée lors de la construction de l'objet et est donc en <strong>lecture seule.</strong></dd>
+ <dt>{{jsxref("DataView.prototype.byteOffset")}} {{readonlyInline}}</dt>
+ <dd>Le décalage, exprimé en octets, entre le début de la vue et du {{jsxref("ArrayBuffer")}} correspondant. Cette propriété est fixée lors de la construction de l'objet et est donc en <strong>lecture seule.</strong></dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<h3 id="Lecture">Lecture</h3>
+
+<dl>
+ <dt>{{jsxref("DataView.prototype.getInt8()")}}</dt>
+ <dd>Obtient un entier signé codé sur 8 bits à partir de l'octet de début (potentiellement décalé) de la vue.</dd>
+ <dt>{{jsxref("DataView.prototype.getUint8()")}}</dt>
+ <dd>Obtient un entier non-signé codé sur 8 bits à partir de l'octet de début de la vue (potentiellement décalé).</dd>
+ <dt>{{jsxref("DataView.prototype.getInt16()")}}</dt>
+ <dd>Obtient un entier signé codé sur 16 bits (<em>short</em> par analogie avec le type C) à partir de l'octet de début de la vue (potentiellement décalé).</dd>
+ <dt>{{jsxref("DataView.prototype.getUint16()")}}</dt>
+ <dd>Obtient un entier non-signé codé sur 16 bits (<em>unsigned short</em> par analogie avec le type C) à partir de l'octet de début de la vue (potentiellement décalé).</dd>
+ <dt>{{jsxref("DataView.prototype.getInt32()")}}</dt>
+ <dd>Obtient un entier signé codé sur 32 bits (<em>long</em> par analogie avec le type C) à partir de l'octet de début de la vue (potentiellement décalé).</dd>
+ <dt>{{jsxref("DataView.prototype.getUint32()")}}</dt>
+ <dd>Obtient un entier non-signé codé sur 32 bits (<em>unsigned long</em> par analogie avec le type C) à partir de l'octet de début de la vue (potentiellement décalé).</dd>
+ <dt>{{jsxref("DataView.prototype.getFloat32()")}}</dt>
+ <dd>Obtient un flottant codé sur 32 bits (<em>float</em> par analogie avec le type C) à partir de l'octet de début de la vue (potentiellement décalé).</dd>
+ <dt>{{jsxref("DataView.prototype.getFloat64()")}}</dt>
+ <dd>Obtient un flottant codé sur 64 bits (<em>double</em> par analogie avec le type C) à partir de l'octet de début de la vue (potentiellement décalé).</dd>
+ <dt>{{jsxref("DataView.prototype.getBigInt64()")}}</dt>
+ <dd>Obtient un entier signé sur 64 bits (<em>long long</em> par analogie avec le type C) à partir de l'octet de début de la vue (potentiellement décalé).</dd>
+ <dt>{{jsxref("DataView.prototype.getBigUint64()")}}</dt>
+ <dd>Obtient un entier non-signé sur 64 bits (<em>unsigned long long</em> par analogie avec le type C) à partir de l'octet de début de la vue (potentiellement décalé).</dd>
+</dl>
+
+<h3 id="Écriture">Écriture</h3>
+
+<dl>
+ <dt>{{jsxref("DataView.prototype.setInt8()")}}</dt>
+ <dd>Enregistre un entier signé codé sur 8 bits à partir de l'octet de début (potentiellement décalé) de la vue.</dd>
+ <dt>{{jsxref("DataView.prototype.setUint8()")}}</dt>
+ <dd>Enregistre un entier non-signé codé sur 8 bits à partir de l'octet de début de la vue (potentiellement décalé).</dd>
+ <dt>{{jsxref("DataView.prototype.setInt16()")}}</dt>
+ <dd>Enregistre un entier signé codé sur 16 bits (<em>short</em> par analogie avec le type C) à partir de l'octet de début de la vue (potentiellement décalé).</dd>
+ <dt>{{jsxref("DataView.prototype.setUint16()")}}</dt>
+ <dd>Enregistre un entier non-signé codé sur 16 bits (<em>unsigned short</em> par analogie avec le type C) à partir de l'octet de début de la vue (potentiellement décalé).</dd>
+ <dt>{{jsxref("DataView.prototype.setInt32()")}}</dt>
+ <dd>Enregistre un entier signé codé sur 32 bits (<em>long</em> par analogie avec le type C) à partir de l'octet de début de la vue (potentiellement décalé).</dd>
+ <dt>{{jsxref("DataView.prototype.setUint32()")}}</dt>
+ <dd>Enregistre un entier non-signé codé sur 32 bits (<em>unsigned long</em> par analogie avec le type C) à partir de l'octet de début de la vue (potentiellement décalé).</dd>
+ <dt>{{jsxref("DataView.prototype.setFloat32()")}}</dt>
+ <dd>Enregistre un flottant codé sur 32 bits (<em>float</em> par analogie avec le type C) à partir de l'octet de début de la vue (potentiellement décalé).</dd>
+ <dt>{{jsxref("DataView.prototype.setFloat64()")}}</dt>
+ <dd>Enregistre un flottant codé sur 64 bits (<em>double</em> par analogie avec le type C) à partir de l'octet de début de la vue (potentiellement décalé).</dd>
+ <dt>{{jsxref("DataView.prototype.setBigInt64()")}}</dt>
+ <dd>Enregistre un entier signé sur 64 bits (<em>long long</em> par analogie avec le type C) à partir de l'octet de début de la vue (potentiellement décalé).</dd>
+ <dt>{{jsxref("DataView.prototype.setBigUint64()")}}</dt>
+ <dd>Enregistre un entier non-signé sur 64 bits (<em>unsigned long long</em> par analogie avec le type C) à partir de l'octet de début de la vue (potentiellement décalé).</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-dataview.prototype', 'DataView.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-dataview.prototype', 'DataView.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.DataView.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("DataView")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/date/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/date/index.html
new file mode 100644
index 0000000000..5d65e47b12
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/date/index.html
@@ -0,0 +1,183 @@
+---
+title: Date.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/Date/prototype
+tags:
+  - Date
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Date
+translation_of_original: Web/JavaScript/Reference/Global_Objects/Date/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>Date.prototype</strong></code> représente le prototype du constructeur {{jsxref("Date")}}.</p>
+
+<div>{{js_property_attributes(0,0,1)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Les instances de {{jsxref("Date")}} JavaScript héritent de <code>Date.prototype</code>. Le prototype du constructeur peut être modifié afin d'altérer l'ensemble des instances de <code>Date</code> pour y ajouter des propriétés et/ou des méthodes.</p>
+
+<p>Pour des questions de compatibilité avec le calcul des millénaires (en d'autres termes, pour prendre en compte l'année 2000), il faut toujours renseigner l'année entière ; par exemple, utilisez 1998, et non 98. Afin d'obtenir ces valeurs JavaScript possède les méthodes {{jsxref("Date/getFullYear", "getFullYear()")}}, {{jsxref("Date/setFullYear", "setFullYear()")}}, {{jsxref("Date/getUTCFullYear", "getUTCFullYear()")}} et {{jsxref("Date/setUTCFullYear", "setUTCFullYear()")}}.</p>
+
+<p>Avec ECMAScript 6, l'objet <code>Date.prototype</code> n'est plus une instance de {{jsxref("Date")}}, c'est un objet « ordinaire ».</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt>Date.prototype.constructor</dt>
+ <dd>Renvoie la fonction qui crée une instance de <code>Date</code>. Par défaut, ce sera le constructeur {{jsxref("Date", "Date")}}.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<h3 id="Lecture_(getters)">Lecture (<em>getters</em>)</h3>
+
+<dl>
+ <dt>{{jsxref("Date.prototype.getDate()")}}</dt>
+ <dd>Renvoie le jour du mois (1-31) pour la date spécifiée selon l'heure locale.</dd>
+ <dt>{{jsxref("Date.prototype.getDay()")}}</dt>
+ <dd>Renvoie le jour de la semaine (0-6) pour la date spécifiée selon l'heure locale.</dd>
+ <dt>{{jsxref("Date.prototype.getFullYear()")}}</dt>
+ <dd>Renvoie l'année (avec 4 chiffres pour une année à 4 chiffres) pour la date spécifiée selon l'heure locale.</dd>
+ <dt>{{jsxref("Date.prototype.getHours()")}}</dt>
+ <dd>Renvoie l'heure (0-23) pour la date spécifiée selon l'heure locale.</dd>
+ <dt>{{jsxref("Date.prototype.getMilliseconds()")}}</dt>
+ <dd>Renvoie les millièmes de secondes (0-999) pour la date spécifiée selon l'heure locale.</dd>
+ <dt>{{jsxref("Date.prototype.getMinutes()")}}</dt>
+ <dd>Renvoie les minutes (0-59) pour la date spécifiée selon l'heure locale.</dd>
+ <dt>{{jsxref("Date.prototype.getMonth()")}}</dt>
+ <dd>Renvoie le mois (0-11) pour la date spécifiée selon l'heure locale.</dd>
+ <dt>{{jsxref("Date.prototype.getSeconds()")}}</dt>
+ <dd>Renvoie les secondes (0-59) pour la date spécifiée selon l'heure locale.</dd>
+ <dt>{{jsxref("Date.prototype.getTime()")}}</dt>
+ <dd>Renvoie la valeur numérique de la date spécifiée sous la forme du nombre de millisecondes depuis le 1<sup>er</sup> janvier 1970, 00:00:00 UTC (les valeurs renvoyées pour les dates antérieures seront négatives).</dd>
+ <dt>{{jsxref("Date.prototype.getTimezoneOffset()")}}</dt>
+ <dd>Renvoie le décalage de fuseau horaire en minutes pour l'heure locale courante.</dd>
+ <dt>{{jsxref("Date.prototype.getUTCDate()")}}</dt>
+ <dd>Renvoie le jour (date) du mois (1-31) pour la date spécifiée selon le temps universel.</dd>
+ <dt>{{jsxref("Date.prototype.getUTCDay()")}}</dt>
+ <dd>Renvoie le jour de la semaine (0-6) pour la date spécifiée selon le temps universel.</dd>
+ <dt>{{jsxref("Date.prototype.getUTCFullYear()")}}</dt>
+ <dd>Renvoie l'année (avec 4 chiffres pour une année à 4 chiffres) pour la date spécifiée selon le temps universel.</dd>
+ <dt>{{jsxref("Date.prototype.getUTCHours()")}}</dt>
+ <dd>Renvoie les heures (0-23) pour la date spécifiée selon le temps universel.</dd>
+ <dt>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</dt>
+ <dd>Renvoie les millièmes de seconde (0-999) pour la date spécifiée selon le temps universel.</dd>
+ <dt>{{jsxref("Date.prototype.getUTCMinutes()")}}</dt>
+ <dd>Renvoie les minutes (0-59) pour la date spécifiée selon le temps universel.</dd>
+ <dt>{{jsxref("Date.prototype.getUTCMonth()")}}</dt>
+ <dd>Renvoie le mois (0-11) pour la date spécifiée selon le temps universel.</dd>
+ <dt>{{jsxref("Date.prototype.getUTCSeconds()")}}</dt>
+ <dd>Renvoie les secondes (0-59) pour la date spécifiée selon le temps universel</dd>
+ <dt>{{jsxref("Date.prototype.getYear()")}} {{ Deprecated_inline() }}</dt>
+ <dd>Renvoie l'année (habituellement avec 2 ou 3 chiffres) pour la date spécifiée selon l'heure locale. Utilisez plutôt {{jsxref("Date/getFullYear", "getFullYear()")}}.</dd>
+</dl>
+
+<h3 id="Écriture_(setters)">Écriture (<em>setters</em>)</h3>
+
+<dl>
+ <dt>{{jsxref("Date.prototype.setDate()")}}</dt>
+ <dd>Définit le jour du mois pour la date spécifiée selon l'heure locale.</dd>
+ <dt>{{jsxref("Date.prototype.setFullYear()")}}</dt>
+ <dd>Définit l'année complète (4 chiffres pour une année à 4 chiffres) pour la date spécifiée selon l'heure locale.</dd>
+ <dt>{{jsxref("Date.prototype.setHours()")}}</dt>
+ <dd>Définit les heures pour la date spécifiée selon l'heure locale.</dd>
+ <dt>{{jsxref("Date.prototype.setMilliseconds()")}}</dt>
+ <dd>Définit les millièmes de seconde pour la date spécifiée selon l'heure locale.</dd>
+ <dt>{{jsxref("Date.prototype.setMinutes()")}}</dt>
+ <dd>Définit les minutes pour la date spécifiée selon l'heure locale.</dd>
+ <dt>{{jsxref("Date.prototype.setMonth()")}}</dt>
+ <dd>Définit le mois pour la date spécifiée selon l'heure locale.</dd>
+ <dt>{{jsxref("Date.prototype.setSeconds()")}}</dt>
+ <dd>Définit les secondes pour la date spécifiée selon l'heure locale.</dd>
+ <dt>{{jsxref("Date.prototype.setTime()")}}</dt>
+ <dd>Règle l'objet <code>Date</code> sur le temps représenté par un nombre de millisecondes depuis le 1<sup>er</sup> janvier 1970, 00:00:00 UTC.</dd>
+ <dt>{{jsxref("Date.prototype.setUTCDate()")}}</dt>
+ <dd>Définit le jour du mois pour la date spécifiée selon le temps universel.</dd>
+ <dt>{{jsxref("Date.prototype.setUTCFullYear()")}}</dt>
+ <dd>Définit l'année complète (4 chiffres pour une année à 4 chiffres) pour la date spécifiée selon le temps universel.</dd>
+ <dt>{{jsxref("Date.prototype.setUTCHours()")}}</dt>
+ <dd>Définit les heures pour la date spécifiée selon le temps universel.</dd>
+ <dt>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</dt>
+ <dd>Définit les millièmes de seconde pour la date spécifiée selon le temps universel.</dd>
+ <dt>{{jsxref("Date.prototype.setUTCMinutes()")}}</dt>
+ <dd>Définit les minutes pour la date spécifiée selon le temps universel.</dd>
+ <dt>{{jsxref("Date.prototype.setUTCMonth()")}}</dt>
+ <dd>Définit le mois pour la date spécifiée selon le temps universel.</dd>
+ <dt>{{jsxref("Date.prototype.setUTCSeconds()")}}</dt>
+ <dd>Définit les secondes pour la date spécifiée selon le temps universel.</dd>
+ <dt>{{jsxref("Date.prototype.setYear()")}} {{ Deprecated_inline() }}</dt>
+ <dd>Définit l'année (habituellement avec 2 ou 3 chiffres) pour une date spécifiée selon le temps universel. Utilisez plutôt {{jsxref("Date/setFullYear", "setFullYear()")}}.</dd>
+</dl>
+
+<h3 id="Lecture_avec_conversion">Lecture avec conversion</h3>
+
+<dl>
+ <dt>{{jsxref("Date.prototype.toDateString()")}}</dt>
+ <dd>Renvoie la partie « date » de l'objet <code>Date</code> sous la forme d'une chaîne de caractères lisible par un humain (autrement dit quelque chose comme "Thu Apr 12 2018").</dd>
+ <dt>{{jsxref("Date.prototype.toISOString()")}}</dt>
+ <dd>Convertit une date en chaîne de caractère respectant la norme ISO 8601 Format Étendu.</dd>
+ <dt>{{jsxref("Date.prototype.toJSON()")}}</dt>
+ <dd>Renvoie une chaîne de caractère représentant la date en utilisant {{jsxref("Date/toISOString", "toISOString()")}}. Pour une utilisation avec {{jsxref("JSON.stringify()")}}.</dd>
+ <dt>{{jsxref("Date.prototype.toGMTString()")}} {{ Deprecated_inline() }}</dt>
+ <dd>Convertit une date en une chaîne de caractères, en utilisant les conventions GMT. Utilisez plutôt {{jsxref("Date/toUTCString", "toUTCString()")}}.</dd>
+ <dt>{{jsxref("Date.prototype.toLocaleDateString()")}}</dt>
+ <dd>Renvoie la partie « date » de l'objet <code>Date</code> sous la forme d'une chaîne de caractères adaptée selon la locale en utilisant les réglages du système pour déterminer la locale à utiliser.</dd>
+ <dt>{{jsxref("Date.prototype.toLocaleFormat()")}} {{ Non-standard_inline() }}</dt>
+ <dd>Convertit une date en une chaîne de caractères, en utilisant une chaîne de formatage.</dd>
+ <dt>{{jsxref("Date.prototype.toLocaleString()")}}</dt>
+ <dd>Convertit une date en une chaîne de caractères, en utilisant les conventions locales courantes. Remplace la méthode {{jsxref("Object/toLocaleString", "Object.prototype.toLocaleString()")}}.</dd>
+ <dt>{{jsxref("Date.prototype.toLocaleTimeString()")}}</dt>
+ <dd>Renvoie la partie « heure » de l'objet <code>Date</code> sous la forme d'une chaîne, en utilisant les conventions locales courantes.</dd>
+ <dt>{{jsxref("Date.prototype.toSource()")}} {{ Non-standard_inline() }}</dt>
+ <dd>Renvoie une chaîne de caractères représentant le code source pour un objet <code>Date</code> équivalent ; cette valeur peut être utilisée pour créer un nouvel objet. Remplace la méthode {{jsxref("Object.prototype.toSource()")}}.</dd>
+ <dt>{{jsxref("Date.prototype.toString()")}}</dt>
+ <dd>Renvoie une chaîne de caractères représentant l'objet <code>Date</code> spécifié. Remplace la méthode {{jsxref("Object.prototype.toString()")}}.</dd>
+ <dt>{{jsxref("Date.prototype.toTimeString()")}}</dt>
+ <dd>Renvoie la partie « heure » de l'objet <code>Date</code> sous la forme d'une chaîne de caractères lisible par humain.</dd>
+ <dt>{{jsxref("Date.prototype.toUTCString()")}}</dt>
+ <dd>Convertit une date en une chaîne de caractères, en utilisant le fuseau horaire UTC.</dd>
+ <dt>{{jsxref("Date.prototype.valueOf()")}}</dt>
+ <dd>Renvoie la valeur primitive d'un objet <code>Date</code>. Remplace la méthode {{jsxref("Object.prototype.valueOf()")}}.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">Statut</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Définition initiale. Implémentée avec JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5', 'Date.prototype')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-properties-of-the-date-prototype-object', 'Date.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-properties-of-the-date-prototype-object', 'Date.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p>
+
+<p>{{Compat("javascript.builtins.Date.prototype")}}</p>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/date/tostring/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/date/tostring/index.html
new file mode 100644
index 0000000000..b558e82142
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/date/tostring/index.html
@@ -0,0 +1,23 @@
+---
+title: toString
+slug: toString
+tags:
+  - Désambiguation
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toString
+translation_of_original: toString
+---
+<div class="noinclude"><strong>toString</strong> est une méthode de plusieurs objets JavaScript :</div>
+
+<ul>
+ <li><a href="fr/R%c3%a9f%c3%a9rence_de_JavaScript_1.5_Core/Objets_globaux/Array/toString">toString</a> — Méthode de l'objet <code>Array</code>.</li>
+ <li><a href="fr/R%c3%a9f%c3%a9rence_de_JavaScript_1.5_Core/Objets_globaux/Boolean/toString">toString</a> — Méthode de l'objet <code>Boolean</code>.</li>
+ <li><a href="fr/R%c3%a9f%c3%a9rence_de_JavaScript_1.5_Core/Objets_globaux/Date/toString">toString</a> — Méthode de l'objet <code>Date</code>.</li>
+ <li><a href="fr/R%c3%a9f%c3%a9rence_de_JavaScript_1.5_Core/Objets_globaux/Function/toString">toString</a> — Méthode de l'objet <code>Function</code>.</li>
+ <li><a href="fr/R%c3%a9f%c3%a9rence_de_JavaScript_1.5_Core/Objets_globaux/JavaArray/toString">toString</a> — Méthode de l'objet <code>JavaArray</code>.</li>
+ <li><a href="fr/R%c3%a9f%c3%a9rence_de_JavaScript_1.5_Core/Objets_globaux/Number/toString">toString</a> — Méthode de l'objet <code>Number</code>.</li>
+ <li><a href="fr/R%c3%a9f%c3%a9rence_de_JavaScript_1.5_Core/Objets_globaux/Object/toString">toString</a> — Méthode de l'objet <code>Object</code>.</li>
+ <li><a href="fr/R%c3%a9f%c3%a9rence_de_JavaScript_1.5_Core/Objets_globaux/RegExp/toString">toString</a> — Méthode de l'objet <code>RegExp</code>.</li>
+ <li><a href="fr/R%c3%a9f%c3%a9rence_de_JavaScript_1.5_Core/Objets_globaux/String/toString">toString</a> — Méthode de l'objet <code>String</code>.</li>
+</ul>
+
+<div class="noinclude"><div class="disambig" id="disambig"><p><i>Ceci est une page de <a href="https://developer.mozilla.org/fr/docs/Project:D%c3%a9sambiguation">désambiguation</a> — une aide à la navigation qui liste une série de pages qui devraient partager le même titre. Si un lien provenant d'un article mène ici, n'hésitez pas à revenir à celui-ci pour le faire pointer vers la page concernée.</i></p></div></div>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/error/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/error/index.html
new file mode 100644
index 0000000000..014afc9ce2
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/error/index.html
@@ -0,0 +1,115 @@
+---
+title: Error.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/Error/prototype
+tags:
+  - Error
+  - JavaScript
+  - Propriété
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Error
+translation_of_original: Web/JavaScript/Reference/Global_Objects/Error/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>Error.prototype</strong></code> représente le prototype du constructeur {{jsxref("Error")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Toutes les instances d'{{jsxref("Error")}} et les instances des {{jsxref("Error", "erreurs non-génériques", "#Types_d'erreur_personnalis.C3.A9s", 1)}} héritent de {{jsxref("Error.prototype")}}. Comme pour tous les constructeurs, on pouvez utiliser le prototype du constructeur pour ajouter des propriétés ou méthodes à l'ensemble des instances créées avec ce constructeur.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<h3 id="Propriétés_standard">Propriétés standard</h3>
+
+<dl>
+ <dt>Error.prototype.constructor</dt>
+ <dd>La fonction créeant une instance du prototype.</dd>
+ <dt>{{jsxref("Error.prototype.message")}}</dt>
+ <dd>Le message de l'erreur.</dd>
+ <dt>{{jsxref("Error.prototype.name")}}</dt>
+ <dd>Le nom de l'erreur.</dd>
+</dl>
+
+<h3 id="Extensions_spécifiques_à_une_implémentation">Extensions spécifiques à une implémentation</h3>
+
+<div>{{Non-standard_header}}</div>
+
+<h4 id="Microsoft">Microsoft</h4>
+
+<dl>
+ <dt>{{jsxref("Error.prototype.description")}}</dt>
+ <dd>Description de l'erreur. Similaire à {{jsxref("Error.message", "message")}}.</dd>
+ <dt>{{jsxref("Error.prototype.number")}}</dt>
+ <dd>Numéro de l'erreur.</dd>
+</dl>
+
+<h4 id="Mozilla">Mozilla</h4>
+
+<dl>
+ <dt>{{jsxref("Error.prototype.fileName")}}</dt>
+ <dd>Chemin vers le fichier qui a déclenché l'erreur.</dd>
+ <dt>{{jsxref("Error.prototype.lineNumber")}}</dt>
+ <dd>Numéro de la ligne qui a déclenché l'erreur dans le fichier.</dd>
+ <dt>{{jsxref("Error.prototype.columnNumber")}}</dt>
+ <dd>Numéro de la colonne qui a déclenché l'erreur dans le fichier.</dd>
+ <dt>{{jsxref("Error.prototype.stack")}}</dt>
+ <dd>Pile d'appels.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("Error.prototype.toSource()")}} {{Non-standard_inline}}</dt>
+ <dd>Renvoie une chaine de caractères contenant le code source de l'objet <code>Error</code> ; cette valeur peut être utilisée pour créer un nouvel objet. Elle remplace la méthode {{jsxref("Object.prototype.toSource()")}}.</dd>
+ <dt>{{jsxref("Error.prototype.toString()")}}</dt>
+ <dd>Renvoie une chaine de caractères représentant l'objet. Elle remplace la méthode {{jsxref("Object.prototype.toString()")}}.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">Statut</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Définition initiale. Implémentée avec JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.11.3.1', 'Error')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-error.prototype', 'Error')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-error.prototype', 'Error')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div>
+<div class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une<em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.Error.prototype")}}</p>
+</div>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Error")}}</li>
+ <li>{{jsxref("Object.prototype")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/evalerror/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/evalerror/index.html
new file mode 100644
index 0000000000..1123259c3d
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/evalerror/index.html
@@ -0,0 +1,91 @@
+---
+title: EvalError.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/EvalError/prototype
+tags:
+  - Error
+  - EvalError
+  - JavaScript
+  - Propriété
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/EvalError
+translation_of_original: Web/JavaScript/Reference/Global_Objects/EvalError/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>EvalError.prototype</strong></code> représente le prototype du constructeur {{jsxref("EvalError")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Chacune des instances de {{jsxref("EvalError")}} hérite de {{jsxref("EvalError.prototype")}}. On peut utiliser le prototype pour ajouter des propriétés ou des méthodes à toutes les instances.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>EvalError.prototype.constructor</code></dt>
+ <dd>Définit la fonction qui crée une instance basée sur le prototype.</dd>
+ <dt>{{jsxref("Error.prototype.message", "EvalError.prototype.message")}}</dt>
+ <dd>Un message décrivant l'erreur. Bien que la spécification ECMA-262 définit que <code>EvalError</code> doit fournir une propriété <code>message</code> propre à l'objet, l'implémentation de <a href="/fr/docs/SpiderMonkey" title="SpiderMonkey">SpiderMonkey</a> fait qu'il hérite de {{jsxref("Error.prototype.message")}}.</dd>
+ <dt>{{jsxref("Error.prototype.name", "EvalError.prototype.name")}}</dt>
+ <dd>Un nom d'erreur. Propriété héritée de {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.fileName", "EvalError.prototype.fileName")}}</dt>
+ <dd>Un chemin vers le fichier qui a provoqué l'erreur. Propriété héritée de {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.lineNumber", "EvalError.prototype.lineNumber")}}</dt>
+ <dd>Le numéro de la ligne du fichier qui a provoqué l'erreur. Propriété héritée de {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.columnNumber", "EvalError.prototype.columnNumber")}}</dt>
+ <dd>Le numéro de la colonne dans la ligne du fichier qui a provoqué l'erreur. Propriété héritée de {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.stack", "EvalError.prototype.stack")}}</dt>
+ <dd>Pile d'appels. Propriété héritée de {{jsxref("Error")}}.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<p>Bien que l'objet prototype <code>EvalError</code> ne possède pas de propriété propre, les instances de {{jsxref("EvalError")}} héritent de certaines méthodes via la chaîne de prototypes.</p>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">Statut</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Défini comme <code><em>NativeError</em>.prototype</code>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Défini comme <code><em>NativeError</em>.prototype</code>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Défini comme <code><em>NativeError</em>.prototype</code>.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div>
+<div class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.EvalError")}}</p>
+</div>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype")}}</li>
+ <li>{{jsxref("Function.prototype")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/function/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/function/index.html
new file mode 100644
index 0000000000..ff4a70e10f
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/function/index.html
@@ -0,0 +1,99 @@
+---
+title: Function.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/Function/prototype
+tags:
+  - Function
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Function
+translation_of_original: Web/JavaScript/Reference/Global_Objects/Function/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>Function.prototype</strong></code> représente le prototype de l'objet {{jsxref("Function")}}.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>Les objets {{jsxref("Function")}} héritent de <code>Function.prototype</code>. <code>Function.prototype</code> ne peut pas être modifié.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt>{{jsxref("Function.arguments")}} {{deprecated_inline}}</dt>
+ <dd>Un tableau correspondant aux arguments passés à la fonction. Cette propriété est dépréciée et il est préférable d'utiliser l'objet {{jsxref("Fonctions/arguments", "arguments")}} à la place.</dd>
+ <dt>{{jsxref("Function.arity")}} {{obsolete_inline}}</dt>
+ <dd>Cette propriété était utilisée pour indiquer le nombre d'arguments attendus par la fonction. Cette propriété a été supprimée. La propriété {{jsxref("Function.length", "length")}} doit être utilisée à la place.</dd>
+ <dt>{{jsxref("Function.caller")}} {{non-standard_inline}}</dt>
+ <dd>Indique la fonction qui a appelée la fonction courante.</dd>
+ <dt>{{jsxref("Function.length")}}</dt>
+ <dd>Indique le nombre d'arguments attendus par la fonction.</dd>
+ <dt>{{jsxref("Function.name")}}</dt>
+ <dd>Le nom de la fonction.</dd>
+ <dt>{{jsxref("Function.displayName")}} {{non-standard_inline}}</dt>
+ <dd>Le nom de la fonction à utiliser pour l'affichage.</dd>
+ <dt><code>Function.prototype.constructor</code></dt>
+ <dd>Définit la fonction qui crée le prototype de l'objet. Voir la page {{jsxref("Object.prototype.constructor")}} pour plus de détails.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("Function.prototype.apply()")}}</dt>
+ <dd>Cette méthode applique la fonction et pour cette fonction, <code>this</code> sera la valeur passée en argument (l'objet manipulé peut ainsi être différent de l'objet courant). Les arguments peuvent être passés grâce à un objet {{jsxref("Array")}}.</dd>
+ <dt>{{jsxref("Function.prototype.bind()")}}</dt>
+ <dd>Cette méthode crée un nouvelle fonction qui, lorsqu'elle est appelée, appelle cette fonction dans le contexte de la valeur fournie avec une suite d'arguments à utiliser avant ceux fournis à la nouvelle fonction.</dd>
+ <dt>{{jsxref("Function.prototype.call()")}}</dt>
+ <dd>Cette méthode applique la fonction, et pour cette fonction, <code>this</code> sera la valeur passée en premier arguments. Les arguments peuvent être passés tels quels dans les arguments suivants.</dd>
+ <dt>{{jsxref("Function.prototype.isGenerator()")}} {{non-standard_inline}}</dt>
+ <dd>Cette méthode renvoie <code>true</code> si la fonction est un <a href="/fr/docs/Web/JavaScript/Reference/Instructions/function*">générateur</a> ; sinon elle renvoie <code>false</code>.</dd>
+ <dt>{{jsxref("Function.prototype.toSource()")}} {{non-standard_inline}}</dt>
+ <dd>Cette méthode renvoie une chaîne de caractères représentant le code source de la fonction. Elle surcharge la méthode {{jsxref("Object.prototype.toSource")}}.</dd>
+ <dt>{{jsxref("Function.prototype.toString()")}}</dt>
+ <dd>Cette méthode renvoie une chaîne de caractères représentant le code source de la fonction. Elle surcharge la méthode {{jsxref("Object.prototype.toString")}}.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">Statut</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Définition initiale. Implémentée avec JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.3.5.2', 'Function.prototype')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function-instances-prototype','Function.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-function-instances-prototype', 'Function.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Function.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Function")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/generatorfunction/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/generatorfunction/index.html
new file mode 100644
index 0000000000..1a23ca8eb5
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/generatorfunction/index.html
@@ -0,0 +1,67 @@
+---
+title: GeneratorFunction.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/GeneratorFunction/prototype
+tags:
+  - ECMAScript 2015
+  - GeneratorFunction
+  - Iterator
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/GeneratorFunction
+translation_of_original: Web/JavaScript/Reference/Global_Objects/GeneratorFunction/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>GeneratorFunction.prototype</strong></code> représente le prototype de l'objet {{jsxref("GeneratorFunction")}}.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>Les objets {{jsxref("GeneratorFunction")}} héritent de <code>GeneratorFunction.prototype</code>. <code>GeneratorFunction.prototype</code> ne peut pas être modifié.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code><strong>GeneratorFunction.constructor</strong></code></dt>
+ <dd>La valeur initiale correspond à {{jsxref("GeneratorFunction")}}.</dd>
+ <dt><code><strong>GeneratorFunction.prototype.prototype</strong></code></dt>
+ <dd>La valeur est <code>%GeneratorPrototype%</code>.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">Statut</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-generatorfunction.prototype', 'GeneratorFunction.prototype')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-generatorfunction.prototype', 'GeneratorFunction.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div>
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.GeneratorFunction.prototype")}}</p>
+</div>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("GeneratorFunction")}}</li>
+ <li>{{jsxref("Function")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/internalerror/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/internalerror/index.html
new file mode 100644
index 0000000000..7d44d99002
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/internalerror/index.html
@@ -0,0 +1,63 @@
+---
+title: InternalError.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/InternalError/prototype
+tags:
+  - Error
+  - InternalError
+  - JavaScript
+  - Propriété
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/InternalError
+translation_of_original: Web/JavaScript/Reference/Global_Objects/InternalError/prototype
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>La propriété <code><strong>InternalError.prototype</strong></code> représente le prototype du constructeur {{jsxref("InternalError")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Toutes les instances de {{jsxref("InternalError")}} héritent de {{jsxref("InternalError.prototype")}}. Ce prototype peut être utilisé pour ajouter des propriétés et/ou des méthodes à toutes les instances.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>InternalError.prototype.constructor</code></dt>
+ <dd>Définit la fonction qui permet de créer une instance du prototype.</dd>
+ <dt>{{jsxref("Error.prototype.message", "InternalError.prototype.message")}}</dt>
+ <dd>Un nom d'erreur. Bien que ECMA-262 spécifie que <code>InternalError</code> devrait fournir une propriété propre pour <code>message</code>. L'implémentation de<a href="/fr/docs/SpiderMonkey"> SpiderMonkey</a> fait que cette propriété est héritée via {{jsxref("Error.prototype.message")}}.</dd>
+ <dt>{{jsxref("Error.prototype.name", "InternalError.prototype.name")}}</dt>
+ <dd>Un nom d'erreur. Hérité via {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.fileName", "InternalError.prototype.fileName")}}</dt>
+ <dd>Le chemin du fichier à l'origine de l'erreur. Héritée via {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.lineNumber", "InternalError.prototype.lineNumber")}}</dt>
+ <dd>Le numéro de la ligne dans le fichier pour le code qui a déclenché l'erreur. Héritée via {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.columnNumber", "InternalError.prototype.columnNumber")}}</dt>
+ <dd>Le numéro de la colonne dans la ligne du fichier pour le code qui a déclenché l'erreur. Héritée via {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.stack", "InternalError.prototype.stack")}}</dt>
+ <dd>Pile d'appels (stack trace). Héritée via {{jsxref("Error")}}.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<p>Bien que l'objet prototype <code>InternalError</code> ne contienne aucune méthode qui lui soit propre, les instances de {{jsxref("InternalError")}} héritent de méthodes grâce à la chaîne de prototypes.</p>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<p>Cette propriété ne fait partie d'aucune spécification.</p>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div>
+<div class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.InternalError")}}</p>
+</div>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype")}}</li>
+ <li>{{jsxref("Function.prototype")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/intl/collator/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/intl/collator/index.html
new file mode 100644
index 0000000000..b523b88842
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/intl/collator/index.html
@@ -0,0 +1,81 @@
+---
+title: Intl.Collator.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/Intl/Collator/prototype
+tags:
+  - Collator
+  - Internationalisation
+  - Intl
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+  - i18n
+translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator
+translation_of_original: Web/JavaScript/Reference/Global_Objects/Intl/Collator/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>Intl.Collator.prototype</strong></code> représente l'objet prototype du constructeur {{jsxref("Collator", "Intl.Collator")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Voir la page {{jsxref("Collator")}} pour une description appliquée aux instances de <code>Intl.Collator</code>.</p>
+
+<p>Les instances de <code>Intl.Collator</code> héritent de <code>Intl.Collator.prototype</code>. Les modifications apportées à l'objet prototype sont propagées sur toutes les instances de <code>Intl.Collator</code> via l'héritage (chaîne de prototypes).</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>Intl.Collator.protoype.constructor</code></dt>
+ <dd>Une référence vers {{jsxref("Collator")}}.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("Collator.compare", "Intl.Collator.prototype.compare")}}</dt>
+ <dd>Un accesseur qui renvoie une fonction comparant deux chaînes de caractères, basée sur l'ordre de tri de l'objet {{jsxref("Objets_globaux/Collator", "Intl.Collator")}}.</dd>
+ <dt>{{jsxref("Collator.resolvedOptions", "Intl.Collator.prototype.resolvedOptions()")}}</dt>
+ <dd>Renvoie un nouvel objet dont les propriétés correspondent aux options de collation et de locales calculées lors de l'initialisation de l'objet.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">Statut</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 1.0', '#sec-10.2.1', 'Intl.Collator.prototype')}}</td>
+   <td>{{Spec2('ES Int 1.0')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 2.0', '#sec-10.2.1', 'Intl.Collator.prototype')}}</td>
+   <td>{{Spec2('ES Int 2.0')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int Draft', '#sec-Intl.Collator.prototype', 'Intl.Collator.prototype')}}</td>
+   <td>{{Spec2('ES Int Draft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Intl.Collator.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Collator", "Intl.Collator")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/intl/datetimeformat/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/intl/datetimeformat/index.html
new file mode 100644
index 0000000000..39e6679295
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/intl/datetimeformat/index.html
@@ -0,0 +1,82 @@
+---
+title: Intl.DateTimeFormat.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/Intl/DateTimeFormat/prototype
+tags:
+  - Internationalisation
+  - Intl
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+  - i18n
+translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat
+translation_of_original: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>Intl.DateTimeFormat.prototype</strong></code> représente le prototype du constructeur {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Voir la page {{jsxref("DateTimeFormat")}} qui décrit les instances de <code>Intl.DateTimeFormat</code>.</p>
+
+<p>Les instances de {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} héritent de <code>Intl.DateTimeFormat.prototype</code>. Les modifications apportées à l'objet prototype sont propagées sur toutes les instances de  <code>Intl.DateTimeFormat</code> par héritage.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>Intl.DateTimeFormat.prototype.constructor</code></dt>
+ <dd>Une référence à <code>Intl.DateTimeFormat</code>.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("DateTimeFormat.format", "Intl.DateTimeFormat.prototype.format")}}</dt>
+ <dd>Un accesseur qui renvoie une fonction formattant une date selon les options de format et de locale spécifiées pour l'objet <code>DateTimeFormat</code>.</dd>
+ <dt>{{jsxref("DateTimeFormat.formatToParts","Intl.DateTimeFormat.prototype.formatToParts()")}}</dt>
+ <dd>Renvoie un tableau d'objets qui représentent les composants de la date sous forme de chaînes de caractères afin que celles-ci puissent être utilisée dans une mise en forme adaptée à la locale.</dd>
+ <dt>{{jsxref("DateTimeFormat.resolvedOptions", "Intl.DateTimeFormat.prototype.resolvedOptions()")}}</dt>
+ <dd>Renvoie un nouvel objet dont les propriétés indiquent les options de format et de locale calculées lors de l'initialisation de l'objet.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">Statut</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 1.0', '#sec-12.2.1', 'Intl.DateTimeFormat.prototype')}}</td>
+   <td>{{Spec2('ES Int 1.0')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 2.0', '#sec-12.2.1', 'Intl.DateTimeFormat.prototype')}}</td>
+   <td>{{Spec2('ES Int 2.0')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int Draft', '#sec-Intl.DateTimeFormat.prototype', 'Intl.DateTimeFormat.prototype')}}</td>
+   <td>{{Spec2('ES Int Draft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Intl.DateTimeFormat.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/intl/listformat/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/intl/listformat/index.html
new file mode 100644
index 0000000000..1aab6a459d
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/intl/listformat/index.html
@@ -0,0 +1,63 @@
+---
+title: Intl.ListFormat.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/Intl/ListFormat/prototype
+tags:
+  - Experimental
+  - Intl
+  - Intl.ListFormat
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Intl/ListFormat
+translation_of_original: Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <strong><code>Intl.ListFormat.prototype</code></strong> représente l'objet prototype utilisé par le constructeur {{jsxref("ListFormat", "Intl.ListFormat")}}.</p>
+
+<p>{{js_property_attributes(0, 0, 0)}}</p>
+
+<h2 id="Description">Description</h2>
+
+<p>Voir la page {{jsxref("ListFormat")}} pour une description des instances de <code>Intl.ListFormat</code>.</p>
+
+<p>Les instances {{jsxref("ListFormat", "Intl.ListFormat")}} héritent de <code>Intl.ListFormat.prototype</code>. Les modifications apportées au prototypes seront héritées par les instances {{jsxref("ListFormat", "Intl.ListFormat")}}.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>Intl.<font face="consolas, Liberation Mono, courier, monospace">ListFormat</font>.prototype.constructor</code></dt>
+ <dd>Une référence à {{jsxref("ListFormat", "Intl.ListFormat()")}}.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td><a href="https://tc39.github.io/proposal-intl-list-format/#sec-Intl.ListFormat.prototype">Proposition pour <code>Intl.ListFormat.prototype</code></a></td>
+   <td>Proposition de niveau 3</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.Intl.ListFormat.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("ListFormat", "Intl.ListFormat")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/intl/locale/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/intl/locale/index.html
new file mode 100644
index 0000000000..cc22f45a17
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/intl/locale/index.html
@@ -0,0 +1,91 @@
+---
+title: Intl.Locale.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/prototype
+tags:
+  - Internationalisation
+  - Intl
+  - JavaScript
+  - Locale
+  - Prototype
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale
+translation_of_original: Web/JavaScript/Reference/Global_Objects/Intl/Locale/prototype
+---
+<p>{{JSRef}}</p>
+
+<p><span class="seoSummary">La propriété <strong><code>Intl.Locale.prototype</code></strong> représente le prototype pour le constructeur {{jsxref("Locale", "Intl.Locale")}}.</span></p>
+
+<p>{{js_property_attributes(0, 0, 0)}}</p>
+
+<h2 id="Description">Description</h2>
+
+<p>Voir la page {{jsxref("Locale")}} pour en savoir plus sur les instances <code>Intl.Locale</code>.</p>
+
+<p>Les instances de {{jsxref("Locale", "Intl.Locale")}} héritent de <code>Intl.Locale.prototype</code>. Les modifications apportées au prototype sont héritées par l'ensemble des instances {{jsxref("Locale", "Intl.Locale")}}.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>{{jsxref("Locale/baseName", "Intl.Locale.prototype.baseName")}}</code></dt>
+ <dd>Renvoie un extrait de la chaîne de caractères représentant l'objet <code>Locale</code>. Cet extrait contient les informations essentielles à propos de l'objet <code>Locale</code>.</dd>
+ <dt><code>{{jsxref("Locale/calendar", "Intl.Locale.prototype.calendar")}}</code></dt>
+ <dd>Renvoie le type de calendrier utilisé par l'instance de <code>Locale</code>.</dd>
+ <dt><code>{{jsxref("Locale/collation", "Intl.Locale.prototype.collation")}}</code></dt>
+ <dd>Renvoie le <a href="https://www.unicode.org/reports/tr35/tr35-collation.html#CLDR_Collation">type de collation</a> pour l'instance de <code>Locale</code> courante. La collation est la méthode qui permet d'ordonner des chaînes de caractères en fonction des règles de la locale.</dd>
+ <dt><code>{{jsxref("Locale/hourCycle", "Intl.Locale.prototype.hourCycle")}}</code></dt>
+ <dd>Renvoie la convention pour le format des heures utilisée par la locale courante.</dd>
+ <dt><code>{{jsxref("Locale/caseFirst", "Intl.Locale.prototype.caseFirst")}}</code></dt>
+ <dd>Renvoie si la casse est prise en compte par la locale pour ses règles de collation (celles qui permettent d'ordonner des chaînes de caractères entre elles).</dd>
+ <dt><code>{{jsxref("Locale/numeric", "Intl.Locale.prototype.numeric")}}</code></dt>
+ <dd>Indique si la locale possède une collation spécifique pour les caractères numériques (la collation étant la méthode qui permet d'ordonner des chaînes de caractères entre elles).</dd>
+ <dt><code>{{jsxref("Locale/numberingSystem", "Intl.Locale.prototype.numberingSystem")}}</code></dt>
+ <dd>Renvoie le <a href="https://en.wikipedia.org/wiki/Numeral_system">système de numération</a> utilisée par la locale.</dd>
+ <dt><code>{{jsxref("Locale/language", "Intl.Locale.prototype.language")}}</code></dt>
+ <dd>Renvoie la langue associée à la locale.</dd>
+ <dt><code>{{jsxref("Locale/script", "Intl.Locale.prototype.script")}}</code></dt>
+ <dd>Renvoie le script utilisé pour l'écriture d'une langue donnée pour la locale courante.</dd>
+ <dt><code>{{jsxref("Locale/region", "Intl.Locale.prototype.region")}}</code></dt>
+ <dd>Renvoie la région du monde (il s'agit généralement d'un pays) associée à la locale courante.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt><code>{{jsxref("Locale/minimize", "Intl.Locale.prototype.minimize()")}}</code></dt>
+ <dd>Cette méthode tente de retirer les informations qui auraient pu être ajoutée à une locale lors d'un appel à {{jsxref("Locale/maximize", "Locale.maximize()")}}.</dd>
+ <dt><code>{{jsxref("Locale/maximize", "Intl.Locale.prototype.maximize()")}}</code></dt>
+ <dd>Cette méthode permet d'obtenir les valeurs les plus vraisemblantes pour la langue, le script et la région de la locale en fonction des valeurs existantes.</dd>
+ <dt><code>{{jsxref("Locale/toString", "Intl.Locale.prototype.toString()")}}</code></dt>
+ <dd>Cette méthode renvoie <a href="https://www.unicode.org/reports/tr35/#Unicode_locale_identifier">l'identifiant de locale complet</a> pour la locale courante.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td><a href="https://tc39.github.io/proposal-intl-locale/#sec-Intl.Locale.prototype">Proposition pour <code>Intl.Locale.prototype</code></a></td>
+   <td>Proposition de niveau 3</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.Intl.Locale.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Locale", "Intl.Locale")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/intl/numberformat/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/intl/numberformat/index.html
new file mode 100644
index 0000000000..7627a01670
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/intl/numberformat/index.html
@@ -0,0 +1,83 @@
+---
+title: Intl.NumberFormat.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/Intl/NumberFormat/prototype
+tags:
+  - Internationalisation
+  - Intl
+  - JavaScript
+  - NumberFormat
+  - Propriété
+  - Prototype
+  - Reference
+  - i18n
+translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat
+translation_of_original: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>Intl.NumberFormat.prototype</strong></code> représente l'objet prototype pour le constructeur {{jsxref("NumberFormat", "Intl.NumberFormat")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Voir la page {{jsxref("NumberFormat", "Intl.NumberFormat")}} pour une description des instances de <code>Intl.NumberFormat</code>.</p>
+
+<p>Les instances de <code>Intl.NumberFormat</code> héritent de <code>Intl.NumberFormat.prototype</code>. Les modifications apportées à l'objet prototype seront propagées par héritage aux instances  <code>Intl.NumberFormat</code>.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>Intl.NumberFormat.prototype.constructor</code></dt>
+ <dd>Une référence à <code>Intl.NumberFormat</code>.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("NumberFormat.format", "Intl.NumberFormat.prototype.format")}}</dt>
+ <dd>Un accesseur qui renvoie une fonction permettant de formater un nombre en fonction des options de locale et de format définies dans un objet <code>NumberFormat</code>.</dd>
+ <dt>{{jsxref("NumberFormat.formatToParts", "Intl.NumberFormat.prototype.formatToParts()")}}</dt>
+ <dd>Cette méthode renvoie un tableau ({{jsxref("Array")}}) d'objets qui représentent les fragments de la chaîne de caractères correspondant au nombre afin de l'utiliser pour des mises en formes prenant en compte la locale de l'utilisateur.</dd>
+ <dt>{{jsxref("NumberFormat.resolvedOptions", "Intl.NumberFormat.prototype.resolvedOptions()")}}</dt>
+ <dd>Cette méthode renvoie un nouvel objet dont les propriétés correspondent aux options de locale et de collation calculées lors de l'initialisation de l'objet.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 1.0', '#sec-11.2.1', 'Intl.NumberFormat.prototype')}}</td>
+   <td>{{Spec2('ES Int 1.0')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 2.0', '#sec-11.2.1', 'Intl.NumberFormat.prototype')}}</td>
+   <td>{{Spec2('ES Int 2.0')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int Draft', '#sec-Intl.NumberFormat.prototype', 'Intl.NumberFormat.prototype')}}</td>
+   <td>{{Spec2('ES Int Draft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Intl.NumberFormat.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("NumberFormat", "Intl.NumberFormat")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/intl/pluralrules/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/intl/pluralrules/index.html
new file mode 100644
index 0000000000..6674890eb1
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/intl/pluralrules/index.html
@@ -0,0 +1,71 @@
+---
+title: Intl.PluralRules.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/Intl/PluralRules/prototype
+tags:
+  - Internationalisation
+  - Intl
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Intl/PluralRules
+translation_of_original: Web/JavaScript/Reference/Global_Objects/Intl/PluralRules/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <strong><code>Intl.PluralRules.prototype</code></strong> représente le prototype du constructeur {{jsxref("PluralRules", "Intl.PluralRules")}}.</p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Voir {{jsxref("PluralRules")}} pour la description des instances <code>Intl.PluralRules</code>.</p>
+
+<p>Les instances de {{jsxref("PluralRules", "Intl.PluralRules")}} héritent de <code>Intl.PluralRules.prototype</code>. Les modifications apportées au prototype seront héritées par l'ensemble des instances de {{jsxref("PluralRules", "Intl.PluralRules")}}.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>Intl.PluralRules.prototype.constructor</code></dt>
+ <dd>Une référence à <code>Intl.PluralRules</code>.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("PluralRules.resolvedOptions", "Intl.PluralRules.prototype.resolvedOptions()")}}</dt>
+ <dd>Cette méthode renvoie un nouvelle objet dont les propriétés reflètent la locale et les options de collations calculées lors de l'initialisation de l'objet.</dd>
+ <dt>{{jsxref("PluralRules.select", "Intl.PluralRules.prototype.select()")}}</dt>
+ <dd>Cette méthode renvoie une chaîne de caractères ({{jsxref("String")}}) qui indique quelle forme de règle de nombre est utilisée pour le formatage.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td><a href="https://rawgit.com/caridy/intl-plural-rules-spec/master/index.html">Brouillon pour les règles de nombre avec <code>Intl</code></a></td>
+   <td>Brouillon</td>
+   <td>Définition initiale.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div>
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Intl.PluralRules.prototype")}}</p>
+</div>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("PluralRules", "Intl.PluralRules")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/intl/relativetimeformat/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/intl/relativetimeformat/index.html
new file mode 100644
index 0000000000..9e212403c3
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/intl/relativetimeformat/index.html
@@ -0,0 +1,73 @@
+---
+title: Intl.RelativeTimeFormat.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/Intl/RelativeTimeFormat/prototype
+tags:
+  - Internationalisation
+  - Intl
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat
+translation_of_original: Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <strong><code>Intl.RelativeTimeFormat.prototype</code></strong> représente l'objet prototype utilisé par le constructeur {{jsxref("RelativeTimeFormat", "Intl.RelativeTimeFormat")}}.</p>
+
+<p>{{js_property_attributes(0, 0, 0)}}</p>
+
+<h2 id="Description">Description</h2>
+
+<p>Voir {{jsxref("RelativeTimeFormat")}} pour une description des instances <code>Intl.RelativeTimeFormat</code>.</p>
+
+<p>Les instances {{jsxref("RelativeTimeFormat", "Intl.RelativeTimeFormat")}} héritent de <code>Intl.RelativeTimeFormat.prototype</code>. Les modifications apportées au prototype seront héritées par l'ensemble des instances {{jsxref("RelativeTimeFormat", "Intl.RelativeTimeFormat")}}.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>Intl.<font face="consolas, Liberation Mono, courier, monospace">RelativeTimeFormat</font>.prototype.constructor</code></dt>
+ <dd>Une référence à <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl.RelativeTimeFormat" title="The Intl.DateTimeFormat object is a constructor for objects that enable language-sensitive date and time formatting."><code>Intl.RelativeTimeFormat</code></a>.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("RelativeTimeFormat.format", "Intl.RelativeTimeFormat.prototype.format()")}}</dt>
+ <dd>Une méthode qui formate une valeur, accompagnée d'une unité selon des options de locales et de formatage stockées dans l'objet <a href="/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl.RelativeTimeFormat" title="The Intl.DateTimeFormat object is a constructor for objects that enable language-sensitive date and time formatting."><code>Intl.RelativeTimeFormat</code></a>.</dd>
+ <dt>{{jsxref("RelativeTimeFormat.formatToParts", "Intl.RelativeTimeFormat.prototype.formatToParts()")}}</dt>
+ <dd>Une méthode qui formate une valeur comme la méthode <code>format()</code> mais qui renvoie un tableau ({{jsxref("Array")}}) contenant les différentes parties de la valeur formatée.</dd>
+ <dt>{{jsxref("RelativeTimeFormat.resolvedOptions", "Intl.RelativeTimeFormat.prototype.resolvedOptions()")}}</dt>
+ <dd>Une méthode qui renvoie un objet dont les propriétés indique les options de locale et de formatage calculées lors de l'initialisation du formateur.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td><a href="https://tc39.github.io/proposal-intl-relative-time/#sec-Intl.RelativeTimeFormat.prototype">Proposition pour <code>Intl.RelativeTime</code></a></td>
+   <td>Proposition de niveau 3</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.Intl.RelativeTimeFormat.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("RelativeTimeFormat", "Intl.RelativeTimeFormat")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/json/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/json/index.html
new file mode 100644
index 0000000000..a70dfee208
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/json/index.html
@@ -0,0 +1,100 @@
+---
+title: Utiliser le JSON natif
+slug: Web/JavaScript/Guide/Utiliser_le_JSON_natif
+tags:
+  - Add-ons
+  - Advanced
+  - ECMAScript5
+  - Extensions
+  - JSON
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects/JSON
+translation_of_original: Web/JavaScript/Guide/Using_native_JSON
+---
+<p>{{jsSidebar("JavaScript Guide")}}</p>
+
+<p>Cet article aborde l'objet JSON natif conforme à ECMAScript 5 qui a été ajouté à Gecko 1.9.1. Pour consulter les informations de base sur l'utilisation de JSON dans les versions précédentes de Firefox, consulter la page <a class="internal" href="/fr/docs/JSON" title="En/JSON">JSON</a>.</p>
+
+<p>L'objet natif JSON possède deux méthodes clés. La méthode <code>JSON.parse()</code> qui analyse une chaîne de caractères JSON et qui reconstruit l'objet JavaScript original. La méthode <code>JSON.stringify()</code>, quant à elle, accepte un objet JavaScript et renvoie son équivalent JSON.</p>
+
+<div class="note"><strong>Note :</strong> JSON ne supporte pas les structures cycliques. Toute tentative de conversion d'une telle structure renverra une exception <code>TypeError</code>.</div>
+
+<h2 id="Analyser_(parser)_les_chaînes_JSON">Analyser (<em>parser</em>) les chaînes JSON</h2>
+
+<p>Afin de convertir une chaîne JSON en un objet JavaScript, il suffit de passer une chaîne JSON à la méthode <code>JSON.parse()</code> :</p>
+
+<pre>var objetJS = JSON.parse(chaineJSON);</pre>
+
+<div class="note">
+<p>À partir de JavaScript 1.8.5 (Firefox 4), <code>JSON.parse()</code> n'accepte pas les virgules en fin de chaîne</p>
+</div>
+
+<pre>// ces deux instructions renverront une exception<code> SyntaxError</code>
+// à partir de JavaScript 1.8.5
+var objetJS = JSON.parse("[1, 2, 3, 4, ]");
+var objetJS = JSON.parse("{ \"toto\" : 1, }");
+</pre>
+
+<h2 id="Convertir_les_objets_en_JSON">Convertir les objets en JSON</h2>
+
+<p>Afin de convertir un objet JavaScript en une chaîne JSON, il suffit de passer l'objet à la méthode <code>JSON.stringify()</code> :</p>
+
+<pre class="brush: js">var toto = {};
+toto.truc = "nouvelle propriété";
+toto.machin = 3;
+
+var chaineJSON = JSON.stringify(toto);
+</pre>
+
+<p><code>chaineJSON</code> contient désormais <code>'{"truc":"nouvelle propriété","machin":3}'</code>.</p>
+
+<p>Depuis Firefox 3.5.4, <code>JSON.stringify()</code> permet d'adapter la conversion grâce à des paramètres optionnels. La syntaxe est la suivante :</p>
+
+<p><code>chaineJSON = JSON.stringify(<em>valeur</em> [, <em>remplacement</em> [, <em>espace</em>]])</code>remplacement</p>
+
+<dl>
+ <dt><code>valeur</code></dt>
+ <dd>L'objet JavaScript à convertir en une chaîne JSON.</dd>
+ <dt><code>remplacement</code></dt>
+ <dd>Une fonction qui modifie le comportement de la conversion ou bien un tableau d<code>'objets </code><a href="/fr/docs/JavaScript/Guide/Objets_élémentaires_JavaScript#L'objet_String" title="/fr/docs/JavaScript/Guide/Objets_élémentaires_JavaScript#L'objet_String"><code>String</code></a> et <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Number"><code>Number</code></a> qui sera utilisé comme une liste de propriétés de l'objet <code>valeur</code> à inclure dans la chaîne JSON. Si cette valeur est nulle ou n'est pas fournie, toutes les propriétés de l'objet seront inclues dans la chaîne résultante.</dd>
+ <dt><code>espace</code></dt>
+ <dd>Un objet <code><a href="/fr/docs/JavaScript/Guide/Objets_élémentaires_JavaScript#L'objet_String"><code>String</code></a></code> ou <a href="/fr/docs/JavaScript/Référence_JavaScript/Objets_globaux/Number" title="/fr/docs/JavaScript/Référence_JavaScript/Objets_globaux/Number"><code>Number</code></a> utilisé pour insérer des espaces dans la chaîne JSON afin qu'elle soit plus lisible. Si c'est un objet <code>Number</code>, il indique le nombre d'espaces à insérer. Ce nombre est limité à 10. Les valeurs inférieures à 1 indiquent qu'aucun espace ne sera utilisé, les valeurs supérieures à 10 seront ramenées à 10. Si cet objet est une <code>String</code>, la chaîne de caractères (ou les 10 premiers caractères si la chaîne est plus longue) à utiliser comme blanc. Si ce paramètre n'est pas fourni (ou vaut <code>null</code>), aucun blanc ne sera utilisé.</dd>
+</dl>
+
+<h3 id="Le_paramètre_de_remplacement">Le paramètre de remplacement</h3>
+
+<p>La paramètre <code>remplacement</code> peut être une fonction ou un tableau. Si c'est une fonction, elle prendra deux paramètres : la clé et la valeur à être convertie en chaîne de caractères. L'objet pour lequel la clé a été trouvée sera fourni comme paramètre <code>this</code> de la fonction de remplacement. Initialement elle est appelée avec une clé vide représentant l'objet à transformer en chaîne et est ensuite appelé pour chacune des propriétés de l'objet ou du tableau à convertir. Elle doit renvoyer la valeur à ajouter à la chaîne de caractère JSON comme suit :</p>
+
+<ul>
+ <li>Si on renvoie un <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Number" title="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Number"><code>Number</code></a>, la chaîne correspondante à ce nombre est utilisée pour la valeur de la propriété de à ajouter à la chaîne JSON.</li>
+ <li>Si on renvoie une <a href="/fr/docs/JavaScript/Guide/Objets_élémentaires_JavaScript#L'objet_String" title="/fr/docs/JavaScript/Guide/Objets_élémentaires_JavaScript#L'objet_String"><code>String</code></a>, cette chaîne est utilisée comme la valeur de la propriété à ajouter à la chaîne JSON.</li>
+ <li>Si on renvoie un <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Boolean"><code>Boolean</code></a>, "true" ou "false" est utilisé comme la valeur de la propriété à ajouter à la chaîne JSON.</li>
+ <li>Si on renvoie n'importe quel autre objet, il est alors transformé en chaîne JSON de façon récursive en appelant la même fonction de remplacement sur chacune de ses propriétés sauf si l'objet est une fonction, auquel cas on n'ajoute rien à la chaîne JSON.</li>
+ <li>Si la valeur de retour est <code>undefined</code>, la propriété n'est pas incluse dans la chaîne résultante.</li>
+</ul>
+
+<div class="note"><strong>Note :</strong> Il est impossible d'utiliser la fonction de remplacement pour retirer des valeurs d'un tableau. Si la valeur <code>undefined</code> ou une fonction est renvoyée  : <code>null</code> sera renvoyé.</div>
+
+<h4 id="Exemple">Exemple</h4>
+
+<pre class="brush: js">function censure(key, value) {
+  if (typeof value === "string") {
+    return undefined;
+  }
+  return value;
+}
+
+var toto = {fondation: "Mozilla", modèle: "box", semaine: 45, transport: "voiture", mois: 7};
+var chaineJSON = JSON.stringify(toto, censure);
+</pre>
+
+<p>La chaîne JSON produite sera <code>{"semaine":45,"mois":7}</code>.</p>
+
+<p>Si <code>remplacement</code> est un tableau, les valeurs du tableau indiquent les noms des propriétés de l'objet à inclure dans la chaîne JSON.</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li><a class="internal" href="/fr/docs/Web/JavaScript/New_in_JavaScript/Support_ECMAScript_5_par_Mozilla">Support d'ECMAScript 5 par Mozilla</a></li>
+ <li><a class="internal" href="/fr/docs/JSON" title="/fr/docs/JSON">JSON</a></li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/map/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/map/index.html
new file mode 100644
index 0000000000..48a00f9135
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/map/index.html
@@ -0,0 +1,89 @@
+---
+title: Map.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/Map/prototype
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Map
+  - Propriété
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Map
+translation_of_original: Web/JavaScript/Reference/Global_Objects/Map/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <strong><code>Map.prototype</code></strong> représente le prototype du constructeur {{jsxref("Map")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Les instances de {{jsxref("Map")}} héritent de {{jsxref("Map.prototype")}}. Le prototype du constructeur permet d'ajouter des propriétés ou des méthodes à toutes les instances de <code>Map</code>.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>Map.prototype.constructor</code></dt>
+ <dd>Renvoie la fonction qui a créé l'instance du prototype. Par défaut, ce sera la fonction {{jsxref("Map")}}.</dd>
+ <dt>{{jsxref("Map.prototype.size")}}</dt>
+ <dd>Renvoie le nombre de paires de clé-valeur contenues dans l'objet <code>Map</code>.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("Map.prototype.clear()")}}</dt>
+ <dd>Supprime toutes les paires de clé-valeur de l'objet <code>Map</code>.</dd>
+ <dt>{{jsxref("Map.delete", "Map.prototype.delete(clé)")}}</dt>
+ <dd>Renvoie <code>true</code> si un élément contenu dans l'objet <code>Map</code> existait avec cette clé et a été retiré. Si aucun élément n'existe dans l'objet <code>Map</code> avec cette clé, c'est <code>false</code> qui est renvoyé. <code>Map.prototype.has(clé)</code> renverra <code>false</code> après l'exécution de cette méthode.</dd>
+ <dt>{{jsxref("Map.prototype.entries()")}}</dt>
+ <dd>Renvoie un nouvel objet <a href="/fr/docs/Web/JavaScript/Guide/Le_protocole_iterator">Iterator</a> qui contient un tableau de<strong> <code>[clé, valeur]</code></strong> pour chacun des éléments de l'objet <code>Map</code>, dans leur ordre d'insertion.</dd>
+ <dt>{{jsxref("Map.forEach", "Map.prototype.forEach(callbackFn[, thisArg])")}}</dt>
+ <dd>Appelle la fonction <code>callbackFn</code> pour chaque paire clé-valeur de l'objet <code>Map</code> dans leur ordre d'insertion. Si un paramètre <code>thisArg</code> est fourni, il sera utilisé comme valeur pour <code>this</code> pour chaque appel de la fonction de retour (callback).</dd>
+ <dt>{{jsxref("Map.get", "Map.prototype.get(clé)")}}</dt>
+ <dd>Renvoie la valeur associée à la clé et <code>undefined</code> s'il n'y en a pas.</dd>
+ <dt>{{jsxref("Map.has", "Map.prototype.has(clé)")}}</dt>
+ <dd>Renvoie un booléen indiquant si une valeur associée à cette clé a été trouvée dans l'objet <code>Map</code>.</dd>
+ <dt>{{jsxref("Map.prototype.keys()")}}</dt>
+ <dd>Renvoie un nouvel objet <code>Iterator</code> contenant les <strong>clés</strong> de chaque élément de l'objet <code>Map</code> dans leur ordre d'insertion.</dd>
+ <dt>{{jsxref("Map.set", "Map.prototype.set(clé, valeur)")}}</dt>
+ <dd>Définit la valeur d'un clé pour l'objet <code>Map</code>. Renvoie <code>undefined</code>.</dd>
+ <dt>{{jsxref("Map.prototype.values()")}}</dt>
+ <dd>Renvoie un nouvel objet <code>Iterator</code> contenant les <strong>valeurs</strong> de chaque élément de l'objet <code>Map</code> dans leur ordre d'insertion.</dd>
+ <dt>{{jsxref("Map.@@iterator", "Map.prototype[@@iterator]()")}}</dt>
+ <dd>Renvoie une nouvel objet <code>Iterator</code> qui contient <strong>un tableau de <code>[clé, valeur]</code></strong> pour chaque élément de l'objet <code>Map</code> dans leur ordre d'insertion.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-map.prototype', 'Map.prototype')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map.prototype', 'Map.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Map.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Set.prototype")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/number/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/number/index.html
new file mode 100644
index 0000000000..0cb02e939e
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/number/index.html
@@ -0,0 +1,91 @@
+---
+title: Number.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/Number/prototype
+tags:
+  - JavaScript
+  - Number
+  - Propriété
+  - Prototype
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Number
+translation_of_original: Web/JavaScript/Reference/Global_Objects/Number/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <strong><code>Number.prototype</code></strong> représente le prototype du constructeur {{jsxref("Number")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Les instances de {{jsxref("Number")}} héritent de <code>Number.prototype</code>. On peut modifier l'objet prototype du constructeur {{jsxref("Number")}} afin que la modification affecte chacune des instances de <code>Number</code>.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>Number.prototype.constructor</code></dt>
+ <dd>Renvoie la fonction qui a créé l'instance de cette objet. Par défaut, ce sera l'objet {{jsxref("Number")}}.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("Number.prototype.toExponential()")}}</dt>
+ <dd>Renvoie une chaîne de caractères qui représente le nombre en notation exponentielle.</dd>
+ <dt>{{jsxref("Number.prototype.toFixed()")}}</dt>
+ <dd>Renvoie une chaîne de caractères qui représente le nombre en représentation à point fixe.</dd>
+ <dt>{{jsxref("Number.prototype.toLocaleString()")}}</dt>
+ <dd>Renvoie une chaîne de caractères qui représente le nombre en tenant compte de la locale. Surcharge la méthode {{jsxref("Object.prototype.toLocaleString()")}}.</dd>
+ <dt>{{jsxref("Number.prototype.toPrecision()")}}</dt>
+ <dd>Renvoie une chaîne de caractères représentant le nombre en représentation à point fixe, selon une précision donnée ou en notation exponentielle.</dd>
+ <dt>{{jsxref("Number.prototype.toSource()")}} {{ Non-standard_inline() }}</dt>
+ <dd>Renvoie un litéral objet représentant l'objet <code>Number</code> fourni. On peut utiliser cette valeur afin de créer un nouvel objet. Cette méthode surcharge la méthode {{jsxref("Object.prototype.toSource()")}}.</dd>
+ <dt>{{jsxref("Number.prototype.toString()")}}</dt>
+ <dd>Renvoie une chaîne de caractères qui représente l'objet fourni selon une base donnée. Surcharge la méthode {{jsxref("Object.prototype.toString()")}}.</dd>
+ <dt>{{jsxref("Number.prototype.valueOf()")}}</dt>
+ <dd>Renvoie une valeur primitive de l'objet fourni. Surcharge la méthode {{jsxref("Object.prototype.valueOf()")}}.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Définition initiale. Implémentée avec JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.7.4', 'Number')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-properties-of-the-number-prototype-object', 'Number')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-properties-of-the-number-prototype-object', 'Number')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p>
+
+<p>{{Compat("javascript.builtins.Number.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Number")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/object/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/object/index.html
new file mode 100644
index 0000000000..6eb405ace4
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/object/index.html
@@ -0,0 +1,176 @@
+---
+title: Object.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/Object/prototype
+tags:
+  - JavaScript
+  - Object
+  - Propriété
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Object
+translation_of_original: Web/JavaScript/Reference/Global_Objects/Object/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>Object.prototype</strong></code> représente le prototype de {{jsxref("Object")}}.</p>
+
+<p>{{js_property_attributes(0, 0, 0)}}</p>
+
+<h2 id="Description">Description</h2>
+
+<p>La quasi-totalité des objets JavaScript descendent de {{jsxref("Object")}} ; un objet classique héritera donc des méthodes et propriétés de <code>Object.prototype</code>. Comme pour toutes les propriétés héritées, il est possible de surcharger ces propriétés. Par exemple, d'autres prototypes de constructeurs surchargent la propriété <code>constructor</code> et fournissent leur propre méthode {{jsxref("Object.prototype.toString()", "toString()")}}.</p>
+
+<p>Cependant, on peut volontairement créer des objets qui ne descendent pas de {{jsxref("Object")}} (par exemple avec {{jsxref("Object.create", "Object.create(null)")}}) ou les modifier afin que ce ne soit plus le cas (par exemple avec la méthode {{jsxref("Object.setPrototypeOf()")}}).</p>
+
+<p>Les modifications apportées aux propriétés du prototype d'<code>Object</code> impactent donc tous ces objets via la chaîne de prototypes, sauf si ces propriétés sont surchargées. Ce puissant mécanisme permet ainsi de modifier le comportement des objets ou d'y ajouter des fonctionnalités.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt>{{jsxref("Object.prototype.constructor")}}</dt>
+ <dd>Définit la fonction qui a créé le prototype d'un objet.</dd>
+ <dt>{{jsxref("Object.prototype.proto","Object.prototype.__proto__")}} {{non-standard_inline}}</dt>
+ <dd>Pointe vers l'objet qui a été utilisé comme prototype lors de l'instanciation de l'objet.</dd>
+ <dt>{{jsxref("Object.prototype.noSuchMethod","Object.prototype.__noSuchMethod__")}} {{non-standard_inline}}</dt>
+ <dd>Permet de définir une fonction qui sera exécutée lors d'une tentative d'accès à une méthode non-définie pour l'objet.</dd>
+ <dt><s class="obsoleteElement">{{jsxref("Object.prototype.count","Object.prototype.__count__")}} {{obsolete_inline}}</s></dt>
+ <dd><s class="obsoleteElement">UTilisée pour renvoyer le nombre de propriétés énumérables sur un objet défini par l'utilisateur. Cette propriété a été retirée.</s></dd>
+ <dt><s class="obsoleteElement">{{jsxref("Object.prototype.parent","Object.prototype.__parent__")}} {{obsolete_inline}}</s></dt>
+ <dd><s class="obsoleteElement">Utilisée pour faire référence au contexte de l'objet. Cette propriété a été retirée.</s></dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("Object.prototype.defineGetter","Object.prototype.__defineGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
+ <dd>Associe une fonction à une propriété qui, lorsqu'on y accède, exécute la fonction et renvoie la valeur de retour.</dd>
+ <dt>{{jsxref("Object.prototype.defineSetter","Object.prototype.__defineSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
+ <dd>Associe une fonction à une propriété qui, lorsqu'on la définit, exécute la fonction qui modifie la propriété.</dd>
+ <dt>{{jsxref("Object.prototype.lookupGetter","Object.prototype.__lookupGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
+ <dd>Renvoie la fonction associée à la propriété définie par la méthode {{jsxref("Object.defineGetter", "__defineGetter__")}}.</dd>
+ <dt>{{jsxref("Object.prototype.lookupSetter()","Object.prototype.__lookupSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
+ <dd>Renvoie la fonction associée avec la propriété définie par la méthode {{jsxref("Object.defineSetter", "__defineSetter__")}}.</dd>
+ <dt>{{jsxref("Object.prototype.hasOwnProperty()")}}</dt>
+ <dd>Renvoie un booléen qui indique si l'objet contient la propriété donnée comme une propriété propre (non héritée via la chaîne de prototypes).</dd>
+ <dt>{{jsxref("Object.prototype.isPrototypeOf()")}}</dt>
+ <dd>Renvoie un booléen qui indique si l'objet courant fait partie de la chaîne de prototype de l'objet passé en argument.</dd>
+ <dt>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</dt>
+ <dd>Renvoie un booléen qui indique si l'<a href="/fr/docs/Web/JavaScript/Structures_de_données#Propriétés">attribut ECMAScript interne [[Enumerable]]</a> est défini.</dd>
+ <dt>{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}</dt>
+ <dd>Renvoie une chaîne de caractères qui est un littéral objet représentant l'objet pour lequel la méthode a été appelée. La valeur de retour peut être utilisée pour créer un nouvel objet.</dd>
+ <dt>{{jsxref("Object.prototype.toLocaleString()")}}</dt>
+ <dd>Appelle la méthode {{jsxref("Object.toString", "toString()")}}.</dd>
+ <dt>{{jsxref("Object.prototype.toString()")}}</dt>
+ <dd>Renvoie une chaîne de caractères représentant l'objet.</dd>
+ <dt>{{jsxref("Object.prototype.unwatch()")}} {{non-standard_inline}}</dt>
+ <dd>Supprime un point d'arrêt conditionnel placé sur une propriété de l'objet.</dd>
+ <dt>{{jsxref("Object.prototype.valueOf()")}}</dt>
+ <dd>Renvoie la valeur primitive de l'objet.</dd>
+ <dt>{{jsxref("Object.prototype.watch()")}} {{non-standard_inline}}</dt>
+ <dd>Ajoute un point d'arrêt conditionnel sur une propriété de l'objet.</dd>
+ <dt><s class="obsoleteElement">{{jsxref("Object.prototype.eval()")}} {{obsolete_inline}}</s></dt>
+ <dd><s class="obsoleteElement">Utilisée pour évaluer une chaîne de caractères étant du code JavaScript dans le contexte de l'objet. Cette méthode a été retirée.</s></dd>
+</dl>
+
+<h2 id="Exemples">Exemples</h2>
+
+<p>Javascript se base sur un modèle prototypal et non pas classique (au sens « modèle à base de classes »). Le prototype d'un objet est utilisé pour fournir de façon dynamique des propriétés aux objets qui héritent du prototype.</p>
+
+<p>Par exemple :</p>
+
+<pre class="brush: js">var Personne = function(nom) {
+  this.name = nom;
+  this.peutParler = true;
+  this.salutation = function() {
+    if (this.peutParler) {
+      console.log('Bonjour, je suis ' + this.nom);
+    }
+  };
+};
+
+var Employe = function(nom, titre) {
+  this.nom = nom;
+  this.titre = titre;
+  this.salutation = function() {
+    if (this.peutParler) {
+      console.log("Bonjour, je suis " + this.nom + ", le " + this.titre);
+    }
+  };
+};
+Employe.prototype = new Personne();
+
+var Client = function(nom) {
+  this.nom = nom;
+};
+Client.prototype = new Personne();
+
+var Mime = function(nom) {
+  this.nom = nom;
+  this.peutParler = false;
+};
+Mime.prototype = new Personne();
+
+var bob = new Employe('Bob', 'bricoleur');
+var joe = new Client('Joe');
+var rg = new Employe('Red Green', 'réparateur');
+var mike = new Client('Mike');
+var mime = new Mime('Mime');
+bob.salutation();
+// Bonjour, je suis Bob, le bricoleur
+
+joe.salutation();
+// Bonjour, je suis Joe
+
+rg.salutation();
+// Bonjour, je suis Red Green, le réparateur
+
+mike.salutation();
+// Bonjour, je suis Mike
+
+mime.salutation();
+</pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Définition initiale. Implémentée avec JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.1', 'Object.prototype')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.prototype', 'Object.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.prototype', 'Object.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.Object.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li><a href="/fr/docs/Web/JavaScript/Introduction_à_JavaScript_orienté_objet">Introduction à JavaScript orienté objet</a></li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/object/tosource/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/object/tosource/index.html
new file mode 100644
index 0000000000..cbd68198f6
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/object/tosource/index.html
@@ -0,0 +1,26 @@
+---
+title: toSource
+slug: toSource
+tags:
+  - Désambiguation
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/toSource
+translation_of_original: toSource
+---
+<div class="noinclude"><strong>toSource</strong> est une méthode de différents objets JavaScript :</div>
+
+<ul>
+ <li><a href="/fr/Référence_de_JavaScript_1.5_Core/Objets_globaux/Array/toSource" title="fr/Référence_de_JavaScript_1.5_Core/Objets_globaux/Array/toSource">toSource</a> — méthode de l'objet Array.</li>
+ <li><a href="/fr/Référence_de_JavaScript_1.5_Core/Objets_globaux/Boolean/toSource" title="fr/Référence_de_JavaScript_1.5_Core/Objets_globaux/Boolean/toSource">toSource</a> — méthode de l'objet Boolean.</li>
+ <li><a href="/fr/Référence_de_JavaScript_1.5_Core/Objets_globaux/Date/toSource" title="fr/Référence_de_JavaScript_1.5_Core/Objets_globaux/Date/toSource">toSource</a> — méthode de l'objet Date.</li>
+ <li><a href="/fr/Référence_de_JavaScript_1.5_Core/Objets_globaux/Function/toSource" title="fr/Référence_de_JavaScript_1.5_Core/Objets_globaux/Function/toSource">toSource</a> — méthode de l'objet Function.</li>
+ <li><a href="/fr/Référence_de_JavaScript_1.5_Core/Objets_globaux/Number/toSource" title="fr/Référence_de_JavaScript_1.5_Core/Objets_globaux/Number/toSource">toSource</a> — méthode de l'objet Number.</li>
+ <li><a href="/fr/Référence_de_JavaScript_1.5_Core/Objets_globaux/Object/toSource" title="fr/Référence_de_JavaScript_1.5_Core/Objets_globaux/Object/toSource">toSource</a> — méthode de l'objet Object.</li>
+ <li><a href="/fr/Référence_de_JavaScript_1.5_Core/Objets_globaux/RegExp/toSource" title="fr/Référence_de_JavaScript_1.5_Core/Objets_globaux/RegExp/toSource">toSource</a> — méthode de l'objet RegExp.</li>
+ <li><a href="/fr/Référence_de_JavaScript_1.5_Core/Objets_globaux/String/toSource" title="fr/Référence_de_JavaScript_1.5_Core/Objets_globaux/String/toSource">toSource</a> — méthode de l'objet String.</li>
+</ul>
+
+<div class="noinclude"><div class="disambig" id="disambig"><p><i>Ceci est une page de <a href="https://developer.mozilla.org/fr/docs/Project:D%c3%a9sambiguation">désambiguation</a> — une aide à la navigation qui liste une série de pages qui devraient partager le même titre. Si un lien provenant d'un article mène ici, n'hésitez pas à revenir à celui-ci pour le faire pointer vers la page concernée.</i></p></div></div>
+
+<div class="noinclude">
+<p>{{ languages( { "en": "en/ToSource" } ) }}</p>
+</div>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/promise/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/promise/index.html
new file mode 100644
index 0000000000..9a6146375f
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/promise/index.html
@@ -0,0 +1,73 @@
+---
+title: Promise.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/Promise/prototype
+tags:
+  - JavaScript
+  - Promise
+  - Propriété
+  - Prototype
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Promise
+translation_of_original: Web/JavaScript/Reference/Global_Objects/Promise/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>Promise.prototype</strong></code> représente le prototype pour le constructeur {{jsxref("Promise")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Les instances de {{jsxref("Promise")}} héritent de {{jsxref("Promise.prototype")}}. On peut utiliser le prototype du constructeur afin d'ajouter des propriétés et/ou des méthodes à chacune des instances de <code>Promise</code>.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>Promise.prototype.constructor</code></dt>
+ <dd>Renvoie la fonction qui a créé le prototype d'une instance. Ce sera la fonction {{jsxref("Promise")}} par défaut.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("Promise.prototype.catch()")}}</dt>
+ <dd>Ajoute une fonction <em>callback</em> à utiliser en cas de rejet de la promesse. Elle renvoie une nouvelle promesse qui est résolue avec la valeur de retour du callback s'il est appelé ou avec la valeur de résolution initiale si la promesse est tenue (et non rejetée).</dd>
+ <dt>{{jsxref("Promise.prototype.then()")}}</dt>
+ <dd>Ajoute des fonctions à utiliser en cas de résolution ou de rejet de la promesse et renvoie une nouvelle promesse qui est résolue avec la valeur de retour de la fonction utilisée en fonction de la résolution ou non.</dd>
+ <dt>{{jsxref("Promise.prototype.finally()")}}</dt>
+ <dd>Ajoute une fonction à la promesse et renvoie une nouvelle promesse qui est résolue lorsque la promesse originale est résolue. La fonction ajoutée est appelée lorsque la promesse est résolue, qu'elle soit tenue ou rejetée.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-promise.prototype', 'Promise.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-promise.prototype', 'Promise.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<p class="hidden">Pour contribuer à ces données de compatibilité, vous pouvez envoyer une poule requête sur : <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p>
+
+<p>{{Compat("javascript.builtins.Promise.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Promise")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/rangeerror/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/rangeerror/index.html
new file mode 100644
index 0000000000..1af96393bc
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/rangeerror/index.html
@@ -0,0 +1,92 @@
+---
+title: RangeError.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/RangeError/prototype
+tags:
+  - Error
+  - JavaScript
+  - Propriété
+  - Prototype
+  - RangeError
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/RangeError
+translation_of_original: Web/JavaScript/Reference/Global_Objects/RangeError/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>RangeError.prototype</strong></code> représente le prototype du constructeur {{jsxref("RangeError")}}.</p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Chacune des instances de {{jsxref("RangeError")}} hérite de <code>RangeError.prototype</code>. Le prototype peut être utilisé afin d'ajouter des propriétés et/ou des méthodes à toutes les instances.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>RangeError.prototype.constructor</code></dt>
+ <dd>Définit la fonction qui a créé le prototype de l'instance.</dd>
+ <dt>{{jsxref("Error.prototype.message", "RangeError.prototype.message")}}</dt>
+ <dd>Le nom de l'erreur. Bien que ECMA-262 spécifie que {{jsxref("RangeError")}} devrait fournir sa propre propriété <code>message</code>, dans <a href="/fr/docs/SpiderMonkey" title="SpiderMonkey">SpiderMonkey</a>, il l'hérite depuis {{jsxref("Error.prototype.message")}}.</dd>
+ <dt>{{jsxref("Error.prototype.name", "RangeError.prototype.name")}}</dt>
+ <dd>Le nom de l'erreur, hérité depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.fileName", "RangeError.prototype.fileName")}}</dt>
+ <dd>Le chemin vers le fichier qui a causé l'erreur, hérité depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.lineNumber", "RangeError.prototype.lineNumber")}}</dt>
+ <dd>Le numéro de la ligne de code dans le fichier qui a causé l'erreur, hérité depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.columnNumber", "RangeError.prototype.columnNumber")}}</dt>
+ <dd>La position du code (colonne) dans la ligne de code qui a causé l'erreur, héritée depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.stack", "RangeError.prototype.stack")}}</dt>
+ <dd>Pile d'appels, héritée depuis {{jsxref("Error")}}.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<p>Bien que l'objet prototype {{jsxref("RangeError")}} ne possède pas de méthodes propres, les instances de <code>RangeError</code> hériteront de certaines méthodes via la chaîne de prototypes.</p>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">Statut</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Défini comme <code><em>NativeError</em>.prototype</code>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Défini comme <code><em>NativeError</em>.prototype</code>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Défini comme <code><em>NativeError</em>.prototype</code>.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div>
+<div class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.RangeError")}}</p>
+</div>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype")}}</li>
+ <li>{{jsxref("Function.prototype")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/referenceerror/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/referenceerror/index.html
new file mode 100644
index 0000000000..bdbf50f34c
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/referenceerror/index.html
@@ -0,0 +1,92 @@
+---
+title: ReferenceError.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/ReferenceError/prototype
+tags:
+  - Error
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+  - ReferenceError
+translation_of: Web/JavaScript/Reference/Global_Objects/ReferenceError
+translation_of_original: Web/JavaScript/Reference/Global_Objects/ReferenceError/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>ReferenceError.prototype</strong></code> représente le prototype du constructeur {{jsxref("ReferenceError")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Toutes les instances de {{jsxref("ReferenceError")}} héritent de <code>ReferenceError.prototype</code>. Le prototype peut être utilisé pour ajouter des propriétés ou des méthodes à chacune des instances.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>ReferenceError.prototype.constructor</code></dt>
+ <dd>Définit la fonction utilisée pour créer une instance du prototype.</dd>
+ <dt>{{jsxref("Error.prototype.message", "ReferenceError.prototype.message")}}</dt>
+ <dd>Le message de l'erreur. Bien que ECMA-262 spécifie que <code>ReferenceError</code> devrait posséder une propriété <code>message</code> en propre, <a href="/fr/docs/SpiderMonkey" title="SpiderMonkey">SpiderMonkey</a> lui fait hériter de {{jsxref("Error.prototype.message")}}.</dd>
+ <dt>{{jsxref("Error.prototype.name", "ReferenceError.prototype.name")}}</dt>
+ <dd>Le nom de l'erreur. Cette propriété est héritée depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.fileName", "ReferenceError.prototype.fileName")}}</dt>
+ <dd>Le chemin du fichier à l'origine de cette erreur. Cette propriété est héritée depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.lineNumber", "ReferenceError.prototype.lineNumber")}}</dt>
+ <dd>Le numéro de la ligne dans le fichier à l'origine de l'erreur. Cette propriété est héritée depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.columnNumber", "ReferenceError.prototype.columnNumber")}}</dt>
+ <dd>Le numéro de la colonne parmi la ligne à l'origine de l'erreur. Cette propriété est héritée depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.stack", "ReferenceError.prototype.stack")}}</dt>
+ <dd>La pile d'appels, héritée de {{jsxref("Error")}}.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<p>Bien que l'objet prototype pour {{jsxref("ReferenceError")}} ne contienne aucune méthode propre, les instances de <code>ReferenceError</code> héritent de certaines méthodes via la chaîne de prototypes.</p>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">Statut</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Défini comme <code><em>NativeError</em>.prototype</code>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Défini comme <code><em>NativeError</em>.prototype</code>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Défini comme <code><em>NativeError</em>.prototype</code>.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div>
+<div class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.ReferenceError")}}</p>
+</div>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype")}}</li>
+ <li>{{jsxref("Function.prototype")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/regexp/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/regexp/index.html
new file mode 100644
index 0000000000..7a507e9699
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/regexp/index.html
@@ -0,0 +1,119 @@
+---
+title: RegExp.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/RegExp/prototype
+tags:
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+  - RegExp
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp
+translation_of_original: Web/JavaScript/Reference/Global_Objects/RegExp/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>RegExp.prototype</strong></code> représente l'objet prototype pour le constructeur {{jsxref("RegExp")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Voir la page {{jsxref("RegExp")}} qui décrit les instances de <code>RegExp</code>. Chaque instance de <code>RegExp</code> hérite de <code>RegExp.prototype</code>. Toute modification à l'objet prototype est propagée aux instances de <code>RegExp</code>.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<p>Voir également la page sur <a href="/fr/docs/JavaScript/Reference/Annexes/Fonctionnalités_dépréciées">les propriétés dépréciées de <code>RegExp</code>.</a></p>
+
+<p>On notera que plusieurs des propriétés de {{jsxref("RegExp")}} ont un nom court et un nom long (semblable aux noms Perl). Le nom court et le nom long font référence à la même propriété. La modélisation des expressions rationnelles JavaScript est basée sur celle de Perl, un autre langage de programmation.</p>
+
+<dl>
+ <dt><code>RegExp.prototype.</code><code>constructor</code></dt>
+ <dd>Définit la fonction qui crée le prototype d'un objet.</dd>
+ <dt>{{jsxref("RegExp.prototype.flags")}}</dt>
+ <dd>Une chaîne qui contient les drapeaux (<em>flags</em>) utilisés pour l'objet <code>RegExp</code>.</dd>
+ <dt>{{jsxref("RegExp.prototype.dotAll")}}</dt>
+ <dd>Indique si <code>.</code> peut correspondre à des sauts de ligne.</dd>
+ <dt>{{jsxref("RegExp.prototype.global")}}</dt>
+ <dd>Définit si l'expression rationnelle doit relever la première correspondance d'une chaîne ou toutes les correspondances.</dd>
+ <dt>{{jsxref("RegExp.prototype.ignoreCase")}}</dt>
+ <dd>Définit si l'expression rationnelle doit ignorer la casse ou non pour détecter une correspondance.</dd>
+ <dt>{{jsxref("RegExp.prototype.multiline")}}</dt>
+ <dd>Définit si la recherche de la correspondance s'effectue sur plusieurs lignes ou sur une seule.</dd>
+ <dt>{{jsxref("RegExp.prototype.source")}}</dt>
+ <dd>Le texte du motif (<em>pattern</em>) à rechercher.</dd>
+ <dt>{{jsxref("RegExp.prototype.sticky")}}</dt>
+ <dd>Définit si la recherche s'effectue uniquement à partir de <code>lastIndex</code> ou non.</dd>
+ <dt>{{jsxref("RegExp.prototype.unicode")}}</dt>
+ <dd>Cette propriété indique si les fonctionnalités Unicode sont activées ou non.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("Regexp.prototype.compile()")}}{{deprecated_inline}}</dt>
+ <dd>(Re)compile une expression rationnelle lors de l'exécution d'un script.</dd>
+ <dt>{{jsxref("RegExp.prototype.exec()")}}</dt>
+ <dd>Exécute une recherche de correspondance sur la chaîne de caractères fournie en paramètre.</dd>
+ <dt>{{jsxref("RegExp.prototype.test()")}}</dt>
+ <dd>Teste s'il y a une correspondance dans la chaîne de caractères fournie en paramètre.</dd>
+ <dt>{{jsxref("RegExp.prototype.@@match()", "RegExp.prototype[@@match]()")}}</dt>
+ <dd>Teste une correspondance sur une chaîne de caractères donnée et renvoie le résultat du test.</dd>
+ <dt>{{jsxref("RegExp.prototype.@@matchAll()", "RegExp.prototype[@@matchAll]()")}}</dt>
+ <dd>Renvoie l'ensemble des correspondances d'une expression rationnelle sur une chaîne.</dd>
+ <dt>{{jsxref("RegExp.prototype.@@replace()", "RegExp.prototype[@@replace]()")}}</dt>
+ <dd>Remplace les correspondances d'une chaîne de caractères avec une nouvelle sous-chaînes.</dd>
+ <dt>{{jsxref("RegExp.prototype.@@search()", "RegExp.prototype[@@search]()")}}</dt>
+ <dd>Recherche la correspondance dans une chaîne de caractères donnée et renvoie la position où est trouvé le motif.</dd>
+ <dt>{{jsxref("RegExp.prototype.@@split()", "RegExp.prototype[@@split]()")}}</dt>
+ <dd>Découpe une chaîne de caractères en un tableau de sous-chaînes.</dd>
+ <dt>{{jsxref("RegExp.prototype.toSource()")}} {{non-standard_inline}}</dt>
+ <dd>Renvoie un littéral objet représentant l'objet spécifié. Cette méthode peut être utilisée pour créer un nouvel objet. Elle surcharge la méthode {{jsxref("Object.prototype.toSource()")}}.</dd>
+ <dt>{{jsxref("RegExp.prototype.toString()")}}</dt>
+ <dd>Renvoie une chaîne de caractères représentant l'objet spécifié. Cette méthode surcharge {{jsxref("Object.prototype.toString()")}}.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">Statut</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Définition initiale</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.10.5.1', 'RegExp')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-regexp.prototype', 'RegExp.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-regexp.prototype', 'RegExp.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.RegExp.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li><a href="/fr/docs/Web/JavaScript/Guide/Expressions_régulières">Le chapitre concernant les expressions rationnelles</a> du <a href="/fr/docs/Web/JavaScript/Guide" title="JavaScript/Guide">Guide JavaScript</a></li>
+ <li>{{jsxref("RegExp")}}</li>
+ <li>{{jsxref("Function.prototype")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/set/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/set/index.html
new file mode 100644
index 0000000000..485be156ee
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/set/index.html
@@ -0,0 +1,88 @@
+---
+title: Set.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/Set/prototype
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Propriété
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Set
+translation_of_original: Web/JavaScript/Reference/Global_Objects/Set/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>Set.prototype</strong></code> représente le prototype pour le constructeur {{jsxref("Set")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Les instances de {{jsxref("Set")}} héritent de {{jsxref("Set.prototype")}}. Le prototype peut être utilisé afin d'ajouter des propriétés (valeurs ou méthodes) à toutes les instances de <code>Set</code>.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>Set.prototype.constructor</code></dt>
+ <dd>Renvoie la fonction qui crée le prototype d'une instance. Par défaut, ce sera la fonction {{jsxref("Set")}}.</dd>
+ <dt>{{jsxref("Set.prototype.size")}}</dt>
+ <dd>Renvoie le nombre de valeurs contenues dans l'objet <code>Set</code>.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("Set.add", "Set.prototype.add(valeur)")}}</dt>
+ <dd>Ajoute un nouvel élément à l'objet <code>Set</code> avec la valeur donnée. La valeur de retour est l'objet <code>Set</code>.</dd>
+ <dt>{{jsxref("Set.prototype.clear()")}}</dt>
+ <dd>Retire tous les éléments de l'objet <code>Set</code>.</dd>
+ <dt>{{jsxref("Set.delete", "Set.prototype.delete(valeur)")}}</dt>
+ <dd>Retire l'élément associé à la <code>valeur</code> et renvoie la valeur que <code>Set.prototype.has(valeur)</code> aurait renvoyé. <code>Set.prototype.has(valeur)</code> renverra <code>false</code> après la suppression.</dd>
+ <dt>{{jsxref("Set.prototype.entries()")}}</dt>
+ <dd>Renvoie un nouvel objet <code>Iterator</code> qui contient un tableau de<strong> <code>[valeur, valeur]</code></strong> pour chaque élément de l'objet <code>Set</code>, dans l'ordre dans lequel les valeurs ont été insérées. On aura donc une structure semblable à un objet <code>Map</code>. Ici, chaque entrée aura la même valeur pour la <em>clé</em> et la <em>valeur</em>.</dd>
+ <dt>{{jsxref("Set.forEach", "Set.prototype.forEach(fnCallback[, thisArg])")}}</dt>
+ <dd>Appelle la fonction <code>fnCallback</code> pour chaque valeur présente dans l'objet <code>Set</code>, dans l'ordre dans lequel elles ont été insérées. Si un paramètre <code>thisArg</code> est fourni à <code>forEach</code>, il sera utilisé comme valeur de <code>this</code> pour chaque appel de la fonction de callback.</dd>
+ <dt>{{jsxref("Set.has", "Set.prototype.has(valeur)")}}</dt>
+ <dd>Renvoie un booléen qui indique si un des éléments de l'ensemble possède cette valeur.</dd>
+ <dt>{{jsxref("Set.prototype.values()","Set.prototype.keys()")}}</dt>
+ <dd>Cette fonction correspond à la fonction <strong><code>values()</code></strong> et renvoie un nouvel objet <code>Iterator</code> qui contient les valeurs correspondant à chaque élément de <code>Set</code> dans l'ordre dans lequel ils ont été insérés.</dd>
+ <dt>{{jsxref("Set.prototype.values()")}}</dt>
+ <dd>Renvoie un nouvel objet <code>Iterator</code> qui contient les valeurs pour chacun des éléments de l'objet <code>Set</code>, dans l'ordre dans lequel ils ont été insérés.</dd>
+ <dt>{{jsxref("Set.prototype.@@iterator()","Set.prototype[@@iterator]()")}}</dt>
+ <dd>Renvoie un nouvel objet <code>Iterator</code> qui contient les valeurs pour chaque élément de l'objet <code>Set</code> dans leur ordre d'insertion.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-set.prototype', 'Set.prototype')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définition initiale</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-set.prototype', 'Set.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Set.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Map.prototype")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/sharedarraybuffer/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/sharedarraybuffer/index.html
new file mode 100644
index 0000000000..58e0f921fd
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/sharedarraybuffer/index.html
@@ -0,0 +1,67 @@
+---
+title: SharedArrayBuffer.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/SharedArrayBuffer/prototype
+tags:
+  - JavaScript
+  - Mémoire partagée
+  - Propriété
+  - Reference
+  - SharedArrayBuffer
+  - TypedArrays
+translation_of: Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer
+translation_of_original: Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <strong><code>SharedArrayBuffer.prototype</code></strong> représente le prototype de l'objet {{jsxref("SharedArrayBuffer")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Les instances de <code>SharedArrayBuffer</code> héritent de <code>SharedArrayBuffer.prototype</code>. Comme avec les autres constructeurs, il est possible de changer le constructeur de l'objet prototype afin de modifier l'ensemble des instancees de <code>SharedArrayBuffer</code>.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt>SharedArrayBuffer.prototype.constructor</dt>
+ <dd>Cette méthode définit la fonction qui crée le prototype d'un objet. La valeur initiale de cette méthode est le constructeur natif <code>SharedArrayBuffer</code>.</dd>
+ <dt>{{jsxref("SharedArrayBuffer.prototype.byteLength")}} {{readonlyInline}}</dt>
+ <dd>La taille, exprimée en octets, du tableau. Elle est définie lorsque le tableau est construit et elle ne peut pas être modifiée par la suite. <strong>Propriété en lecture seule</strong><strong>.</strong></dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("SharedArrayBuffer.slice", "SharedArrayBuffer.prototype.slice(début, fin)")}}</dt>
+ <dd>Cette méthode renvoie un nouvel <code>SharedArrayBuffer</code> dont le contenu est une copie des octets de cet <code>SharedArrayBuffer</code>'s entre un indice de début et un indice de fin. Si cet indice de début ou de fin est négatif, cela représentera l'indice à partir de la fin du tableau.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-sharedarraybuffer.prototype', 'SharedArrayBuffer.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Définition initiale avec ES2017.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.SharedArrayBuffer.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("SharedArrayBuffer")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/string/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/string/index.html
new file mode 100644
index 0000000000..f7fc1c80a6
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/string/index.html
@@ -0,0 +1,190 @@
+---
+title: String.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/String/prototype
+tags:
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String
+translation_of_original: Web/JavaScript/Reference/Global_Objects/String/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <strong><code>String.prototype</code></strong> représente l'objet prototype de {{jsxref("String")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Toutes les instances de {{jsxref("String")}} héritent de <code>String.prototype</code>. Les modifications de l'objet prototype <code>String</code> sont répercutées sur toutes les instances de <code>String</code>.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>String.prototype.constructor</code></dt>
+ <dd>Définit la fonction créant le prototype d'un objet.</dd>
+ <dt>{{jsxref("String.prototype.length")}}</dt>
+ <dd>Reflète la longueur de la chaîne</dd>
+ <dt><code><em>N</em></code></dt>
+ <dd>Utilisée pour accéder au caractère en <em>N</em><sup>ème</sup> position où <em>N</em> est un entier entre 0 et la valeur de {{jsxref("String.length")}} moins un. Ces propriétés sont en lecture seule.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<h3 id="Méthodes_non_liées_à_HTML">Méthodes non liées à HTML</h3>
+
+<dl>
+ <dt>{{jsxref("String.prototype.charAt()")}}</dt>
+ <dd>Renvoie le caractère (ou plus précisement, le point de code UTF-16) à la position spécifiée.</dd>
+ <dt>{{jsxref("String.prototype.charCodeAt()")}}</dt>
+ <dd>Renvoie un nombre indiquant la valeur du point de code UTF-16 du caractère à la position spécifiée.</dd>
+ <dt>{{jsxref("String.prototype.codePointAt()")}}</dt>
+ <dd>Renvoie un entier positif qui est la valeur du codet UTF-16 à la position donnée.</dd>
+ <dt>{{jsxref("String.prototype.concat()")}}</dt>
+ <dd>Combine le texte de deux chaînes et renvoie une nouvelle chaîne.</dd>
+ <dt>{{jsxref("String.prototype.includes()")}}</dt>
+ <dd>Défini si une chaîne de caractères est contenue dans une autre chaîne de caractères.</dd>
+ <dt>{{jsxref("String.prototype.endsWith()")}}</dt>
+ <dd>Défini si une chaîne de caractère se termine par une chaîne de caractères spécifique.</dd>
+ <dt>{{jsxref("String.prototype.indexOf()")}}</dt>
+ <dd>Renvoie la position, au sein de l'objet <code>String</code> appelant, de la première occurrence de la valeur spécifiée, ou -1 si celle-ci n'est pas trouvée.</dd>
+ <dt>{{jsxref("String.prototype.lastIndexOf()")}}</dt>
+ <dd>Renvoie la position, au sein de l'objet String appelant, de la dernière occurrence de la valeur spécifiée, ou -1 si celle-ci n'est pas trouvée.</dd>
+ <dt>{{jsxref("String.prototype.localeCompare()")}}</dt>
+ <dd>Renvoie un nombre indiquant si une chaîne de référence vient avant, après ou est en position identique à la chaîne donnée selon un ordre de tri.</dd>
+ <dt>{{jsxref("String.prototype.match()")}}</dt>
+ <dd>Utilisée pour faire correspondre une expression rationnelle avec une chaîne.</dd>
+ <dt>{{jsxref("String.prototype.matchAll()")}}</dt>
+ <dd>Renvoie un itérateur listant l'ensemble des correspondances d'une expression rationnelle avec la chaîne.</dd>
+ <dt>{{jsxref("String.prototype.normalize()")}}</dt>
+ <dd>Retourne la forme Unicode normalisée de la chaîne de caractères appelée.</dd>
+ <dt>{{jsxref("String.prototype.padEnd()")}}</dt>
+ <dd>Complète la chaîne courante avec une autre chaîne de caractères, éventuellement répétée, afin d'obtenir une nouvelle chaîne de la longueur indiquée. La chaîne complémentaire est ajoutée à la fin.</dd>
+ <dt>{{jsxref("String.prototype.padStart()")}}</dt>
+ <dd>Complète la chaîne courante avec une autre chaîne de caractères, éventuellement répétée, afin d'obtenir une nouvelle chaîne de la longueur indiquée. La chaîne complémentaire est ajoutée au début.</dd>
+</dl>
+
+<dl>
+ <dt>{{jsxref("String.prototype.quote()")}} {{obsolete_inline}}</dt>
+ <dd>Entoure la chaîne de guillemets doubles anglais ("<code>"</code>").</dd>
+ <dt>{{jsxref("String.prototype.repeat()")}}</dt>
+ <dd>Renvoie une chaîne dont le contenu est la chaîne courante répétée un certain nombre de fois.</dd>
+ <dt>{{jsxref("String.prototype.replace()")}}</dt>
+ <dd>Utilisée pour rechercher une correspondance entre une expression rationnelle et une chaîne, et pour remplacer la sous-chaîne correspondante par une nouvelle chaîne.</dd>
+ <dt>{{jsxref("String.prototype.search()")}}</dt>
+ <dd>Exécute la recherche d'une correspondance entre une expression régulière et une chaîne spécifiée.</dd>
+ <dt>{{jsxref("String.prototype.slice()")}}</dt>
+ <dd>Extrait une section d'une chaîne et renvoie une nouvelle chaîne.</dd>
+ <dt>{{jsxref("String.prototype.split()")}}</dt>
+ <dd>Sépare un objet String en un tableau de chaînes en séparant la chaîne en plusieurs sous-chaînes.</dd>
+ <dt>{{jsxref("String.prototype.startsWith()")}}</dt>
+ <dd>Détermine si une chaîne commence avec les caractères d'une autre chaîne.</dd>
+ <dt>{{jsxref("String.prototype.substr()")}} {{deprecated_inline}}</dt>
+ <dd>Renvoie les caractères d'une chaîne à partir de la position spécifiée et pour la longueur spécifiée.</dd>
+ <dt>{{jsxref("String.prototype.substring()")}}</dt>
+ <dd>Renvoie les caractères d'une chaîne entre deux positions dans celle-ci.</dd>
+ <dt>{{jsxref("String.prototype.toLocaleLowerCase()")}}</dt>
+ <dd>Les caractères de la chaîne seront convertis en minuscules selon la locale courante. Pour la plupart des langues, le résultat est identique à {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}.</dd>
+ <dt>{{jsxref("String.prototype.toLocaleUpperCase()")}}</dt>
+ <dd>Les caractères de la chaîne seront convertis en majuscules selon la locale courante. Pour la plupart des langues, le résultat est identique à {{jsxref("String.toUpperCase()", "toUpperCase()")}}.</dd>
+ <dt>{{jsxref("String.prototype.toLowerCase()")}}</dt>
+ <dd>Renvoie la valeur de la chaîne appelante convertie en minuscules.</dd>
+ <dt>{{jsxref("String.prototype.toSource()")}} {{ Non-standard_inline() }}</dt>
+ <dd>Renvoie une représentation littérale de l'objet; celle-ci peut être utilisée pour créer un nouvel objet. Remplace la méthode {{jsxref("Object.prototype.toSource()")}}.</dd>
+ <dt>{{jsxref("String.prototype.toString()")}}</dt>
+ <dd>Renvoie une chaîne représentant l'objet spécifié. Remplace la méthode {{jsxref("Object.prototype.toString()")}}.</dd>
+ <dt>{{jsxref("String.prototype.toUpperCase()")}}</dt>
+ <dd>Renvoie la valeur de la chaîne appelante convertie en majuscules.</dd>
+ <dt>{{jsxref("String.prototype.trim()")}}</dt>
+ <dd>Retire les blancs en début et en fin de chaîne. Cette méthode a été définie avec ECMAScript 5.</dd>
+ <dt>{{jsxref("String.prototype.trimStart()")}}<br>
+ {{jsxref("String.prototype.trimLeft()")}}</dt>
+ <dd>Retire les blancs situés au début de la chaîne.</dd>
+ <dt>{{jsxref("String.prototype.trimEnd()")}}<br>
+ {{jsxref("String.prototype.trimRight()")}}</dt>
+ <dd>Retire les blancs situés à la fin de la chaîne.</dd>
+ <dt>{{jsxref("String.prototype.valueOf()")}}</dt>
+ <dd>Renvoie la valeur primitive de l'objet spécifié. Remplace la méthode {{jsxref("Object.prototype.valueOf()")}}.</dd>
+ <dt>{{jsxref("String.prototype.@@iterator()","String.prototype[@@iterator]()")}}</dt>
+ <dd>Renvoie un nouvel objet <code>Iterator</code> qui permet d'itérer sur les codets de la chaîne, chaque codet étant renvoyé comme une chaîne.</dd>
+</dl>
+
+<h3 id="Méthodes_de_transformation_HTML">Méthodes de transformation HTML</h3>
+
+<p>Ces méthodes ont une utilisation limitée, étant donné qu'elles ne fournissent qu'un petit sous-ensemble des balises et attributs HTML existants.</p>
+
+<dl>
+ <dt>{{jsxref("String.prototype.anchor()")}} {{deprecated_inline}}</dt>
+ <dd>{{htmlattrxref("name", "a", "&lt;a name=\"name\"&gt;")}} (cible hypertexte)</dd>
+ <dt>{{jsxref("String.prototype.big()")}} {{deprecated_inline}}</dt>
+ <dd>{{HTMLElement("big")}}</dd>
+ <dt>{{jsxref("String.prototype.blink()")}} {{deprecated_inline}}</dt>
+ <dd>{{HTMLElement("blink")}}</dd>
+ <dt>{{jsxref("String.prototype.bold()")}} {{deprecated_inline}}</dt>
+ <dd>{{HTMLElement("b")}}</dd>
+ <dt>{{jsxref("String.prototype.fixed()")}} {{deprecated_inline}}</dt>
+ <dd>{{HTMLElement("tt")}}</dd>
+ <dt>{{jsxref("String.prototype.fontcolor()")}} {{deprecated_inline}}</dt>
+ <dd>{{htmlattrxref("color", "font", "&lt;font color=\"color\"&gt;")}}</dd>
+ <dt>{{jsxref("String.prototype.fontsize()")}} {{deprecated_inline}}</dt>
+ <dd>{{htmlattrxref("size", "font", "&lt;font size=\"size\"&gt;")}}</dd>
+ <dt>{{jsxref("String.prototype.italics()")}} {{deprecated_inline}}</dt>
+ <dd>{{HTMLElement("i")}}</dd>
+ <dt>{{jsxref("String.prototype.link()")}} {{deprecated_inline}}</dt>
+ <dd>{{htmlattrxref("href", "a", "&lt;a href=\"url\"&gt;")}} (lien vers une URL)</dd>
+ <dt>{{jsxref("String.prototype.small()")}} {{deprecated_inline}}</dt>
+ <dd>{{HTMLElement("small")}}</dd>
+ <dt>{{jsxref("String.prototype.strike()")}} {{deprecated_inline}}</dt>
+ <dd>{{HTMLElement("strike")}}</dd>
+ <dt>{{jsxref("String.prototype.sub()")}} {{deprecated_inline}}</dt>
+ <dd>{{HTMLElement("sub")}}</dd>
+ <dt>{{jsxref("String.prototype.sup()")}} {{deprecated_inline}}</dt>
+ <dd>{{HTMLElement("sup")}}</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5.3.1', 'String.prototype')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype', 'String.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype', 'String.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p>
+
+<p>{{Compat("javascript.builtins.String.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("String")}}</li>
+ <li>{{jsxref("Function.prototype")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/symbol/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/symbol/index.html
new file mode 100644
index 0000000000..9f3c6f0703
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/symbol/index.html
@@ -0,0 +1,75 @@
+---
+title: Symbol.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/Symbol/prototype
+tags:
+  - ECMAScript6
+  - JavaScript
+  - Propriété
+  - Reference
+  - Symbol
+translation_of: Web/JavaScript/Reference/Global_Objects/Symbol
+translation_of_original: Web/JavaScript/Reference/Global_Objects/Symbol/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>Symbol</strong></code><strong><code>.prototype</code></strong> représente le prototype du constructeur {{jsxref("Symbol")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/symbol-prototype.html")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<h2 id="Description">Description</h2>
+
+<p>Les instances de {{jsxref("Symbol")}} héritent toutes de {{jsxref("Symbol.prototype")}}. Ce prototype du constructeur peut être utilisé afin d'ajouter des propriétés et/ou des méthodes pour chaque instance de <code>Symbol</code> via la chaîne de prototypes.</p>
+
+<p>{{js_property_attributes(0,0,0)}}</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>Symbol.prototype.constructor</code></dt>
+ <dd>Cette propriété correspond à la fonction qui a crée l'instance du prototype. Par défaut, c'est la fonction {{jsxref("Symbol")}} qui est renvoyée.</dd>
+ <dt>{{jsxref("Symbol.prototype.description")}}</dt>
+ <dd>Une chaîne de caractères en lecture seule qui contient la description du symbole.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("Symbol.prototype.toSource()")}} {{Non-standard_inline}}</dt>
+ <dd>Cette méthode renvoie une chaîne de caractères contenant la source de l'objet {{jsxref("Objets_globaux/Symbol", "Symbol")}}. Cette méthode surcharge la méthode {{jsxref("Object.prototype.toSource()")}}.</dd>
+ <dt>{{jsxref("Symbol.prototype.toString()")}}</dt>
+ <dd>Cette méthode renvoie une chaîne de caractères contenant la description du symbole. Cette méthode surcharge la méthode {{jsxref("Object.prototype.toString()")}}.</dd>
+ <dt>{{jsxref("Symbol.prototype.valueOf()")}}</dt>
+ <dd>Cette méthode renvoie la valeur primitive de l'objet {{jsxref("Symbol")}}. Cette méthode surcharge la méthode {{jsxref("Object.prototype.valueOf()")}}.</dd>
+ <dt>{{jsxref("Symbol.prototype.@@toPrimitive()", "Symbol.prototype[@@toPrimitive]")}}</dt>
+ <dd>Renvoie la valeur primitive de l'objet {{jsxref("Symbol")}}.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-symbol.prototype', 'Symbol.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-symbol.prototype', 'Symbol.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.Symbol.prototype")}}</p>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/syntaxerror/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/syntaxerror/index.html
new file mode 100644
index 0000000000..7407f68670
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/syntaxerror/index.html
@@ -0,0 +1,90 @@
+---
+title: SyntaxError.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/SyntaxError/prototype
+tags:
+  - Error
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+  - SyntaxError
+translation_of: Web/JavaScript/Reference/Global_Objects/SyntaxError
+translation_of_original: Web/JavaScript/Reference/Global_Objects/SyntaxError/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>SyntaxError.prototype</strong></code> représente le prototype du constructeur {{jsxref("SyntaxError")}}.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>Toutes les instances de {{jsxref("SyntaxError")}} héritent de <code>SyntaxError.prototype</code>. Le prototype peut être utilisé afin d'ajouter des propriétés ou des méthodes à toutes les instances.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>SyntaxError.prototype.constructor</code></dt>
+ <dd>Définit la fonction qui a créé le prototype d'une instance.</dd>
+ <dt>{{jsxref("Error.prototype.message", "SyntaxError.prototype.message")}}</dt>
+ <dd>Un message d'erreur. Bien que ECMA-262 définisse que {{jsxref("SyntaxError")}} doit avoir une propriété <code>message</code> en propre, dans <a href="/fr/docs/SpiderMonkey">SpiderMonkey</a>, elle est héritée depuis {{jsxref("Error.prototype.message")}}.</dd>
+ <dt>{{jsxref("Error.prototype.name", "SyntaxError.prototype.name")}}</dt>
+ <dd>Un nom d'erreur. Propriété héritée depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.fileName", "SyntaxError.prototype.fileName")}}</dt>
+ <dd>Le chemin du fichier qui a causé l'erreur. Propriété héritée depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.lineNumber", "SyntaxError.prototype.lineNumber")}}</dt>
+ <dd>Le numéro de la ligne du fichier qui a causé l'erreur. Propriété héritée depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.columnNumber", "SyntaxError.prototype.columnNumber")}}</dt>
+ <dd>Le numéro de la colonne dans la ligne qui a causé l'erreur. Propriété héritée depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.stack", "SyntaxError.prototype.stack")}}</dt>
+ <dd>La pile d'appels (<em>stack trace</em>). Propriété héritée depuis {{jsxref("Error")}}.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<p>Bien que le prototype de {{jsxref("SyntaxError")}} ne possède pas de méthodes directes, les instances de {{jsxref("SyntaxError")}} héritent de certaines méthodes via la chaîne de prototypes.</p>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">Statut</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Définie comme <code><em>NativeError</em>.prototype</code>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Définie comme <code><em>NativeError</em>.prototype</code>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Définie comme <code><em>NativeError</em>.prototype</code>.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div>
+<div class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.SyntaxError")}}</p>
+</div>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype")}}</li>
+ <li>{{jsxref("Function.prototype")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/typedarray/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/typedarray/index.html
new file mode 100644
index 0000000000..85c7f14222
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/typedarray/index.html
@@ -0,0 +1,132 @@
+---
+title: TypedArray.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/TypedArray/prototype
+tags:
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+  - TypedArray
+translation_of: Web/JavaScript/Reference/Global_Objects/TypedArray
+translation_of_original: Web/JavaScript/Reference/Global_Objects/TypedArray/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>TypedArray</strong></code><strong><code>.prototype</code></strong> représente le prototype des constructeurs {{jsxref("TypedArray")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Les instances de {{jsxref("TypedArray")}} héritent de {{jsxref("TypedArray.prototype")}}. Le prototype du constructeur peut être utilisé pour ajouter des propriétés et/ou des méthodes à toutes les instances de <em>TypedArray</em> (où <em>TypedArray</em> correspond à un des <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray#Les_objets_TypedArray">types de tableaux typés</a>).</p>
+
+<p>Pour plus de détails sur le fonctionnement de l'héritage, voir la page sur <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray#Description"><em>TypedArray</em></a>.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>TypedArray.prototype.constructor</code></dt>
+ <dd>Cette propriété renvoie la fonction qui a créé le prototype de l'instance. Elle correspondra à l'une des fonctions par défaut pour le <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray#Les_objets_TypedArray">type du tableau typé</a> utilisé.</dd>
+ <dt>{{jsxref("TypedArray.prototype.buffer")}} {{readonlyInline}}</dt>
+ <dd>Cette propriété renvoie l'{{jsxref("ArrayBuffer")}} qui est référencé par le tableau typé. Cette propriété est définie lors de la construction et est donc accessible en <strong>lecture seule</strong> uniquement.</dd>
+ <dt>{{jsxref("TypedArray.prototype.byteLength")}} {{readonlyInline}}</dt>
+ <dd>Cette propriété renvoie la longueur (exprimée en octets) du tableau typé, à partir du début de l'{{jsxref("ArrayBuffer")}}. Cette propriété est définie lors de la construction et est donc accessible en <strong>lecture seule</strong> uniquement<strong>.</strong></dd>
+ <dt>{{jsxref("TypedArray.prototype.byteOffset")}} {{readonlyInline}}</dt>
+ <dd>Cette propriété renvoie le décalage utilisé (exprimé en octets) entre le début du tableau typé et le début du {{jsxref("ArrayBuffer")}}. Cette propriété est définie lors de la construction et est donc accessible en <strong>lecture seule</strong> uniquement<strong>.</strong></dd>
+ <dt>{{jsxref("TypedArray.prototype.length")}} {{readonlyInline}}</dt>
+ <dd>Cette propriété renvoie le nombre d'éléments contenus dans le tableau typé. Cette propriété est définie lors de la construction et est donc accessible en <strong>lecture seule</strong> uniquement<strong>.</strong></dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("TypedArray.prototype.copyWithin()")}}</dt>
+ <dd>Copie une suite d'éléments au sein du tableau typé. Voir aussi {{jsxref("Array.prototype.copyWithin()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.entries()")}}</dt>
+ <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les clés/valeurs pour chaque indice du tableau. Voir aussi {{jsxref("Array.prototype.entries()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.every()")}}</dt>
+ <dd>Teste si tous les éléments du tableau typé respectent une condition donnée sous la forme d'une fonction. Voir aussi {{jsxref("Array.prototype.every()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.fill()")}}</dt>
+ <dd>Affecte une même valeur statique aux éléments du tableau typé entre un indice de début et un indice de fin. Voir aussi {{jsxref("Array.prototype.fill()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.filter()")}}</dt>
+ <dd>Crée un nouveau tableau typé dont les éléments proviennent d'un tableau typé qu'on a filtré avec une fonction. Voir aussi {{jsxref("Array.prototype.filter()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.find()")}}</dt>
+ <dd>Renvoie la valeur trouvée dans le tableau typé si un élément du tableau typé respecte une condition définie par une fonction. Si aucun élément n'est trouvé, {{jsxref("undefined")}} sera renvoyé. Voir aussi {{jsxref("Array.prototype.find()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.findIndex()")}}</dt>
+ <dd>Renvoie l'indice de l'élément trouvé si un élément du tableau typé respecte une condition définie par une fonction. Si aucun élément n'est trouvé, -1 sera renvoyé. Voir aussi {{jsxref("Array.prototype.findIndex()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.forEach()")}}</dt>
+ <dd>Appelle une fonction pour chaque élément du tableau typé. Voir aussi {{jsxref("Array.prototype.forEach()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.includes()")}}</dt>
+ <dd>Détermine si un élément est contenu dans un tableau typé et renvoie <code>true</code> ou <code>false</code> selon le cas de figure. Voir aussi {{jsxref("Array.prototype.includes()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.indexOf()")}}</dt>
+ <dd>Renvoie le premier indice (le plus petit) d'un élément du tableau typé qui a la valeur fournie en argument. Si aucun élément n'est trouvé, la valeur -1 sera renvoyée. Voir aussi {{jsxref("Array.prototype.indexOf()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.join()")}}</dt>
+ <dd>Fusionne l'ensemble des éléments du tableau typé en une chaîne de caractères. Voir aussi {{jsxref("Array.prototype.join()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.keys()")}}</dt>
+ <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les clés pour chaque élément du tableau. Voir aussi {{jsxref("Array.prototype.keys()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.lastIndexOf()")}}</dt>
+ <dd>Renvoie le dernier indice (le plus grand) d'un élément du tableau typé qui a la valeur fournie en argument. Si aucun élément n'est trouvé, -1 sera renvoyé. Voir aussi {{jsxref("Array.prototype.lastIndexOf()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.map()")}}</dt>
+ <dd>Crée un nouveau tableau typé dont les éléments sont les images des éléments du tableau typé courant par une fonction donnée. Voir aussi  {{jsxref("Array.prototype.map()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt>
+ <dd>Ancienne version, non-standard, de {{jsxref("TypedArray.prototype.copyWithin()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.reduce()")}}</dt>
+ <dd>Applique une fonction par rapport à un accumulateur pour chaque valeur du tableau (de gauche à droite) afin de réduire le tableau typé à une seule valeur. Voir aussi {{jsxref("Array.prototype.reduce()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.reduceRight()")}}</dt>
+ <dd>Applique une fonction par rapport à un accumulateur pour chaque valeur du tableau (de droite à gauche) afin de réduire le tableau typé à une seule valeur. Voir aussi {{jsxref("Array.prototype.reduceRight()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.reverse()")}}</dt>
+ <dd>Inverse l'ordre des éléments du tableau typé (le premier devient le dernier, le dernier devient le premier et ainsi de suite). Voir aussi {{jsxref("Array.prototype.reverse()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.set()")}}</dt>
+ <dd>Cette méthode permet d'enregistrer plusieurs valeurs dans le tableau typé à partir d'un tableau donné.</dd>
+ <dt>{{jsxref("TypedArray.prototype.slice()")}}</dt>
+ <dd>Extrait un fragment du tableau typé et renvoie ce fragment sous forme d'un tableau typé. Voir aussi {{jsxref("Array.prototype.slice()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.some()")}}</dt>
+ <dd>Renvoie <code>true</code> si au moins un élément du tableau typé respecte une condition définie par une fonction passée en argument. Voir aussi {{jsxref("Array.prototype.some()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.sort()")}}</dt>
+ <dd>Trie les éléments du tableau typé sur place et renvoie le tableau typé. Voir aussi {{jsxref("Array.prototype.sort()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.subarray()")}}</dt>
+ <dd>Cette méthode renvoie un nouvel objet <code>TypedArray</code> en fonction d'un indice de début et de fin.</dd>
+ <dt>{{jsxref("TypedArray.prototype.values()")}}</dt>
+ <dd>Renvoie un nouvel objet <code>Array Iterator</code> qui contient les valeurs pour chaque indice du tableau typé. Voir aussi {{jsxref("Array.prototype.values()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.toLocaleString()")}}</dt>
+ <dd>Renvoie une chaîne de caractères localisée qui représente le tableau typé et ses éléments. Voir aussi {{jsxref("Array.prototype.toLocaleString()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.toString()")}}</dt>
+ <dd>Renvoie une chaîne de caractères représentant le tableau typé et ses éléments. Voir aussi {{jsxref("Array.prototype.toString()")}}.</dd>
+ <dt>{{jsxref("TypedArray.prototype.@@iterator()", "TypedArray.prototype[@@iterator]()")}}</dt>
+ <dd>Renvoie un nouvel objet <code>Array Iterator</code> contenant les valeurs pour chaque indice du tableau typé.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">Statut</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-properties-of-the-%typedarrayprototype%-object', 'TypedArray prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-properties-of-the-%typedarrayprototype%-object', 'TypedArray prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.TypedArray.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li><a href="/fr/docs/Web/JavaScript/Tableaux_typés">Les tableaux typés en JavaScript</a></li>
+ <li>{{jsxref("TypedArray")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/typeerror/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/typeerror/index.html
new file mode 100644
index 0000000000..041451e11c
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/typeerror/index.html
@@ -0,0 +1,90 @@
+---
+title: TypeError.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/TypeError/prototype
+tags:
+  - Error
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+  - TypeError
+translation_of: Web/JavaScript/Reference/Global_Objects/TypeError
+translation_of_original: Web/JavaScript/Reference/Global_Objects/TypeError/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>TypeError.prototype</strong></code> représente le prototype du constructeur {{jsxref("TypeError")}}.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>Toutes les instances de {{jsxref("TypeError")}} héritent de <code>TypeError.prototype</code>. Le prototype peut être utilisé afin d'ajouter des propriétés ou des méthodes à l'ensemble des instances.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>TypeError.prototype.constructor</code></dt>
+ <dd>Définit la fonction qui crée le prototype d'une instance.</dd>
+ <dt>{{jsxref("Error.prototype.message", "TypeError.prototype.message")}}</dt>
+ <dd>Un message d'erreur. Bien que la spécification ECMA-262 définisse que {{jsxref("TypeError")}} doive fournir une propriété directe pour <code>message</code>, <a href="/fr/docs/SpiderMonkey">SpiderMonkey</a> la fait hériter de {{jsxref("Error.prototype.message")}}.</dd>
+ <dt>{{jsxref("Error.prototype.name", "TypeError.prototype.name")}}</dt>
+ <dd>Nom pour l'erreur, hérité depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.fileName", "TypeError.prototype.fileName")}}</dt>
+ <dd>Le chemin vers le fichier qui a causé l'erreur. Hérité depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.lineNumber", "TypeError.prototype.lineNumber")}}</dt>
+ <dd>La ligne du fichier qui a causé l'erreur. Hérité depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.columnNumber", "TypeError.prototype.columnNumber")}}</dt>
+ <dd>La colonne (la position dans la ligne) du fichier qui a causé l'erreur. Hérité depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.stack", "TypeError.prototype.stack")}}</dt>
+ <dd>La pile d'appels (<em>stack trace</em>). Héritée depuis {{jsxref("Error")}}.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<p>Bien que l'objet prototype pour {{jsxref("TypeError")}} ne contienne aucune méthode propre (qui lui soit directement rattachée), {{jsxref("TypeError")}} hérite de certaines méthodes grâce à la chaîne de prototypes.</p>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">Statut</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3', '#sec-15.11.7.6', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Définie comme <code><em>NativeError</em>.prototype</code>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Définie comme <code><em>NativeError</em>.prototype</code>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Définie comme <code><em>NativeError</em>.prototype</code>.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div>
+<div class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.TypeError")}}</p>
+</div>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype")}}</li>
+ <li>{{jsxref("Function.prototype")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/urierror/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/urierror/index.html
new file mode 100644
index 0000000000..4c45a4af6b
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/urierror/index.html
@@ -0,0 +1,90 @@
+---
+title: URIError.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/URIError/prototype
+tags:
+  - Error
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+  - URIError
+translation_of: Web/JavaScript/Reference/Global_Objects/URIError
+translation_of_original: Web/JavaScript/Reference/Global_Objects/URIError/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>URIError.prototype</strong></code> représente le prototype du constructeur {{jsxref("URIError")}}.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>Toutes les instances de {{jsxref("URIError")}} héritent de <code>URIError.prototype</code>. Ce prototype peut être utilisé pour ajouter des propriétés et/ou des méthodes à l'ensemble des instances.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>URIError.prototype.constructor</code></dt>
+ <dd>Cette propriété définit la fonction qui a créé le prototype de l'instance.</dd>
+ <dt>{{jsxref("Error.prototype.message", "URIError.prototype.message")}}</dt>
+ <dd>Un message décrivant l'erreur. Bien qu'ECMA-262 spécifie qu'{{jsxref("URIError")}} devrait avoir une propriété <code>message</code> en propre, <a href="/fr/docs/SpiderMonkey">SpiderMonkey</a> lui fait hériter de {{jsxref("Error.prototype.message")}}.</dd>
+ <dt>{{jsxref("Error.prototype.name", "URIError.prototype.name")}}</dt>
+ <dd>Un nom d'erreur. Héritée depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.fileName", "URIError.prototype.fileName")}}</dt>
+ <dd>Le chemin vers le fichier qui a causé l'erreur. Héritée depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.lineNumber", "URIError.prototype.lineNumber")}}</dt>
+ <dd>Le numéro de la ligne dans le fichier qui a causé l'erreur. Héritée depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.columnNumber", "URIError.prototype.columnNumber")}}</dt>
+ <dd>Le numéro de colonne (la position dans la ligne) dans le fichier qui a causé l'erreur. Héritée depuis {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.stack", "URIError.prototype.stack")}}</dt>
+ <dd>La pile d'appels ayant mené à l'erreur (<em>stack trace</em>). Héritée de {{jsxref("Error")}}.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<p>Bien que l'objet prototype pour {{jsxref("URIError")}} ne contienne pas de méthode qui lui soit directement rattachée, les instances d'{{jsxref("URIError")}} héritent de certaines méthodes grâce à la chaîne de prototypes.</p>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">Statut</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3', '#sec-15.11.7.6', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Définie comme <code><em>NativeError</em>.prototype</code>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Définie comme <code><em>NativeError</em>.prototype</code>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Définie comme <code><em>NativeError</em>.prototype</code>.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div>
+<div class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.URIError")}}</p>
+</div>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype")}}</li>
+ <li>{{jsxref("Function.prototype")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/weakmap/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/weakmap/index.html
new file mode 100644
index 0000000000..7ca2bf02d1
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/weakmap/index.html
@@ -0,0 +1,82 @@
+---
+title: WeakMap.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/WeakMap/prototype
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Propriété
+  - Reference
+  - WeakMap
+translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap
+translation_of_original: Web/JavaScript/Reference/Global_Objects/WeakMap/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>WeakMap</strong></code><strong><code>.prototype</code></strong> représente le prototype du constructeur {{jsxref("WeakMap")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Les instances de {{jsxref("WeakMap")}} héritent de {{jsxref("WeakMap.prototype")}}. L'objet prototype du constructeur peut donc être utilisé pour ajouter des propriétés et/ou des méthodes pour toutes les instances de <code>WeakMap</code>.</p>
+
+<p>WeakMap.prototype est un objet ordinaire :</p>
+
+<pre class="brush: js">Object.prototype.toString.call(WeakMap.prototype); // "[object Object]"
+</pre>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>WeakMap.prototype.constructor</code></dt>
+ <dd>Renvoie la fonction qui a créé le prototype de l'instance. Par défaut, ce sera la fonction {{jsxref("WeakMap")}}.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("WeakMap.delete", "WeakMap.prototype.delete(clé)")}}</dt>
+ <dd>Retire la valeur associée à la clé <code>clé.</code> <code>WeakMap.prototype.has(clé)</code> renverra <code>false</code> une fois la valeur supprimée.</dd>
+ <dt>{{jsxref("WeakMap.get", "WeakMap.prototype.get(clé)")}}</dt>
+ <dd>Renvoie la valeur associée à la <code>clé</code>, ou <code>undefined</code> s'il n'y en a pas.</dd>
+ <dt>{{jsxref("WeakMap.has", "WeakMap.prototype.has(clé)")}}</dt>
+ <dd>Renvoie un booléen qui indique s'il existe ou non une valeur associée à une <code>clé</code> donnée pour l'objet <code>WeakMap</code>.</dd>
+ <dt>{{jsxref("WeakMap.set", "WeakMap.prototype.set(clé, valeur)")}}</dt>
+ <dd>Définit la valeur associée à la <code>clé</code> dans l'objet <code>WeakMap</code>. La méthode renvoie l'objet<code> WeakMap</code>.</dd>
+ <dt><s class="obsoleteElement">{{jsxref("WeakMap.prototype.clear()")}}</s> {{obsolete_inline}}</dt>
+ <dd><s class="obsoleteElement">Retire toutes les paires de clés/valeurs contenues dans l'objet <code>WeakMap</code>. Il est possible de construire un objet semblable à <code>WeakMap</code> qui possède une méthode <code>clear()</code> en encapsulant (cf. l'exemple sur la page {{jsxref("WeakMap")}}).</s></dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-weakmap.prototype', 'WeakMap.prototype')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-weakmap.prototype', 'WeakMap.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.WeakMap.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Map.prototype")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/weakset/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/weakset/index.html
new file mode 100644
index 0000000000..092f97b6c3
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/weakset/index.html
@@ -0,0 +1,80 @@
+---
+title: WeakSet.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/WeakSet/prototype
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Propriété
+  - Reference
+  - WeakSet
+translation_of: Web/JavaScript/Reference/Global_Objects/WeakSet
+translation_of_original: Web/JavaScript/Reference/Global_Objects/WeakSet/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>WeakSet</strong></code><strong><code>.prototype</code></strong> représente le prototype du constructeur {{jsxref("WeakSet")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Toutes les instances de {{jsxref("WeakSet")}} héritent de {{jsxref("WeakSet.prototype")}}. Le prototype du constructeur peut être utilisé pour ajouter des méthodes et/ou des propriétés à toutes les instances de <code>WeakSet</code>.</p>
+
+<p>WeakSet.prototype est un objet ordinaire :</p>
+
+<pre class="brush: js">Object.prototype.toString.call(WeakSet.prototype); // "[object Object]"</pre>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>WeakSet.prototype.constructor</code></dt>
+ <dd>Cette propriété renvoie la fonction qui a créé le prototype de l'instance. Par défaut, ce sera la fonction native {{jsxref("WeakSet")}}.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt>{{jsxref("WeakSet.add", "WeakSet.prototype.add(valeur)")}}</dt>
+ <dd>Cette méthode permet d'ajouter une nouvel objet avec une valeur donnée à l'objet <code>WeakSet</code>.</dd>
+ <dt>{{jsxref("WeakSet.delete", "WeakSet.prototype.delete(valeur)")}}</dt>
+ <dd>Cette méthode retire l'élément associé à <code>valeur</code>. <code>WeakSet.prototype.has(valeur)</code> renverra <code>false</code> une fois l'opération effectuée.</dd>
+ <dt>{{jsxref("WeakSet.has", "WeakSet.prototype.has(valeur)")}}</dt>
+ <dd>Cette méthode renvoie un booléen indiquant si oui ou non un élément est présent avec cette valeur au sein de l'objet <code>WeakSet</code>.</dd>
+ <dt><s class="obsoleteElement">{{jsxref("WeakSet.prototype.clear()")}}{{obsolete_inline}}</s></dt>
+ <dd><s class="obsoleteElement">Cette méthode retire tous les éléments de l'ensemble <code>WeakSet</code>.</s></dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-weakset.prototype', 'WeakSet.prototype')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-weakset.prototype', 'WeakSet.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.WeakSet.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Set.prototype")}}</li>
+ <li>{{jsxref("WeakMap.prototype")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/webassembly/global/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/webassembly/global/index.html
new file mode 100644
index 0000000000..fabce82ac1
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/webassembly/global/index.html
@@ -0,0 +1,69 @@
+---
+title: WebAssembly.Global.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Global/prototype
+tags:
+  - JavaScript
+  - Propriété
+  - Prototype
+  - WebAssembly
+translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Global
+translation_of_original: Web/JavaScript/Reference/Global_Objects/WebAssembly/Global/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>WebAssembly.Global</strong></code><strong><code>.prototype</code></strong> représente le prototype du constructeur {{jsxref("WebAssembly.Global()")}}.</p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Toutes les instances de {{jsxref("WebAssembly.Global")}} héritent de <code>Global.prototype</code>. L'objet prototype du constructeur {{jsxref("WebAssembly.Global()")}} peut être modifié afin d'avoir un impact sur l'ensemble des instances {{jsxref( "WebAssembly.Global")}}.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>Global.prototype.constructor</code></dt>
+ <dd>Cette propriété renvoie la fonction qui a créé l'instance de l'objet. Par défaut, c'est le constructeur {{jsxref("WebAssembly.Global()")}}.</dd>
+ <dt><code>Global.prototype[@@toStringTag]</code></dt>
+ <dd>La valeur initiale de la propriété <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Symbol/toStringTag">@@toStringTag</a></code> est la chaîne de caractères <code>"WebAssembly.Global"</code>.</dd>
+ <dt><code>Global.prototype.value</code></dt>
+ <dd>La valeur contenue à l'intérieur de la variable globale. Cette propriété peut être utilisée afin de modifier et d'accéder à la valeur globale.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<dl>
+ <dt><code>Global.prototype.valueOf()</code></dt>
+ <dd>Une méthode qui renvoie la valeur contenue dans la variable globale.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('WebAssembly JS', '#globals', 'WebAssembly.Global()')}}</td>
+   <td>{{Spec2('WebAssembly JS')}}</td>
+   <td>Brouillon pour la définition initiale.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.WebAssembly.Global.prototype")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("WebAssembly.Global()")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/webassembly/instance/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/webassembly/instance/index.html
new file mode 100644
index 0000000000..504c57504a
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/webassembly/instance/index.html
@@ -0,0 +1,71 @@
+---
+title: WebAssembly.Instance.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Instance/prototype
+tags:
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+  - WebAssembly
+  - instance
+translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance
+translation_of_original: Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance/prototype
+---
+<div>{{JSRef}} {{SeeCompatTable}}</div>
+
+<p>La propriété <code><strong>WebAssembly.Instance</strong></code><strong><code>.prototype</code></strong> représente le prototype du constructeur {{jsxref("WebAssembly.Instance()")}}.</p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Toutes les instances de {{jsxref("WebAssembly.Instance")}} héritent de <code>Instance.prototype</code>. L'objet qui est le prototype du constructeur {{jsxref("WebAssembly.Instance()")}} permet de modifier l'ensemble des instances {{jsxref( "WebAssembly.Instance")}} à travers la chaîne des prototypes.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>Instance.prototype.constructor</code></dt>
+ <dd>Renvoie la fonction qui a créé l'instance de l'objet. Par défaut, c'est le constructeur {{jsxref("WebAssembly.Instance()")}}.</dd>
+ <dt><code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/WebAssembly/Instance/exports">Instance.prototype.exports</a></code> {{readonlyinline}}</dt>
+ <dd>Renvoie un objet dont les propriétés sont l'ensemble des fonctions exportées depuis l'instance du module WebAssembly. Cela permet d'y accéder et de les manipuler depuis du code JavaScript.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<p>Aucune.</p>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('WebAssembly JS', '#webassemblymodule-objects', 'WebAssembly.Module()')}}</td>
+   <td>{{Spec2('WebAssembly JS')}}</td>
+   <td>Brouillon de définition initiale pour WebAssembly.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div>
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.WebAssembly.Instance.prototype")}}</p>
+</div>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("WebAssembly.Instance()")}}</li>
+ <li><a href="/fr/docs/WebAssembly">Le portail WebAssembly</a></li>
+ <li><a href="/fr/docs/WebAssembly/Concepts">Les concepts relatifs à WebAssembly</a></li>
+ <li><a href="/fr/docs/WebAssembly/Using_the_JavaScript_API">Utiliser l'API JavaScript WebAssembly</a></li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/webassembly/memory/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/webassembly/memory/index.html
new file mode 100644
index 0000000000..32b16d8969
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/webassembly/memory/index.html
@@ -0,0 +1,72 @@
+---
+title: WebAssembly.Memory.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Memory/prototype
+tags:
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+  - WebAssembly
+  - memory
+translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory
+translation_of_original: Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/prototype
+---
+<div>{{JSRef}} {{SeeCompatTable}}</div>
+
+<p>La propriété <code><strong>WebAssembly.Memory</strong></code><strong><code>.prototype</code></strong> représente le prototype du constructeur {{jsxref("WebAssembly.Memory()")}}.</p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Toutes les instances de {{jsxref("WebAssembly.Memory")}} héritent de <code>Memory.prototype</code>. Le prototype du constructeur {{jsxref("WebAssembly.Memory()")}} peut être modifié afin de modifier le comportement de l'ensemble des instances de {{jsxref( "WebAssembly.Memory")}}.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>Memory.prototype.constructor</code></dt>
+ <dd>Renvoie la fonction qui a créé l'instance de l'objet. Par défaut, c'est le constructeur {{jsxref("WebAssembly.Memory()")}}.</dd>
+ <dt>{{jsxref("WebAssembly/Memory/buffer","Memory.prototype.buffer")}}</dt>
+ <dd>Une propriété d'accesseur qui renvoie le tampon contenu dans l'espace mémoire.</dd>
+ <dt>
+ <h2 id="Méthodes">Méthodes</h2>
+ </dt>
+ <dt>{{jsxref("WebAssembly/Memory/grow","Memory.prototype.grow()")}}</dt>
+ <dd>Cette méthode permet d'accroître la taille de l'espace mémoire en ajoutant un nombre de pages WebAssembly (dont chacune mesure 64 Ko).</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('WebAssembly JS', '#webassemblymemory-objects', 'Memory')}}</td>
+   <td>{{Spec2('WebAssembly JS')}}</td>
+   <td>Brouillon de définition initiale pour WebAssembly.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div>
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.WebAssembly.Memory.prototype")}}</p>
+</div>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("WebAssembly.Memory()")}}</li>
+ <li><a href="/fr/docs/WebAssembly">Le portail WebAssembly</a></li>
+ <li><a href="/fr/docs/WebAssembly/Concepts">Les concepts relatifs à WebAssembly</a></li>
+ <li><a href="/fr/docs/WebAssembly/Using_the_JavaScript_API">Utiliser l'API JavaScript WebAssembly</a></li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/webassembly/module/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/webassembly/module/index.html
new file mode 100644
index 0000000000..3ac694ae07
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/webassembly/module/index.html
@@ -0,0 +1,69 @@
+---
+title: WebAssembly.Module.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Module/prototype
+tags:
+  - Experimental
+  - JavaScript
+  - Module
+  - Propriété
+  - Prototype
+  - Reference
+  - WebAssembly
+translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module
+translation_of_original: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>La propriété <code><strong>WebAssembly.Module</strong></code><strong><code>.prototype</code></strong> représente le prototype du constructeur {{jsxref("WebAssembly.Module()")}}.</p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Toutes les instances de {{jsxref("WebAssembly.Module")}} héritent de <code>Module.prototype</code>. Le prototype du constructeur {{jsxref("WebAssembly.Module()")}} peut être modifié afin de modifier le comportement de toutes les instances de {{jsxref( "WebAssembly.Module")}}.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>Module.prototype.constructor</code></dt>
+ <dd>Renvoie la fonction qui a créé l'instance de l'objet. Par défaut, c'est le constructeur {{jsxref("WebAssembly.Module()")}}.</dd>
+ <dt><code>Module.prototype[@@toStringTag]</code></dt>
+ <dd>La valeur initiale de la propriété <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Symbol/toStringTag">@@toStringTag</a></code> est la chaîne de caractères <code>"WebAssembly.Module"</code>.</dd>
+</dl>
+
+<h2 id="Méthodes">Méthodes</h2>
+
+<p>Aucune.</p>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('WebAssembly JS', '#webassemblymodule-objects', 'WebAssembly.Module()')}}</td>
+   <td>{{Spec2('WebAssembly JS')}}</td>
+   <td>Brouillon de définition initiale pour WebAssembly.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div>
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.WebAssembly.Module.prototype")}}</p>
+</div>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("WebAssembly.Module()")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/global_objects/webassembly/table/index.html b/files/fr/conflicting/web/javascript/reference/global_objects/webassembly/table/index.html
new file mode 100644
index 0000000000..b9f2be5e36
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/global_objects/webassembly/table/index.html
@@ -0,0 +1,76 @@
+---
+title: WebAssembly.Table.prototype
+slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/prototype
+tags:
+  - Experimental
+  - JavaScript
+  - Propriété
+  - Prototype
+  - Reference
+  - WebAssembly
+translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table
+translation_of_original: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/prototype
+---
+<div>{{JSRef}} {{SeeCompatTable}}</div>
+
+<p>La propriété <code><strong>WebAssembly.Table</strong></code><strong><code>.prototype</code></strong> représente le prototype du constructeur {{jsxref("WebAssembly.Table()")}}.</p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Description">Description</h2>
+
+<p>Toutes les instances de {{jsxref("WebAssembly.Table")}} héritent de <code>Table.prototype</code>. Le prototype du constructeur {{jsxref("WebAssembly.Table()")}} peut être modifié afin de modifier le comportement de toutes les instances {{jsxref( "WebAssembly.Table")}}.</p>
+
+<h2 id="Propriétés">Propriétés</h2>
+
+<dl>
+ <dt><code>Table.prototype.constructor</code></dt>
+ <dd>Renvoie la fonction qui a créé l'instance de l'objet. Par défaut, c'est le constructeur {{jsxref("WebAssembly.Table()")}}.</dd>
+ <dt>{{jsxref("WebAssembly/Table/length","Table.prototype.length")}}</dt>
+ <dd>Renvoie la taille du tableau, c'est-à-dire le nombre de références enregistrées dans le tableau.</dd>
+ <dt>
+ <h2 id="Méthodes">Méthodes</h2>
+ </dt>
+ <dt>{{jsxref("WebAssembly/Table/get","Table.prototype.get()")}}</dt>
+ <dd>Une fonction accesseur qui permet d'obtenir une référence à partir d'une position dans le tableau.</dd>
+ <dt>{{jsxref("WebAssembly/Table/grow","Table.prototype.grow()")}}</dt>
+ <dd>Cette méthode permet d'augmenter la taille de l'instance de <code>Table</code> d'un nombre donné de référence.</dd>
+ <dt>{{jsxref("WebAssembly/Table/set","Table.prototype.set()")}}</dt>
+ <dd>Cette méthode permet de changer une référence située à une position donnée dans le tableau.</dd>
+</dl>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('WebAssembly JS', '#webassemblytable-objects', 'Table')}}</td>
+   <td>{{Spec2('WebAssembly JS')}}</td>
+   <td>Brouillon de définition initiale pour WebAssembly.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div>
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.builtins.WebAssembly.Table.prototype")}}</p>
+</div>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("WebAssembly.Table")}}</li>
+ <li><a href="/fr/docs/WebAssembly">Le portail WebAssembly</a></li>
+ <li><a href="/fr/docs/WebAssembly/Concepts">Les concepts relatifs à WebAssembly</a></li>
+ <li><a href="/fr/docs/WebAssembly/Using_the_JavaScript_API">Utiliser l'API JavaScript WebAssembly</a></li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/lexical_grammar/index.html b/files/fr/conflicting/web/javascript/reference/lexical_grammar/index.html
new file mode 100644
index 0000000000..dae1cd3126
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/lexical_grammar/index.html
@@ -0,0 +1,94 @@
+---
+title: Mots réservés
+slug: Web/JavaScript/Reference/Mots_réservés
+translation_of: Web/JavaScript/Reference/Lexical_grammar#Keywords
+translation_of_original: Web/JavaScript/Reference/Reserved_Words
+---
+<h3 id="Introduction">Introduction</h3>
+
+<p>Cet annexe présente les mots réservés. Les mots réservés ne doivent pas être utilisés en tant que noms de variables, de fonctions, de méthodes ou d'identifiants d'objets parce-que <a href="/fr/ECMAScript" title="fr/ECMAScript">ECMAScript</a> spécifie une utilité spéciale pour eux.</p>
+
+<h3 id="Mots_actuellement_réservés">Mots actuellement réservés</h3>
+
+<p>Voici la liste des mots réservés actuellement utilisés en JavaScript :</p>
+
+<ul>
+ <li><a href="/en/JavaScript/Reference/Statements/break" title="en/JavaScript/Reference/Statements/break">break</a></li>
+ <li><a href="/en/JavaScript/Reference/Statements/switch" title="en/JavaScript/Reference/Statements/switch">case</a></li>
+ <li><a href="/en/JavaScript/Reference/Statements/try...catch" title="en/JavaScript/Reference/Statements/try...catch">catch</a></li>
+ <li><a href="/en/JavaScript/Reference/Statements/continue" title="en/JavaScript/Reference/Statements/continue">continue</a></li>
+ <li><a href="/en/JavaScript/Reference/Statements/debugger" title="en/JavaScript/Reference/Statements/debugger">debugger</a></li>
+ <li><a href="/en/JavaScript/Reference/Statements/switch" title="en/JavaScript/Reference/Statements/switch">default</a></li>
+ <li><a href="/en/JavaScript/Reference/Operators/Special/delete" title="en/JavaScript/Reference/Operators/Special/delete">delete</a></li>
+ <li><a href="/en/JavaScript/Reference/Statements/do...while" title="en/JavaScript/Reference/Statements/do...while">do</a></li>
+ <li><a href="/en/JavaScript/Reference/Statements/if...else" title="en/JavaScript/Reference/Statements/if...else">else</a></li>
+ <li><a href="/en/JavaScript/Reference/Statements/try...catch" title="en/JavaScript/Reference/Statements/try...catch">finally</a></li>
+ <li><a href="/en/JavaScript/Reference/Statements/for" title="en/JavaScript/Reference/Statements/for">for</a></li>
+ <li><a href="/en/JavaScript/Reference/Statements/function" title="en/JavaScript/Reference/Statements/function">function</a></li>
+ <li><a href="/en/JavaScript/Reference/Statements/if...else" title="en/JavaScript/Reference/Statements/if...else">if</a></li>
+ <li><a href="/en/JavaScript/Reference/Statements/for...in" title="en/JavaScript/Reference/Statements/for...in">in</a></li>
+ <li><a href="/en/JavaScript/Reference/Operators/Special/instanceof" title="en/JavaScript/Reference/Operators/Special/instanceof">instanceof</a></li>
+ <li><a href="/en/JavaScript/Reference/Operators/Special/new" title="en/JavaScript/Reference/Operators/Special/new">new</a></li>
+ <li><a href="/en/JavaScript/Reference/Statements/return" title="en/JavaScript/Reference/Statements/return">return</a></li>
+ <li><a href="/en/JavaScript/Reference/Statements/switch" title="en/JavaScript/Reference/Statements/switch">switch</a></li>
+ <li><a href="/en/JavaScript/Reference/Operators/Special/this" title="en/JavaScript/Reference/Operators/Special/this">this</a></li>
+ <li><a href="/en/JavaScript/Reference/Statements/throw" title="en/JavaScript/Reference/Statements/throw">throw</a></li>
+ <li><a href="/en/JavaScript/Reference/Statements/try...catch" title="en/JavaScript/Reference/Statements/try...catch">try</a></li>
+ <li><a href="/en/JavaScript/Reference/Operators/Special/typeof" title="en/JavaScript/Reference/Operators/Special/typeof">typeof</a></li>
+ <li><a href="/en/JavaScript/Reference/Statements/var" title="en/JavaScript/Reference/Statements/var">var</a></li>
+ <li><a href="/en/JavaScript/Reference/Operators/Special/void" title="en/JavaScript/Reference/Operators/Special/void">void</a></li>
+ <li><a href="/en/JavaScript/Reference/Statements/while" title="en/JavaScript/Reference/Statements/while">while</a></li>
+ <li><a href="/en/JavaScript/Reference/Statements/with" title="en/JavaScript/Reference/Statements/with">with</a></li>
+</ul>
+
+<h3 id="Mots_réservés_dans_le_futur">Mots réservés dans le futur</h3>
+
+<p>Les mots suivants sont de futurs mots-clés réservés par la spécification ECMAScript. Bien qu'ils ne soient actuellement pas utilisés, ils ne peuvent pas servir d'identifiants d'objets car ils seront bientôt fonctionnels. (Notez que pour le moment, Mozilla réserve ces mots-clés seulement dans le code en mode strict. La plupart des autres navigateurs réservent ces mots-clés pour tout le code, qu'il soit strict ou non. Leur utilisation est souvent incompatbile entre les différents navigateurs. Mozilla réservera ces mots-clés à un code normal à l'avenir, pour correspondre aux spécifications des autres navigateurs).</p>
+
+<p>{{ gecko_minversion_header("2.1") }}</p>
+
+<div class="note"><strong>Note: </strong>En commençant avec Javascript 1.9 (Firefox 5), ces derniers seront réservés même lorsque vous n'êtes pas en mode strict.<br>
+<strong>Note: La version de JavaScript ci-dessus n'est pas officielle.</strong></div>
+
+<ul>
+ <li>class</li>
+ <li>enum</li>
+ <li><a href="/en/JavaScript/Reference/Statements/export" title="en/JavaScript/Reference/Statements/export">export</a></li>
+ <li>extends</li>
+ <li><a href="/en/JavaScript/Reference/Statements/import" title="en/JavaScript/Reference/Statements/import">import</a></li>
+ <li>super</li>
+</ul>
+
+<p>Les mots suivants sont de futurs mots-clés réservés par la spécification ECMAScript lorsqu'ils se situent dans de code en mode strict, excepté lorsque <code>let</code> et <code>yield</code> ont leurs fonctions traditionnelles dans le code compilé comme JavaScript 1.7 ou plus:</p>
+
+<ul>
+ <li>implements</li>
+ <li>interface</li>
+ <li><a href="/JavaScript/Reference/Statements/let" title="JavaScript/Reference/Statements/let">let</a></li>
+ <li>package</li>
+ <li>private</li>
+ <li>protected</li>
+ <li>public</li>
+ <li>static</li>
+ <li><a href="/en/JavaScript/Reference/Statements/yield" title="en/JavaScript/Reference/Statements/yield">yield</a></li>
+</ul>
+
+<p>Note that while <a href="/en/JavaScript/Reference/Statements/const" title="en/JavaScript/Reference/Statements/const">const</a> is reserved as a future keyword by the ECMAScript specification, Mozilla and most other browsers implement it as a non-standard extension that may be standardized in a future version of ECMAScript.  Further, <a href="/en/JavaScript/Reference/Statements/export" title="en/JavaScript/Reference/Statements/export">export</a> and <a href="/en/JavaScript/Reference/Statements/import" title="en/JavaScript/Reference/Statements/import">import</a> were once implemented in Mozilla but have returned to reserved status in recent releases.</p>
+
+<p>Additionally, the literals <code>null</code>, <code>true</code>, and <code>false</code> are reserved in ECMAScript for their normal uses.</p>
+
+<h2 id="Reserved_Word_Usage">Reserved Word Usage</h2>
+
+<p>Reserved Words actually only apply to Identifiers (vs. <span class="comment-copy">IdentifierNames) </span>. <span class="comment-copy">As described in <a href="http://es5.github.com/#A.1" rel="nofollow">es5.github.com/#A.1</a>, these are all IdentifierNames which do not exclude ReservedWords.</span></p>
+
+<p><span class="comment-copy"><code>a.import</code></span><br>
+ <span class="comment-copy"><code>a["import"]</code></span><br>
+ <span class="comment-copy"><code>a = { import: "test" }</code>.</span></p>
+
+<p><span class="comment-copy">On the other hand the following is illegal because it's an Identifier, which is an IdentifierName without the Reserved Words. Identifiers are used for FunctionDeclaration and FunctionExpression.</span></p>
+
+<p><span class="comment-copy"><code>function import() {}</code></span></p>
+
+<p> </p>
+
+<p>{{ languages( { "es": "es/Referencia_de_JavaScript_1.5/Palabras_Reservadas", "fr": "fr/R\u00e9f\u00e9rence_de_JavaScript_1.5_Core/Mots_r\u00e9serv\u00e9s", "ja": "ja/Core_JavaScript_1.5_Reference/Reserved_Words", "pl": "pl/Dokumentacja_j\u0119zyka_JavaScript_1.5/S\u0142owa_zarezerwowane" } ) }}</p>
diff --git a/files/fr/conflicting/web/javascript/reference/operators/index.html b/files/fr/conflicting/web/javascript/reference/operators/index.html
new file mode 100644
index 0000000000..d11d106a96
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/operators/index.html
@@ -0,0 +1,296 @@
+---
+title: Opérateurs arithmétiques
+slug: Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques
+tags:
+  - JavaScript
+  - Operator
+  - Reference
+translation_of: Web/JavaScript/Reference/Operators
+translation_of_original: Web/JavaScript/Reference/Operators/Arithmetic_Operators
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p><strong>Les opérateurs arithmétiques </strong>utilisent des valeurs numériques (variables ou littéraux) comme opérandes et renvoient une valeur numérique. Les opérateurs arithmétiques standard sont l'addition (+), la soustraction (-), la multiplication (*), et la division (/).</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-arithmetic.html")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<h2 id="Addition_2"><a name="Addition">Addition (+)</a></h2>
+
+<p>L'opérateur d'addition permet d'obtenir la somme des opérandes numériques ou bien la concaténation de chaînes de caractères.</p>
+
+<h3 id="Syntaxe">Syntaxe</h3>
+
+<pre class="syntaxbox">Opérateur : x + y</pre>
+
+<h3 id="Exemples">Exemples</h3>
+
+<pre class="brush: js">// nombre + nombre -&gt; addition
+1 + 2 // 3
+
+// booléen + nombre -&gt; addition
+true + 1 // 2
+
+// booléen + booléen -&gt; addition
+false + false // 0
+
+// nombre + chaîne de caractères -&gt; concaténation
+5 + "
+
+ concaténation
+"toto" + false // "totofalse"
+
+// chaîne de caractères + chaîne de caractères -&gt; concaténation
+"toto" + "truc" // "tototruc"
+</pre>
+
+<h2 id="Soustraction_-"><a name="Subtraction">Soustraction (-)</a></h2>
+
+<p>L'opérateur de soustraction soustrait les deux opérandes pour obtenir leur différence.</p>
+
+<h3 id="Syntaxe_2">Syntaxe</h3>
+
+<pre class="syntaxbox">Opérateur : x - y</pre>
+
+<h3 id="Exemples_2">Exemples</h3>
+
+<pre class="brush:js">5 - 3 // 2
+3 - 5 // -2
+"toto" - 3 // NaN
+</pre>
+
+<h2 id="Division_2"><a name="Division">Division (/)</a></h2>
+
+<p>L'opérateur de division produit le quotient de ces opérandes avec l'opérande gauche comme numérateur et l'opérande droit comme dénominateur.</p>
+
+<h3 id="Syntaxe_3">Syntaxe</h3>
+
+<pre class="syntaxbox">Opérateur : x / y</pre>
+
+<h3 id="Exemples_3">Exemples</h3>
+
+<pre class="brush: js">1 / 2      // renvoie 0.5 en JavaScript
+1 / 2      // renvoie 0 en Java
+// (aucun des deux opérandes n'est un nombre flottant de façon explicite)
+
+1.0 / 2.0  // renvoie 0.5 en JavaScript et Java
+
+2.0 / 0    // renvoie Infinity (pour l'infini) en JavaScript
+2.0 / 0.0  // renvoie Infinity également
+2.0 / -0.0 // renvoie -Infinity en JavaScript</pre>
+
+<h2 id="Multiplication_*"><a name="Multiplication">Multiplication (*)</a></h2>
+
+<p>L'opérateur de multiplication permet d'obtenir le produit des opérandes.</p>
+
+<h3 id="Syntaxe_4">Syntaxe</h3>
+
+<pre class="syntaxbox">Opérateur : x * y</pre>
+
+<h3 id="Exemples_4">Exemples</h3>
+
+<pre class="brush: js">2 * 2 // 4
+-2 * 2 // -4
+Infinity * 0 // NaN
+Infinity * Infinity // Infinity
+"toto" * 2 // NaN
+</pre>
+
+<h2 id="Reste"><a name="Remainder">Reste (%)</a></h2>
+
+<p>L'opérateur « reste » renvoie le reste de la division du premier opérande par le second. Le résultat obtenu a toujours le signe du numérateur (la quantité divisée).</p>
+
+<h3 id="Syntaxe_5">Syntaxe</h3>
+
+<pre class="syntaxbox">Opérateur : var1 % var2</pre>
+
+<h3 id="Exemples_5">Exemples</h3>
+
+<pre class="brush: js">12 % 5  // 2
+-1 % 2  // -1
+1 % -2  // 1
+NaN % 2 // NaN
+1 % 2   // 1
+2 % 3   // 2
+-4 % 2  // -0
+5.5 % 2 // 1.5</pre>
+
+<h2 id="Exponentiation_**"><a id="Exponentiation" name="Exponentiation">Exponentiation (**)</a></h2>
+
+<p>L'opérateur d'exponentiation (aussi appelé opérateur de puissance) renvoie le résultat de l'élévation d'un nombre (premier opérande) à une puissance donnée (deuxième opérande). Par exemple : <code>var1 ** var2</code> sera équivalent à <code>var1<sup>var2</sup></code> en notation mathématique. Cet opérateur est associatif à droite, autrement dit <code>a ** b ** c</code> est égal à <code>a ** (b ** c)</code>.</p>
+
+<h3 id="Syntaxe_6">Syntaxe</h3>
+
+<pre class="syntaxbox">Opérateur : var1 ** var2</pre>
+
+<h3 id="Notes">Notes</h3>
+
+<p>Dans la plupart des langages (par exemple PHP, Python, etc.), l'opérateur d'exponentiation est défini avec une précédence supérieure à celle des opérateurs unaires tels que le plus unaire et le moins unaire. Des exceptions existent comme Bash où l'opérateur ** a une précédence inférieure à celle des opérateurs unaires. En JavaScript, il est impossible d'écrire une expression ambigüe avec l'exponentiation : il est impossible de placer un opérateur unaire juste avant le nombre.</p>
+
+<pre class="brush: js">-2 ** 2;
+// vaut 4 en Bash ou -4 avec d'autres langages
+// C'est invalide en JavaScript car il y
+// une ambiguïté liée à l'expression
+
+- (2 ** 2);
+// -4 en JavaScript car les parenthèses lèvent
+// l'ambiguïté
+</pre>
+
+<h3 id="Exemples_6">Exemples</h3>
+
+<pre class="brush: js">2 ** 3 // 8
+3 ** 2 // 9
+3 ** 2.5 // 15.588457268119896
+10 ** -1 // 0.1
+NaN ** 2 // NaN
+
+2 ** 3 ** 2 // 512
+2 ** (3 ** 2) // 512
+(2 ** 3) ** 2 // 64</pre>
+
+<div class="note">
+<p><strong>Note :</strong> JavaScript possède également <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#(XOR_binaire)">un opérateur binaire ^ (XOR logique)</a>. <code>**</code> et <code>^</code> sont deux opérateurs bien différents. Par exemple <code>2 ** 3 === 8</code> et <code>2 ^ 3 === 1</code>.</p>
+</div>
+
+<h2 id="Incrément"><a name="Increment">Incrément (++)</a></h2>
+
+<p>L'opérateur d'incrément ajoute une unité à son opérande et renvoie une valeur.</p>
+
+<ul>
+ <li>Si l'opérateur est utilisé en suffixe (par exemple : x++), il renvoie la valeur avant l'incrémentation.</li>
+ <li>Si l'opérateur est utilisé en préfixe (par exemple : ++x), il renvoie la valeur après l'incrémentation.</li>
+</ul>
+
+<h3 id="Syntaxe_7">Syntaxe</h3>
+
+<pre class="syntaxbox">Opérateur : x++ ou ++x</pre>
+
+<h3 id="Exemples_7">Exemples</h3>
+
+<pre class="brush: js">// Suffixe
+var x = 3;
+y = x++; // y = 3, x = 4
+
+// Préfixe
+var a = 2;
+b = ++a; // a = 3, b = 3
+</pre>
+
+<h2 id="Décrément_--"><a name="Decrement">Décrément (--)</a></h2>
+
+<p>L'opérateur de décrément soustrait une unité à son opérande et renvoie une valeur.</p>
+
+<ul>
+ <li>Si l'opérateur est utilisé en suffixe (par exemple : x--), il renvoie la valeur avant la décrémentation.</li>
+ <li>Si l'opérateur est utilisé en préfixe (par exemple : --x), il renvoie la valeur après la décrémentation.</li>
+</ul>
+
+<h3 id="Syntaxe_8">Syntaxe</h3>
+
+<pre class="syntaxbox">Opérateur : x-- ou --x</pre>
+
+<h3 id="Exemples_8">Exemples</h3>
+
+<pre class="brush: js">// Suffixe
+var x = 3;
+y = x--; // y = 3, x = 2
+
+// Préfixe
+var a = 2;
+b = --a; // a = 1, b = 1
+</pre>
+
+<h2 id="Négation_unaire_-"><a name="Unary_negation">Négation unaire (-)</a></h2>
+
+<p>L'opérateur de négation unaire précède son opérande et prend l'opposé de celui-ci (après l'avoir converti en nombre si besoin).</p>
+
+<h3 id="Syntaxe_9">Syntaxe</h3>
+
+<pre class="syntaxbox">Opérateur : -x</pre>
+
+<h3 id="Exemples_9">Exemples</h3>
+
+<pre class="brush: js">var x = 3;
+y = -x; // y = -3, x = 3
+
+// La négation unaire permet de convertir
+// un opérande en nombre
+var y = "4";
+var z = -y; // z = -4
+</pre>
+
+<h2 id="Plus_unaire"><a name="Unary_plus">Plus unaire</a> (+)</h2>
+
+<p>L'opérateur unaire plus (+) précède son opérande, l'évaluation correspond à son opérande, converti en nombre si possible et si ce n'est pas déjà un nombre. Bien que l'opérateur de négation unaire (-) puisse également convertir les expressions qui ne sont pas des nombres, le plus unaire est la méthode la plus efficace et celle la plus utilisée pour convertir quelque chose en un nombre car la conversion est la seule opération effectuée. Cet opérateur permet de convertir les chaînes de caractères représentant des nombres entiers, des nombres flottants ainsi que les valeurs <code>true</code>, <code>false</code>, et <code>null</code>. Les entiers, représentés sous forme décimale ou hexadécimale (préfixés par "0x"), sont supportés. Les nombres négatifs sont également supportés (mais pas au format hexadécimal). Si l'opérateur ne peut pas analyser l'opérande fourni, il sera évalué à <a href="/fr/docs/JavaScript/Reference/Propriétés_globales/NaN">NaN</a>.</p>
+
+<h3 id="Syntaxe_10">Syntaxe</h3>
+
+<pre class="syntaxbox">Opérator : +x</pre>
+
+<h3 id="Exemples_10">Exemples</h3>
+
+<pre class="brush: js">+3     // 3
++"3"   // 3
++true  // 1
++false // 0
++null  // 0
++function(val){ return val; } // NaN
+</pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-additive-operators')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2017', '#sec-postfix-expressions')}}</td>
+   <td>{{Spec2('ES2017')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2016', '#sec-postfix-expressions')}}</td>
+   <td>{{Spec2('ES2016')}}</td>
+   <td><a href="https://github.com/rwaldron/exponentiation-operator">Ajout de l'opérateur d'exponentiation.</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-postfix-expressions')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Définis au sein de plusieurs sections de cette spécification : <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-additive-operators">Opérateurs additifs</a>, <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-multiplicative-operators">opérateurs multiplicatifs</a>, <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-postfix-expressions">expressions postfixes</a>, <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-unary-operators">opérateurs unaires</a>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.3')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Définis au sein de plusieurs sections de cette spécification : <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.6">Opérateurs additifs</a>, <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.5">opérateurs multiplicatifs</a>,<a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.3"> expressions postfixes</a>, <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.4">opérateurs unaires</a>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Définition initiale</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.operators.arithmetic")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation">Opérateurs d'affectation</a></li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/operators_03cb648b1d07bbaa8b57526b509d6d55/index.html b/files/fr/conflicting/web/javascript/reference/operators_03cb648b1d07bbaa8b57526b509d6d55/index.html
new file mode 100644
index 0000000000..50d1221a40
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/operators_03cb648b1d07bbaa8b57526b509d6d55/index.html
@@ -0,0 +1,257 @@
+---
+title: Opérateurs de comparaison
+slug: Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison
+tags:
+  - JavaScript
+  - Opérateur
+  - Reference
+translation_of: Web/JavaScript/Reference/Operators
+translation_of_original: Web/JavaScript/Reference/Operators/Comparison_Operators
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>JavaScript possède des opérateurs de comparaisons stricts et des opérateurs de comparaisons qui effectuent des conversions. Une comparaison strict (ex. : <code>===</code>) ne sera vraie que si les deux opérandes sont du même type. La comparaison d'égalité faible (<code>==</code>) convertira les deux opérandes en un même type avant d'effectuer la comparaison. Pour les comparaisons relationnelles (ex. : <code>&lt;=</code>), les opérandes sont tout d'abord converties en valeurs, puis en valeurs du même type, enfin la comparaison est effectuée.</p>
+
+<p>Les chaînes de caractères sont comparées en fonction de l'ordre lexicographique, avec des valeurs Unicode.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-comparisonoperators.html")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<p>Les règles de comparaisons pour <a href="/fr/docs/Web/JavaScript/Structures_de_données#Les_valeurs_primitives">les types primitifs</a> sont les suivantes :</p>
+
+<ul>
+ <li>Deux chaînes de caractères sont strictement égales lorsqu'elles ont la même séquence de caractères, la même longueur et les mêmes caractères aux mêmes positions.</li>
+ <li>Deux nombres sont strictement égaux lorsqu'ils ont la même valeur. {{jsxref("Objets_globaux/NaN","NaN")}} n'est égal à rien, y compris lui-même. Le zéro positif et le zéro négatif sont considérés égaux.</li>
+ <li>Deux booléens sont strictement égaux s'ils valent tous les deux <code>true</code> ou tous les deux <code>false</code>.</li>
+ <li>Deux objets distincts ne sont jamais égaux l'un à l'autre (pour l'égalité faible et stricte).</li>
+ <li>Deux objets sont égaux si les deux opérandes sont des références au même objet.</li>
+ <li>Les types nul et indéfini sont strictement égaux à eux-mêmes et sont faiblement égaux l'un à autre.</li>
+</ul>
+
+<h2 id="Les_opérateurs_dégalité">Les opérateurs d'égalité</h2>
+
+<h3 id="Égalité_simple"><a>Égalité simple (==)</a></h3>
+
+<p>L'opérateur d'égalité simple convertit les deux opérandes s'<strong>ils ne sont pas du même type</strong>, ensuite la comparaison stricte est appliquée. Si <strong>les deux opérandes sont des objets</strong>, le moteur JavaScript comparera les références internes pour voir si elles réfèrent au même objet en mémoire.</p>
+
+<h4 id="Syntaxe">Syntaxe</h4>
+
+<pre class="syntaxbox">x == y
+</pre>
+
+<h4 id="Exemples">Exemples</h4>
+
+<pre class="brush: js"> 1   ==  1;        // true
+"1"  ==  1;        // true
+ 1   == '1';       // true
+ 0   == false;     // true
+ 0   == null;      // false
+ 0   == undefined  // false
+null == undefined  // true
+
+var obj1 = { "clé": "valeur"};
+var obj2 = { "clé": "valeur"};
+obj1 == obj2       // false
+</pre>
+
+<h3 id="Inégalité_simple_!"><a>Inégalité simple (!=)</a></h3>
+
+<p>L'opérateur d'inégalité simple renvoie <code>true</code> si les deux opérandes ne sont pas égaux. Si les deux opérandes <strong>ne sont pas du même type</strong>, une conversion sera effectuée vers un type adéquat. <strong>Si les deux opérandes sont des objets,</strong> le moteur JavaScript comparera les références internes pour voir si elles réfèrent à des objets différents en mémoire.</p>
+
+<h4 id="Syntaxe_2">Syntaxe</h4>
+
+<pre class="syntaxbox">x != y</pre>
+
+<h4 id="Exemples_2">Exemples</h4>
+
+<pre class="brush: js">1 !=   2;     // true
+1 !=  "1";    // false
+1 !=  '1';    // false
+1 !=  true;   // false
+0 !=  false;  // false
+</pre>
+
+<h3 id="Égalité_stricte"><a>Égalité stricte (===)</a></h3>
+
+<p>L'opérateur d'égalité stricte renvoie <code>true</code> si les opérandes sont strictement égaux (voir ci-avant), <strong>aucune conversion de type n'est effectuée</strong>.</p>
+
+<h4 id="Syntaxe_3">Syntaxe</h4>
+
+<pre class="syntaxbox">x === y</pre>
+
+<h4 id="Exemples_3">Exemples</h4>
+
+<pre class="brush: js ">3 === 3   // true
+3 === '3' // false
+
+var objet1 = {'clé': 'valeur'};
+var objet2 = {'clé': 'valeur'};
+objet1 === objet2; // false
+</pre>
+
+<h3 id="Inégalité_stricte_!"><a>Inégalité stricte (!==)</a></h3>
+
+<p>L'opérateur d'inégalité stricte renvoie <code>true</code> si les opérandes sont de types différents ou ne sont pas égaux.</p>
+
+<h4 id="Syntaxe_4">Syntaxe</h4>
+
+<pre class="syntaxbox">x !== y</pre>
+
+<h4 id="Exemples_4">Exemples</h4>
+
+<pre class="brush: js">3 !== '3' // true
+4 !== 3   // true
+</pre>
+
+<h2 id="Opérateurs_relationnels">Opérateurs relationnels</h2>
+
+<div class="note">
+<p><strong>Note :</strong> Chacun de ces opérateurs invoquera la fonction <code>valueOf()</code> des opérandes qui sont des objets avant d'effectuer la comparaison.</p>
+</div>
+
+<h3 id="Supérieur_strict_>"><a>Supérieur strict (&gt;)</a></h3>
+
+<p>Cet opérateur renvoie <code>true</code> si l'opérande gauche est strictement supérieur à l'opérande droit.</p>
+
+<h4 id="Syntaxe_5">Syntaxe</h4>
+
+<pre class="syntaxbox">x &gt; y</pre>
+
+<h4 id="Exemples_5">Exemples</h4>
+
+<pre class="brush: js">4 &gt; 3; // true
+</pre>
+
+<h3 id="Supérieur_ou_égal_>"><a>Supérieur ou égal (&gt;=)</a></h3>
+
+<p>Cet opérateur renvoie <code>true</code> si l'opérande gauche est supérieur ou égal à l'opérande droit</p>
+
+<h4 id="Syntaxe_6">Syntaxe</h4>
+
+<pre class="syntaxbox"> x &gt;= y</pre>
+
+<h4 id="Exemples_6">Exemples</h4>
+
+<pre class="brush: js">4 &gt;= 3; // true
+3 &gt;= 3; // true
+</pre>
+
+<h3 id="Inférieur_strict_&lt;"><a>Inférieur strict (&lt;)</a></h3>
+
+<p>Cet opérateur renvoie <code>true</code> si l'opérande gauche est strictement inférieur à l'opérande droit</p>
+
+<h4 id="Syntaxe_7">Syntaxe</h4>
+
+<pre class="syntaxbox"> x &lt; y</pre>
+
+<h4 id="Exemples_7">Exemples</h4>
+
+<pre class="brush: js">3 &lt; 4; // true
+</pre>
+
+<h3 id="Inférieur_ou_égal_&lt;"><a>Inférieur ou égal (&lt;=)</a></h3>
+
+<p>Cet opérateur renvoie <code>true</code> si l'opérande gauche est inférieur ou égal à l'opérande droit</p>
+
+<h4 id="Syntaxe_8">Syntaxe</h4>
+
+<pre class="syntaxbox"> x &lt;= y</pre>
+
+<h4 id="Exemples_8">Exemples</h4>
+
+<pre class="brush: js">3 &lt;= 4; // true
+</pre>
+
+<h2 id="Utiliser_les_opérateurs_dégalité">Utiliser les opérateurs d'égalité</h2>
+
+<p>Les opérateurs d'égalité/inégalité faible (<code>==</code> et <code>!=</code>) utilisent <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3">l'algorithme de comparaison d'égalité abstraite</a> afin de comparer les deux opérandes. Si les opérandes sont de types primitifs différents, le moteur tentera de les convertir en un même type avant d'effectuer la comparaison. Ainsi, dans l'expression <code>5 == '5'</code>, la chaîne de droite est convertie en un nombre avant que la comparaison soit faite.</p>
+
+<p>Les opérateurs d'égalité/inégalité stricte (<code>===</code> et <code>!==</code>) utilisent <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.9.6">l'algorithme de comparaison d'égalité stricte</a>. Si les opérandes sont de types différents, le résultat sera toujours <code>false</code>, on aura donc <code>5 !== '5'</code>.</p>
+
+<p>Selon qu'on souhaite comparer des opérandes qui sont censés avoir le même type ou non, on utilisera l'un ou l'autre type d'opérateur.</p>
+
+<p>Si un opérande doit être comparé à un autre type, le moteur effectuera une conversion de la façon suivante :</p>
+
+<ul>
+ <li>Lorsqu'une comparaison est opérée entre une chaîne de caractères et un nombre, Javascript tente de convertir la chaine en une valeur numérique. Une valeur mathématique est obtenue à partir de la chaîne littérale numérique, puis celle-ci est arrondie à une valeur de type Nombre.</li>
+ <li>Si l'un des opérandes est de type booléen, <code>true</code> sera converti en 1 et <code>false</code> en +0.</li>
+ <li>Si on compare un objet avec un nombre ou une chaîne, le moteur JavaScript tentera de renvoyer la valeur par défaut de l'objet. Les opérateurs opèrent une conversion grâce aux méthodes <code>valueOf</code> (pour obtenir un nombre) et <code>toString</code> (pour obtenir une chaîne de caractères). Si cela ne fonctionne pas, une exception sera levée.</li>
+ <li>Un objet sera converti en un type primitif autre uniquement si l'autre opérande est un type primitif (autre qu'objet). Si les deux opérandes sont des objets, ils seront comparés comme deux objets (voir ci-avant) et l'égalité ne sera vérifiée que si les opérandes font référence au même objet en mémoire</li>
+</ul>
+
+<div class="note">
+<p><strong>Note :</strong> Voir également la page sur <a href="/fr/docs/Web/JavaScript/Les_diff%C3%A9rents_tests_d_%C3%A9galit%C3%A9_comment_les_utiliser">les différents tests d'égalité et quand les utiliser</a>.</p>
+</div>
+
+<div class="note"><strong>Note :</strong> Les objets String sont du type objet et ne sont pas de simples chaînes de caractères ! Cela peut parfois avoir des conséquences surprenantes :</div>
+
+<pre class="brush:js">// true car les deux opérandes sont du type primitif chaîne de caractères
+'toto' === 'toto'
+
+var a = new String('toto');
+var b = new String('toto');
+
+// false car a et b sont du type objet mais font référence à deux objets distincts
+a == b
+
+// false car a et b sont du type objet mais font référence à deux objets distincts
+a === b
+
+// true car a et 'toto' sont de type différents et lorsque a est
+// converti, la fonction de conversion renvoie bien la chaîne 'toto'
+a == 'toto' </pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Définition initiale. Implémentée avec JavaScript 1.0</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Ajoute les opérateurs <code>===</code> et <code>!==</code>. Implémentés avec JavaScript 1.3</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.8')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Définis dans plusieurs sections de la spécification : <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.8">opérateurs relationnels</a>, <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.9">opérateurs d'égalité</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-relational-operators')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Définis dans plusieurs sections de la spécification : <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-relational-operators">opérateurs relationnels</a>, <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-equality-operators">opérateurs d'égalité</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-relational-operators')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Définis dans plusieurs sections de la spécification : <a href="https://tc39.github.io/ecma262/#sec-relational-operators">opérateurs relationnels</a>, <a href="https://tc39.github.io/ecma262/#sec-equality-operators">opérateurs d'égalité</a></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.operators.comparison")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Object.is()")}}</li>
+ <li>{{jsxref("Math.sign()")}}</li>
+ <li><a href="/fr/docs/Web/JavaScript/Guide/%C3%89galit%C3%A9_en_JavaScript">L'égalité en JavaScript</a></li>
+ <li><a href="/fr/docs/Web/JavaScript/Les_diff%C3%A9rents_tests_d_%C3%A9galit%C3%A9_comment_les_utiliser">Les différents tests d'égalité en JavaScript</a></li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/operators_201bc9aef1615ff38f215c35d4cde8c9/index.html b/files/fr/conflicting/web/javascript/reference/operators_201bc9aef1615ff38f215c35d4cde8c9/index.html
new file mode 100644
index 0000000000..5b7ec3375f
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/operators_201bc9aef1615ff38f215c35d4cde8c9/index.html
@@ -0,0 +1,28 @@
+---
+title: Opérateurs de chaînes
+slug: Web/JavaScript/Reference/Opérateurs/Opérateurs_de_chaînes
+translation_of: Web/JavaScript/Reference/Operators/Arithmetic_Operators#Addition
+translation_of_original: Web/JavaScript/Reference/Operators/String_Operators
+---
+<p> </p>
+<h3 id="R.C3.A9sum.C3.A9" name="R.C3.A9sum.C3.A9">Résumé</h3>
+<p>En complément des opérateurs de comparaison, qui peuvent être utilisés sur des valeurs chaînes de caractères, l'opérateur de concaténation (<code>+</code>) permet d'assembler deux chaînes, en renvoyant une nouvelle chaîne étant l'union des deux opérandes chaînes. Par exemple, <code>"ma " + "chaîne"</code> renvoie la chaîne <code>"ma chaîne"</code>.</p>
+<p>L'opérateur raccourci d'assignation <code>+=</code> peut également être utilisé pour concaténer des chaînes. Par exemple, si la variable <code>ma_chaine</code> a la valeur <code>"alpha"</code>, l'expression <code>ma_chaine += "bet"</code> sera évaluée à <code>"alphabet"</code> et assignera cette valeur à la variable <code>ma_chaine</code>.</p>
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <td class="header" colspan="2">Opérateur</td>
+  </tr>
+  <tr>
+   <td>Implémentation :</td>
+   <td>JavaScript 1.0</td>
+  </tr>
+  <tr>
+   <td>Version ECMA :</td>
+   <td>ECMA-262</td>
+  </tr>
+ </tbody>
+</table>
+<div class="noinclude">
+  </div>
+<p>{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Operators/String_Operators", "es": "es/Referencia_de_JavaScript_1.5/Operadores/String", "pl": "pl/Dokumentacja_j\u0119zyka_JavaScript_1.5/Operatory/Operatory_dzia\u0142aj\u0105ce_na_ci\u0105gach_znak\u00f3w" } ) }}</p>
diff --git a/files/fr/conflicting/web/javascript/reference/operators_2be16fc74d75a7c9dca0abca1dc5883b/index.html b/files/fr/conflicting/web/javascript/reference/operators_2be16fc74d75a7c9dca0abca1dc5883b/index.html
new file mode 100644
index 0000000000..d019cb8637
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/operators_2be16fc74d75a7c9dca0abca1dc5883b/index.html
@@ -0,0 +1,414 @@
+---
+title: Opérateurs d'affectation
+slug: Web/JavaScript/Reference/Opérateurs/Opérateurs_d_affectation
+tags:
+  - JavaScript
+  - Operator
+  - Reference
+translation_of: Web/JavaScript/Reference/Operators#Assignment_operators
+translation_of_original: Web/JavaScript/Reference/Operators/Assignment_Operators
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>Un <strong>opérateur d'affectation</strong> permet d'assigner une valeur à son opérande gauche en se basant sur la valeur de son opérande droit.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-assignment.html")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<h2 id="Description">Description</h2>
+
+<p>L'opérateur utilisé pour l'affectation est le symbole égal (<code>=</code>), il permet d'affecter la valeur de l'opérande droit à son opérande gauche. Ainsi, quand on écrit <code>x = y</code>, on affecte la valeur de <code>y</code> à <code>x</code>. Les autres opérateurs d'affectation sont généralement des raccourcis pour des opérations standards. Ils sont décrits ci-après avec définitions et exemples.</p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th>Nom</th>
+   <th>Opérateur (raccourci)</th>
+   <th>Signification</th>
+  </tr>
+  <tr>
+   <td><a href="#Assignment">Affectation</a></td>
+   <td><code>x = y</code></td>
+   <td><code>x = y</code></td>
+  </tr>
+  <tr>
+   <td><a href="#Addition_assignment">Affectation après addition</a></td>
+   <td><code>x += y</code></td>
+   <td><code>x = x + y</code></td>
+  </tr>
+  <tr>
+   <td><a href="#Subtraction_assignment">Affectation après soustraction</a></td>
+   <td><code>x -= y</code></td>
+   <td><code>x = x - y</code></td>
+  </tr>
+  <tr>
+   <td><a href="#Multiplication_assignment">Affectation après multiplication</a></td>
+   <td><code>x *= y</code></td>
+   <td><code>x = x * y</code></td>
+  </tr>
+  <tr>
+   <td><a href="#Division_assignment">Affectation après division</a></td>
+   <td><code>x /= y</code></td>
+   <td><code>x = x / y</code></td>
+  </tr>
+  <tr>
+   <td><a href="#Remainder_assignment">Affectation du reste</a></td>
+   <td><code>x %= y</code></td>
+   <td><code>x = x % y</code></td>
+  </tr>
+  <tr>
+   <td><a href="#Exponentiation">Affectation après exponentiation</a></td>
+   <td><code>x **= y</code></td>
+   <td><code>x = x ** y</code></td>
+  </tr>
+  <tr>
+   <td><a href="#Left_shift_assignment">Affectation après décalage à gauche</a></td>
+   <td><code>x &lt;&lt;= y</code></td>
+   <td><code>x = x &lt;&lt; y</code></td>
+  </tr>
+  <tr>
+   <td><a href="#Right_shift_assignment">Affectation après décalage à droite</a></td>
+   <td><code>x &gt;&gt;= y</code></td>
+   <td><code>x = x &gt;&gt; y</code></td>
+  </tr>
+  <tr>
+   <td><a href="#Unsigned_right_shift_assignment">Affectation après décalage à droite non-signé</a></td>
+   <td><code>x &gt;&gt;&gt;= y</code></td>
+   <td><code>x = x &gt;&gt;&gt; y</code></td>
+  </tr>
+  <tr>
+   <td><a href="#Bitwise_AND_assignment">Affectation après ET binaire</a></td>
+   <td><code>x &amp;= y</code></td>
+   <td><code>x = x &amp; y</code></td>
+  </tr>
+  <tr>
+   <td><a href="#Bitwise_XOR_assignment">Affectation après OU exclusif binaire</a></td>
+   <td><code>x ^= y</code></td>
+   <td><code>x = x ^ y</code></td>
+  </tr>
+  <tr>
+   <td><a href="#Bitwise_OR_assignment">Affectation après OU binaire</a></td>
+   <td><code>x |= y</code></td>
+   <td><code>x = x | y</code></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Affectation"><a name="Assignment">Affectation</a></h2>
+
+<p>L'opérateur d'affectation simple permet d'assigner une valeur à une variable. Le résultat de l'affectation est la valeur affectée. Il est possible de chaîner plusieurs opérateurs d'affectation afin d'assigner une même valeur à plusieurs variables. Voir l'exemple ci-après.</p>
+
+<h4 id="Syntaxe">Syntaxe</h4>
+
+<pre class="syntaxbox"><strong>Opérateur :</strong> x = y
+</pre>
+
+<h4 id="Exemples">Exemples</h4>
+
+<pre class="brush: js">// Si on dispose des variables suivantes :
+//  x = 5;
+//  y = 10;
+//  z = 25;
+
+x = y;     // x vaudra désormais 10
+x = y = z; // x, y et z valent désormais tous 25
+</pre>
+
+<h3 id="Affectation_après_addition"><a name="Addition_assignment">Affectation après addition</a></h3>
+
+<p>Cet opérateur permet d'ajouter la valeur de l'opérande droit à une variable, le résultat de l'addition étant affecté à cette variable. Les types des deux opérandes déterminent le comportement de l'opérateur. Selon le type, on pourra en effet avoir une addition ou une concaténation. Voir la page sur l'opérateur d'{{jsxref("Opérateurs/Opérateurs_arithmétiques", "addition", "#Addition_(.2B)", 1)}} pour plus d'informations.</p>
+
+<h4 id="Syntaxe_2">Syntaxe</h4>
+
+<pre class="syntaxbox"><strong>Opérateur :</strong> x += y
+<strong>Signification :</strong>  x  = x + y
+</pre>
+
+<h4 id="Exemples_2">Exemples</h4>
+
+<pre class="brush: js">// Si on dispose des variables suivantes :
+//  toto = "toto";
+//  truc = 5;
+//  machin = true;
+
+
+// Nombre + Nombre -&gt; addition
+truc += 2; // 7
+
+// Booléen + Booléen -&gt; addition
+machin += 1; // 2
+
+// Booléen + Booléen -&gt; addition
+machin += false; // 1
+
+// Nombre + String -&gt; concaténation
+truc += "toto"; // "5toto"
+
+// String + Booléen -&gt; concaténation
+toto += false; // "totofalse"
+
+// String + String -&gt; concaténation
+toto += "truc"; // "tototruc"
+</pre>
+
+<h3 id="Affectation_après_soustraction"><a name="Subtraction_assignment">Affectation après soustraction</a></h3>
+
+<p>Cet opérateur soustrait la valeur de l'opérande droit à la variable puis affecte le résultat de cette soustraction à la variable. Voir la page sur l'opérateur de {{jsxref("Opérateurs/Opérateurs_arithmétiques", "soustraction", "#Soustraction_(-)", 1)}} pour plus d'information.</p>
+
+<h4 id="Syntaxe_3">Syntaxe</h4>
+
+<pre class="syntaxbox"><strong>Opérateur :</strong> x -= y
+<strong>Signification :</strong>  x  = x - y
+</pre>
+
+<h4 id="Exemples_3">Exemples</h4>
+
+<pre class="brush: js">// Si on a la variable suivante :
+//  truc = 5;
+
+truc -= 2;     // 3
+truc -= "toto"; // NaN
+</pre>
+
+<h3 id="Affectation_après_multiplication"><a name="Multiplication_assignment">Affectation après multiplication</a></h3>
+
+<p>Cet opérateur permet de multiplier une variable par la valeur de l'opérande droit et d'affecter le résultat de cette opération à la variable. Voir la page sur l'opérateur de {{jsxref("Opérateurs/Opérateurs_arithmétiques", "multiplication", "#Multiplication_(*)", 1)}} pour plus d'informations.</p>
+
+<h4 id="Syntaxe_4">Syntaxe</h4>
+
+<pre class="syntaxbox"><strong>Opérateur :</strong> x *= y
+<strong>Signification :</strong>  x  = x * y
+</pre>
+
+<h4 id="Exemples_4">Exemples</h4>
+
+<pre class="brush: js">// Si on a la variable suivante :
+//  truc = 5;
+
+truc *= 2;     // 10
+truc *= "toto"; // NaN
+</pre>
+
+<h3 id="Affectation_après_division"><a name="Division_assignment">Affectation après division</a></h3>
+
+<p>Cet opérateur permet de diviser une variable par la valeur de l'opérande droit et d'affecter le résultat de cette opération à la variable. Voir la page sur l'opérateur de {{jsxref("Opérateurs/Opérateurs_arithmétiques", "division", "#Division_(.2F)", 1)}} pour plus d'informations.</p>
+
+<h4 id="Syntaxe_5">Syntaxe</h4>
+
+<pre class="syntaxbox"><strong>Opérateur :</strong> x /= y
+<strong>Signification :</strong>  x  = x / y
+</pre>
+
+<h4 id="Exemples_5">Exemples</h4>
+
+<pre class="brush: js">// Si on a la variable suivante :
+//  truc = 5;
+
+truc /= 2;     // 2.5
+truc /= "toto"; // NaN
+truc /= 0;     // Infinity
+</pre>
+
+<h3 id="Affectation_du_reste"><a name="Remainder_assignment">Affectation du reste</a></h3>
+
+<p>Cet opérateur permet de divisier une variable par la valeur de l'opérande droit et d'affecter le reste de cette division à la variable. Pour plus d'informations, voir la page sur l'opérateur {{jsxref("Opérateurs/Opérateurs_arithmétiques", "reste", "#Reste_(.25)", 1)}}.</p>
+
+<h4 id="Syntaxe_6">Syntaxe</h4>
+
+<pre class="syntaxbox"><strong>Opérateur :</strong> x %= y
+<strong>Signification :</strong>  x  = x % y
+</pre>
+
+<h4 id="Exemples_6">Exemples</h4>
+
+<pre class="brush: js">// Si on a la variable suivante :
+//  truc = 5;
+
+truc %= 2;      // 1
+truc %= "toto"; // NaN
+truc %= 0;      // NaN
+</pre>
+
+<h3 id="Affectation_après_exponentiation"><a id="Exponentiation" name="Exponentiation">Affectation après exponentiation</a></h3>
+
+<p>L'opérateur d'affectation après exponentiation renvoie le résultat de l'élévation du premier opérande à la puissance donnée par le second opérande. Pour plus de détails, voir la page sur {{jsxref("Opérateurs/Opérateurs_arithmétiques", "l'opérateur d'exponentiation", "#Exponentiation_(**)", 1)}} for more details.</p>
+
+<h4 id="Syntaxe_7">Syntaxe</h4>
+
+<pre class="syntaxbox"><strong>Opérateur :</strong> x **= y
+<strong>Signification :</strong>  x  = x ** y
+</pre>
+
+<h4 id="Exemples_7">Exemples</h4>
+
+<pre class="brush: js">// Si on a la variable :
+//  toto = 5
+
+toto **= 2      // 25
+toto **= "truc" // NaN</pre>
+
+<h3 id="Affectation_après_décalage_à_gauche"><a name="Left_shift_assignment">Affectation après décalage à gauche</a></h3>
+
+<p>Cet opérateur permet de décaler un nombre donné de bits vers la gauche, le résultat de l'opération est ensuite affecté à la variable. Voir la page sur l'opérateur de {{jsxref("Opérateurs/Opérateurs_binaires", "décalage à gauche", "#.3C.3C_.28d.C3.A9calage_.C3.A0_gauche.29", 1)}} pour plus d'informations.</p>
+
+<h4 id="Syntaxe_8">Syntaxe</h4>
+
+<pre class="syntaxbox"><strong>Opérateur :</strong> x &lt;&lt;= y
+<strong>Signification :</strong>  x   = x &lt;&lt; y
+</pre>
+
+<h4 id="Exemples_8">Exemples</h4>
+
+<pre class="brush: js">var toto = 5; //  (00000000000000000000000000000101)
+toto &lt;&lt;= 2;   // 20 (00000000000000000000000000010100)
+</pre>
+
+<h3 id="Affectation_après_décalage_à_droite"><a name="Right_shift_assignment">Affectation après décalage à droite</a></h3>
+
+<p>Cet opérateur permet de décaler un nombre donné de bits vers la droite, le résultat de l'opération est ensuite affecté à la variable. Voir la page sur l'opérateur de {{jsxref("Opérateurs/Opérateurs_binaires", "décalage à droite", "##.3E.3E_.28d.C3.A9calage_.C3.A0_droite_avec_propagation_du_signe.29", 1)}} pour plus d'informations.</p>
+
+<h4 id="Syntaxe_9">Syntaxe</h4>
+
+<pre class="syntaxbox"><strong>Opérateur :</strong> x &gt;&gt;= y
+<strong>Signification :</strong>  x   = x &gt;&gt; y
+</pre>
+
+<h4 id="Exemples_9">Exemples</h4>
+
+<pre class="brush: js">var toto = 5; //   (00000000000000000000000000000101)
+toto &gt;&gt;= 2;   // 1 (00000000000000000000000000000001)
+
+var toto -5; //    (-00000000000000000000000000000101)
+toto &gt;&gt;= 2;  // -2 (-00000000000000000000000000000010)
+</pre>
+
+<h3 id="Affectation_après_décalage_à_droite_non-signé"><a name="Unsigned_right_shift_assignment">Affectation après décalage à droite non-signé</a></h3>
+
+<p>Cet opérateur permet de décaler le contenu de la variable d'un nombre de bits donné pour ensuite affecter le résultat à la variable. Voir la page sur l'opérateur de {{jsxref("Opérateurs/Opérateurs_binaires", "décalage à droite non-signé", "#.3E.3E.3E_.28d.C3.A9calage_.C3.A0_droite_avec_insertion_de_z.C3.A9ros.29", 1)}} pour plus de détails.</p>
+
+<h4 id="Syntaxe_10">Syntaxe</h4>
+
+<pre class="syntaxbox"><strong>Opérateur :</strong> x &gt;&gt;&gt;= y
+<strong>Signification :</strong>  x    = x &gt;&gt;&gt; y
+</pre>
+
+<h4 id="Exemples_10">Exemples</h4>
+
+<pre class="brush: js">var toto = 5; //   (00000000000000000000000000000101)
+toto &gt;&gt;&gt;= 2;  // 1 (00000000000000000000000000000001)
+
+var toto = -5; // (-00000000000000000000000000000101)
+toto &gt;&gt;&gt;= 2; // 1073741822 (00111111111111111111111111111110)</pre>
+
+<h3 id="Affectation_après_ET_binaire"><a name="Bitwise_AND_assignment">Affectation après ET binaire</a></h3>
+
+<p>Cet opérateur effectue une opération ET binaire sur les deux opérandes et affecte le résultat de l'opération à la variable (l'opérande gauche). Pour plus d'informations sur cette opération, voir la page sur l'opérateur {{jsxref("Opérateurs/Opérateurs_binaires", "binaire ET", "#&amp;_.28ET_binaire.29", 1)}}.</p>
+
+<h4 id="Syntaxe_11">Syntaxe</h4>
+
+<pre class="syntaxbox"><strong>Opérateur :</strong> x &amp;= y
+<strong>Signification :</strong>  x  = x &amp; y
+</pre>
+
+<h4 id="Exemple">Exemple</h4>
+
+<pre class="brush: js">var truc = 5;
+// 5:     00000000000000000000000000000101
+// 2:     00000000000000000000000000000010
+truc &amp;= 2; // 0
+</pre>
+
+<h3 id="Affectation_après_OU_exclusif_(XOR)_binaire"><a name="Bitwise_XOR_assignment">Affectation après OU exclusif (<em>XOR</em>) binaire</a></h3>
+
+<p>Cet opérateur utilise une représentation binaire des deux opérandes, effectue une opération binaire avec un OU exclusif et affecte le résultat à la variable. Pour plus d'informations sur cette opération, voir la page sur l'opérateur {{jsxref("Opérateurs/Opérateurs_binaires", "binaire OU exclusif", "#.5E_.28XOR_binaire.29", 1)}}.</p>
+
+<h4 id="Syntaxe_12">Syntaxe</h4>
+
+<pre class="syntaxbox"><strong>Opérateur :</strong> x ^= y
+<strong>Signification :</strong>  x  = x ^ y
+</pre>
+
+<h4 id="Exemple_2">Exemple</h4>
+
+<pre class="brush: js">var toto = 5;
+toto ^= 2; // 7
+// 5: 00000000000000000000000000000101
+// 2: 00000000000000000000000000000010
+// -----------------------------------
+// 7: 00000000000000000000000000000111
+</pre>
+
+<h3 id="Affectation_après_OU_binaire"><a name="Bitwise_OR_assignment">Affectation après OU binaire</a></h3>
+
+<p>Cet opérateur utilise une représentation binaire des deux opérandes, effectue un OU logique binaire entre ces deux variables et affecte le résultat de l'opération à la variable. Pour plus de détails sur cette opération, voir la page sur l'opérateur {{jsxref("Opérateurs/Opérateurs_binaires", "OU binaire", "#|_.28OU_binaire.29", 1)}}.</p>
+
+<h4 id="Syntaxe_13">Syntaxe</h4>
+
+<pre class="syntaxbox"><strong>Opérateur :</strong> x |= y
+<strong>Signification :</strong>  x  = x | y
+</pre>
+
+<h4 id="Exemple_3">Exemple</h4>
+
+<pre class="brush: js">var toto = 5;
+toto |= 2; // 7
+// 5: 00000000000000000000000000000101
+// 2: 00000000000000000000000000000010
+// -----------------------------------
+// 7: 00000000000000000000000000000111
+</pre>
+
+<h2 id="Exemples_11">Exemples</h2>
+
+<h3 id="Opérande_gauche_utilisé_avec_un_autre_opérateur_d'affectation">Opérande gauche utilisé avec un autre opérateur d'affectation</h3>
+
+<p>Dans certains cas, l'opérateur d'affectation (par exemple<code> x += y</code>) n'est pas identique à l'expression développée correspondante (respectivement <code>x = x + y</code>). Lorsque l'opérande gauche contient lui-même un opérateur d'affectation, l'opérande gauche n'est évalué qu'une fois. Ainsi :</p>
+
+<pre class="brush: js">a[i++] += 5         // i est évalué une fois
+a[i++] = a[i++] + 5 // i est évalué deux fois
+</pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-assignment-operators', 'Assignment operators')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-assignment-operators', 'Assignment operators')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.13', 'Assignment operators')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1', '#sec-11.13', 'Assignment operators')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Définition initiale</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.operators.assignment")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques">Les opérateurs arithmétiques</a></li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/operators_688eef608213025193cd6b8e1e75b5c3/index.html b/files/fr/conflicting/web/javascript/reference/operators_688eef608213025193cd6b8e1e75b5c3/index.html
new file mode 100644
index 0000000000..af76410f01
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/operators_688eef608213025193cd6b8e1e75b5c3/index.html
@@ -0,0 +1,554 @@
+---
+title: Opérateurs binaires
+slug: Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires
+tags:
+  - JavaScript
+  - Operator
+  - Opérateur
+  - Reference
+translation_of: Web/JavaScript/Reference/Operators
+translation_of_original: Web/JavaScript/Reference/Operators/Bitwise_Operators
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>Les opérateurs binaires traitent leurs opérandes comme des séquences de 32 bits (des zéros et des uns), plutôt que comme des nombres décimaux, hexadécimaux ou octaux. Par exemple, le nombre décimal neuf a une représentation binaire de 1001. Les opérateurs binaires traitent de telles représentations binaires, mais renvoient des valeurs numériques JavaScript standards.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-bitwiseoperators.html")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<p>Le tableau qui suit résume les opérateurs binaires de JavaScript :</p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th>Opérateur</th>
+   <th>Utilisation</th>
+   <th>Description</th>
+  </tr>
+  <tr>
+   <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#(ET_binaire)">ET binaire</a></td>
+   <td><code>a &amp; b</code></td>
+   <td>
+    <p>Renvoie un <code>1</code> pour chaque position de bit pour laquelle les bits correspondants des deux opérandes sont des <code>1</code>.</p>
+   </td>
+  </tr>
+  <tr>
+   <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#(OU_binaire)">OU binaire</a></td>
+   <td><code>a | b</code></td>
+   <td>Renvoie un <code>1</code> pour chaque position de bit pour laquelle le bit correspondant d'au moins un des deux opérandes est un <code>1</code> .</td>
+  </tr>
+  <tr>
+   <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#(XOR_binaire)">OU exclusif binaire (<em>XOR</em>)</a></td>
+   <td><code>a ^ b</code></td>
+   <td>Renvoie un <code>1</code> pour chaque position de bit pour laquelle le bit correspondant d'un seul des deux opérandes est un <code>1</code>.</td>
+  </tr>
+  <tr>
+   <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#(NON_binaire)">NON binaire</a></td>
+   <td><code>~ a</code></td>
+   <td>Inverse les bits de son opérande.</td>
+  </tr>
+  <tr>
+   <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#&lt;&lt;_(décalage_à_gauche)">Décalage à gauche</a></td>
+   <td><code>a &lt;&lt; b</code></td>
+   <td>Décale <code>a</code> en représentation binaire de <code>b</code> bits vers la gauche, en introduisant des zéros par la droite.</td>
+  </tr>
+  <tr>
+   <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#>>_(décalage_à_droite_avec_propagation_du_signe)">Décalage à droite avec propagation du signe</a></td>
+   <td><code>a &gt;&gt; b</code></td>
+   <td>Décale <code>a</code> en représentation binaire de <code>b</code> bits vers la droite, en rejetant les bits à droite.</td>
+  </tr>
+  <tr>
+   <td><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_binaires#>>>_(décalage_à_droite_avec_insertion_de_zéros)">Décalage à droite avec introduction de zéros</a></td>
+   <td><code>a &gt;&gt;&gt; b</code></td>
+   <td>Décale <code>a</code> en représentation binaire de <code>b</code> bits vers la droite, en rejetant les bits à droite et en introduisant des zéros par la gauche.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Entiers_sur_32_bits_signés">Entiers sur 32 bits signés</h2>
+
+<p>Les opérandes de tous les opérateurs binaires sont convertis en entiers signés sur 32 bits en ordre big-endian et en format de <a href="https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_deux">complément à deux</a> (à l'exception de l'opération de décalage à droite avec remplissage des zéros qui renvoie un non-signé). L'ordre big-endian signifie que le bit le plus significatif (la position du bit qui a la plus grande valeur) est le bit le plus à gauche si les 32 bits sont disposés sur une ligne horizontale. Le format de complément à deux signifie que la contrepartie négative d'un nombre (par exemple 5 pour -5) est l'inversion de tous les bits du nombre (NON binaire du nombre, c'est-à-dire son complément à un) plus un. Par exemple, la représentation suivante encode l'entier 314 (base 10) :</p>
+
+<pre class="eval">00000000000000000000000100111010
+</pre>
+
+<p>La représentation suivante encode ~314, c'est-à-dire le complément à un de 314 :</p>
+
+<pre class="eval">11111111111111111111111011000101
+</pre>
+
+<p>Finalement, la représentation suivante encode -314, c'est-à-dire le complément à deux de 314 :</p>
+
+<pre class="eval">11111111111111111111111011000110
+</pre>
+
+<p>Le complément à deux garantit que le bit le plus à gauche soit 0 lorsque le nombre est positif, et <code>1</code> lorsque le nombre est négatif. C'est pourquoi on l'appelle le <em>bit de signe</em> .</p>
+
+<p>Le nombre 0 est l'entier constitué intégralement de bits à <code>0</code> .</p>
+
+<pre>0 (base 10) = 00000000000000000000000000000000 (base 2)</pre>
+
+<p>Le nombre -1 est l'entier constitué intégralement de bits à <code>1</code> .</p>
+
+<pre>-1 (base 10) = 11111111111111111111111111111111 (base 2)</pre>
+
+<p>Le nombre <code>-2147483648</code> (qui correspond à <code>-0x80000000</code> en notation hexadécimale) est l'entier uniquement composé de 0, à l'exception du premier bit (le plus à gauche) qui vaut 1.</p>
+
+<pre>-2147483648 (base 10) = 10000000000000000000000000000000 (base 2)</pre>
+
+<p>Le nombre <code>2147483647</code> (qui correspond à <code>0x7fffffff</code> en notation hexadécimale) est l'entier uniquement composé de 1, à l'exception du premier bit (le plus à gauche) qui vaut 0.</p>
+
+<pre>2147483647 (base 10) = 01111111111111111111111111111111 (base 2)</pre>
+
+<p>Les nombres <code>-2147483648</code> et <code>2147483647</code> sont respectivement le nombre le plus petit et le plus grand qu'on peut représenter sur 32 bits (signés).</p>
+
+<h2 id="Opérateurs_logiques_binaires">Opérateurs logiques binaires</h2>
+
+<p>Conceptuellement, les opérateurs logiques binaires fonctionnent de la manière suivante :</p>
+
+<ul>
+ <li>Les opérandes sont convertis en entiers sur 32 bits et exprimés sous la forme d'une série de bits (des 1 et des 0). Les nombres sur plus de 32 bits voient leurs bits supplémentaires supprimés :
+  <pre class="brush: js">Avant : 11100110111110100000000000000110000000000001
+Après :             10100000000000000110000000000001</pre>
+ </li>
+ <li>Chaque bit du premier opérande est combiné avec le bit correspondant du second opérande : le premier bit avec le premier bit, le second bit avec le second bit, et ainsi de suite.</li>
+ <li>L'opérateur est appliqué à chaque paire de bits, et le résultat est construit bit après bit.</li>
+</ul>
+
+<h3 id="(ET_binaire)"><a name="ET">&amp; (ET binaire)</a></h3>
+
+<p>Effectue l'opération ET (<em>AND</em>) sur chaque paire de bits. <code>a</code> ET <code>b</code> donne 1 uniquement si à la fois <code>a</code> et <code>b</code> sont <code>1</code> . La table de vérité pour l'opération ET est :</p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <td class="header">a</td>
+   <td class="header">b</td>
+   <td class="header">a ET b</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td>0</td>
+   <td>0</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td>1</td>
+   <td>0</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>0</td>
+   <td>0</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>1</td>
+   <td>1</td>
+  </tr>
+ </tbody>
+</table>
+
+<pre class="eval">     9 (base 10) = 00000000000000000000000000001001 (base 2)
+    14 (base 10) = 00000000000000000000000000001110 (base 2)
+                   --------------------------------
+14 &amp; 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)
+</pre>
+
+<p>Utiliser le ET binaire avec n'importe quel nombre x et zéro donne zéro. Utiliser le ET binaire avec n'importe quel nombre x et -1 donne x.</p>
+
+<h3 id="(OU_binaire)"><a name="OU">| (OU binaire)</a></h3>
+
+<p>Effectue l'opération OU (<em>OR</em>) sur chaque paire de bits. <code>a</code> OU <code>b</code> donne <code>1</code> si <code>a</code> ou <code>b</code> vaut 1. La table de vérité pour l'opération OU est :</p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <td class="header">a</td>
+   <td class="header">b</td>
+   <td class="header">a OU b</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td>0</td>
+   <td>0</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td>1</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>0</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>1</td>
+   <td>1</td>
+  </tr>
+ </tbody>
+</table>
+
+<pre class="eval">     9 (base 10) = 00000000000000000000000000001001 (base 2)
+    14 (base 10) = 00000000000000000000000000001110 (base 2)
+                   --------------------------------
+14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10)
+</pre>
+
+<p>Utiliser le OU binaire avec n'importe quel nombre x et 0 donne x. Utiliser le OU binaire avec n'importe quel nombre x et -1 donne -1.</p>
+
+<h3 id="(XOR_binaire)"><a name="XOR">^ (XOR binaire)</a></h3>
+
+<p>Effectue l'opération XOR (OU exclusif) sur chaque paire de bits. <code>a</code> XOR <code>b</code> donne <code>1</code> si <code>a</code> et <code>b</code> sont différents. La table de vérité pour l'opération XOR est :</p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <td class="header">a</td>
+   <td class="header">b</td>
+   <td class="header">a XOR b</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td>0</td>
+   <td>0</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td>1</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>0</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>1</td>
+   <td>0</td>
+  </tr>
+ </tbody>
+</table>
+
+<pre class="eval">     9 (base 10) = 00000000000000000000000000001001 (base 2)
+    14 (base 10) = 00000000000000000000000000001110 (base 2)
+                   --------------------------------
+14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10)
+</pre>
+
+<p>Utiliser le XOR binaire avec n'importe quel nombre x et 0 donne x. Utiliser le XOR binaire avec n'importe quel nombre x et -1 donne ~x.</p>
+
+<h3 id="(NON_binaire)"><a name="NON">~ (NON binaire)</a></h3>
+
+<p>Effectue l'opération NON (<em>NOT</em>) sur chaque bit. NON <code>a</code> donne la valeur inversée (c'est-à-dire le complément à un) de <code>a</code>. La table de vérité de l'opération NON est :</p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <td class="header">a</td>
+   <td class="header">NON a</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>0</td>
+  </tr>
+ </tbody>
+</table>
+
+<pre class="eval"> 9 (base 10) = 00000000000000000000000000001001 (base 2)
+               --------------------------------
+~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10)
+</pre>
+
+<p>Utiliser le NON binaire avec n'importe quel nombre <code>x</code> donne <code>-(x + 1)</code>. Par exemple, <code>~-5</code> donne <code>4</code>.</p>
+
+<p>Étant donnée la représentation sur 32 bits des nombres en JavaScript, on a <code>~-1</code> et <code>~4294967295</code> (2<sup>32</sup>-1) qui valent tous les deux <code>0</code>.</p>
+
+<h2 id="Opérateurs_de_décalage_binaire">Opérateurs de décalage binaire</h2>
+
+<p>Les opérateurs de décalage binaire (<em>shift</em>) prennent deux opérandes : le premier est une valeur à décaler et le second spécifie le nombre de positions de bits duquel le premier opérande doit glisser. La direction de l'opération de décalage est contrôlée par l'opérateur utilisé.</p>
+
+<p>Les opérateurs de décalage convertissent leurs opérandes en entiers 32 bits en ordre big-endian et renvoient un résultat du même type que l'opérande de gauche. L'opérande droit doit être inférieur à 32, sinon les cinq bits les plus faibles seront utilisés.</p>
+
+<h3 id="&lt;&lt;_(décalage_à_gauche)"><a name="Gauche">&lt;&lt; (décalage à gauche)</a></h3>
+
+<p>Cet opérateur décale le premier opérande du nombre de bits spécifié vers la gauche. Les bits surnuméraires éjectés à gauche sont perdus. Des bits à zéro sont insérés par la droite.</p>
+
+<p>Par exemple, <code>9 &lt;&lt; 2</code> donne 36 :</p>
+
+<pre class="eval">     9 (base 10) : 00000000000000000000000000001001 (base 2)
+                   --------------------------------
+9 &lt;&lt; 2 (base 10) : 00000000000000000000000000100100 (base 2) = 36 (base 10)
+</pre>
+
+<p>Décaler un nombre <strong>x</strong> de <strong>y</strong> bits vers la gauche renverra <math><semantics><mrow><mi>x</mi><mo>*</mo><msup><mn>2</mn><mi>y</mi></msup></mrow><annotation encoding="TeX">x*2^y</annotation></semantics></math>. Par exemple,  <code>9 &lt;&lt; 3</code> correspondra à <code>9 * (2 ** 3) = 9 * 8 = 72</code>.</p>
+
+<h3 id=">>_(décalage_à_droite_avec_propagation_du_signe)"><a name="Droite">&gt;&gt; (décalage à droite avec propagation du signe)</a></h3>
+
+<p>Cet opérateur décale le premier opérande du nombre de bits spécifié vers la droite. Les bits surnuméraires éjectés à droite sont perdus. Des copies du bit le plus à gauche sont insérés par la gauche. Comme le bit le plus a gauche a la même valeur qu'avant l'opération, le bit de signe (celui qui est le plus à gauche) ne change pas. D'où ce qu'on appelle la « propagation du signe ».</p>
+
+<p>Par exemple, <code>9 &gt;&gt; 2</code> donne 2 :</p>
+
+<pre class="eval">     9 (base 10) : 00000000000000000000000000001001 (base 2)
+                   --------------------------------
+9 &gt;&gt; 2 (base 10) : 00000000000000000000000000000010 (base 2) = 2 (base 10)
+</pre>
+
+<p>De même, <code>-9 &gt;&gt; 2</code> donne -3, parce que le signe est préservé :</p>
+
+<pre class="eval">     -9 (base 10) : 11111111111111111111111111110111 (base 2)
+                    --------------------------------
+-9 &gt;&gt; 2 (base 10) : 11111111111111111111111111111101 (base 2) = -3 (base 10)
+</pre>
+
+<h3 id=">>>_(décalage_à_droite_avec_insertion_de_zéros)"><a name="Droite_zero">&gt;&gt;&gt; (décalage à droite avec insertion de zéros)</a></h3>
+
+<p>Cet opérateur décale le premier opérande du nombre de bits spécifié vers la droite. Les bits surnuméraires éjectés à droite sont perdus. Des bits à zéro sont insérés par la gauche. Le bit de signe devient 0, donc le résultat est toujours positif. À la différence des autres opérateurs binaires, cette opération renvoie un entier non-signé sur 32 bits.</p>
+
+<p>Pour les nombres non négatifs, le décalage à droite avec insertion de zéros et le décalage à droite avec propagation du signe donnent le même résultat. Par exemple, <code>9 &gt;&gt;&gt; 2</code> donne 2, tout comme <code>9 &gt;&gt; 2</code> :</p>
+
+<pre class="eval">      9 (base 10) : 00000000000000000000000000001001 (base 2)
+                    --------------------------------
+9 &gt;&gt;&gt; 2 (base 10) : 00000000000000000000000000000010 (base 2) = 2 (base 10)
+</pre>
+
+<p>Cependant, ce n'est pas le cas des nombres négatifs. Par exemple, <code>-9 &gt;&gt;&gt; 2</code> donne 1073741821, ce qui est différent de <code>-9 &gt;&gt; 2</code> (qui donne -3) :</p>
+
+<pre class="eval">      -9 (base 10) : 11111111111111111111111111110111 (base 2)
+                     --------------------------------
+-9 &gt;&gt;&gt; 2 (base 10) : 00111111111111111111111111111101 (base 2) = 1073741821 (base 10)
+</pre>
+
+<h2 id="Exemples">Exemples</h2>
+
+<h3 id="Exemple_flags_et_bitmasks">Exemple : <em>flags</em> et <em>bitmasks</em></h3>
+
+<p>Les opérateurs logiques binaires sont souvent utilisés pour créer, manipuler et lire des séquences de<em>flags</em> , qui sont comme des variables binaires. On pourrait très bien utiliser des variables à la place de ces séquences binaires, mais des flags binaires prennent nettement moins de mémoire (par un facteur de 32).</p>
+
+<p>Supposons que l'on ait 4 flags :</p>
+
+<ul>
+ <li>flag A : nous avons une araignée</li>
+ <li>flag B : nous avons une belette</li>
+ <li>flag C : nous avons un chat</li>
+ <li>flag D : nous avons un dinosaure</li>
+</ul>
+
+<p>Ces flags sont représentés par une séquence de bits : DCBA. Lorsqu'un flag est <em>positionné</em>, il a une valeur de 1. Sinon, il a une valeur de 0. Supposons qu'une variable <code>flags</code> a la valeur binaire de 0101 :</p>
+
+<pre class="eval">var flags = 0x5;   // 0101 en binaire
+</pre>
+
+<p>Cette valeur indique :</p>
+
+<ul>
+ <li>le flag A est vrai (nous avons une araignée) ;</li>
+ <li>le flag B est faux (nous n'avons pas de belette) ;</li>
+ <li>le flag C est vrai (nous avons un chat) ;</li>
+ <li>le flag D est faux (nous n'avons pas de dinosaure).</li>
+</ul>
+
+<p>Comme les opérateurs binaires sont sur 32 bits, <code>0101</code> est en fait <code>00000000000000000000000000000101</code>, mais les zéros qui précèdent peuvent être négligés étant donné qu'ils ne contiennent aucune information significative.</p>
+
+<p>Un <em>bitmask</em> est une séquence de bits qui peuvent manipuler et/ou lire des flags. Typiquement, un masque « primitif » pour chaque flag est défini :</p>
+
+<pre class="eval">var FLAG_A = 0x1; // 0001
+var FLAG_B = 0x2; // 0010
+var FLAG_C = 0x4; // 0100
+var FLAG_D = 0x8; // 1000
+</pre>
+
+<p>De nouveaux masques peuvent être créés à l'aide des opérateurs logiques binaires sur ces masques primitifs. Par exemple, le masque <code>1011</code> peut être créé avec une opération OU sur <code>FLAG_A</code>, <code>FLAG_B</code> et <code>FLAG_D</code> :</p>
+
+<pre class="eval">var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 =&gt; 1011
+</pre>
+
+<p>Des valeurs de flag particulières peuvent être extraites à l'aide d'une opération ET avec un bitmask, où chaque bit avec la valeur 1 va « extraire » le flag qui correspond. Le bitmask <em>masque</em> les flags dont on n'a pas besoin en effectuant l'opération ET avec des zéros (d'où le terme « bitmask »). Par exemple, le masque 0100 peut être utilisé pour voir si le flag C est positionné :</p>
+
+<pre class="eval">// si l'on a un chat
+if (flags &amp; FLAG_C) { // 0101 &amp; 0100 =&gt; 0100 =&gt; true
+   // faire quelque chose
+}
+</pre>
+
+<p>Un masque avec plusieurs flags positionnés agit comme un « et/ou ». Par exemple, les deux instructions suivantes sont équivalentes :</p>
+
+<pre class="eval">// si on a une belette ou si on a un chat
+if ((flags &amp; FLAG_B) || (flags &amp; FLAG_C)) { // (0101 &amp; 0010) || (0101 &amp; 0100) =&gt; 0000 || 0100 =&gt; true
+   // faire quelque chose
+}
+</pre>
+
+<pre class="eval">// si on a une belette ou si on a un chat
+var mask = FLAG_B | FLAG_C; // 0010 | 0100 =&gt; 0110
+if (flags &amp; mask) { // 0101 &amp; 0110 =&gt; 0100 =&gt; true
+   // faire quelque chose
+}
+</pre>
+
+<p>Les flags peuvent être positionnés en utilisant l'opération OU avec un masque, où chaque bit de la valeur 1 définira le flag correspondant, si celui-ci n'est pas déjà positionné. Par exemple, le masque 1100 peut être utilisé pour positionner les flags C et D :</p>
+
+<pre class="eval">// oui, on a un chat et un dinosaure
+var mask = FLAG_C | FLAG_D; // 0100 | 1000 =&gt; 1100
+flags |= mask;   // 0101 | 1100 =&gt; 1101
+</pre>
+
+<p>Les flags peuvent être remis à zéro en utilisant l'opération ET avec un masque, où chaque bit avec la valeur 0 remettra à zéro le flag correspondant s'il ne l'est pas déjà. Ce masque peut être créé avec l'opération NOT sur les masques primitifs. Par exemple, le masque 1010 peut être utilisé pour remettre à zéro les flags A et C :</p>
+
+<pre class="eval">// non, nous n'avons pas d'araignée ou de chat
+var mask = ~(FLAG_A | FLAG_C); // ~0101 =&gt; 1010
+flags &amp;= mask;   // 1101 &amp; 1010 =&gt; 1000
+</pre>
+
+<p>Le masque aurait également pu être créé avec <code>~FLAG_A &amp; ~FLAG_C</code> (Loi de De Morgan) :</p>
+
+<pre class="eval">// non, nous n'avons pas d'araignée ou de chat
+var mask = ~FLAG_A &amp; ~FLAG_C;
+flags &amp;= mask;   // 1101 &amp; 1010 =&gt; 1000
+</pre>
+
+<p>Les flags peuvent être inversés en utilisant l'opération XOR avec un masque, où chaque bit avec la valeur 1 inversera le flag correspondant. Par exemple, le masque 0110 peut être utilisé pour inverser les flags B et C :</p>
+
+<pre class="eval">// si on n'avait pas de belette, on en a maintenant une.
+// si on en avait une, on ne l'a plus. Même chose pour les chats.
+var mask = FLAG_B | FLAG_C;
+flags = flags ^ mask;   // 1100 ^ 0110 =&gt; 1010
+</pre>
+
+<p>Finalement, les flags peuvent être tous inversés avec l'opérateur NON :</p>
+
+<pre class="eval">// entrée dans un univers parallèle...
+flags = ~flags;    // ~1010 =&gt; 0101
+</pre>
+
+<h3 id="Codes_de_conversion">Codes de conversion</h3>
+
+<p>Pour convertir une <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/String">String</a></code> binaire en un <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Number">Number</a></code> (en base 10):</p>
+
+<pre class="brush: js">var chaîneBinaire = "1011";
+var monNombre = parseInt(chaîneBinaire, 2);
+console.log(monNombre); // affiche 11 (1011 en base 2)
+</pre>
+
+<p>Pour convertir un <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Number">Number</a></code> (en base 10) en une <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/String">String</a></code> binaire :</p>
+
+<pre class="brush: js">var monNombre = 11;
+var chaîneBinaire = monNombre.toString(2);
+console.log(chaîneBinaire); // affiche 1011 (11 en base 10)
+</pre>
+
+<h3 id="Automatiser_la_création_d'un_masque">Automatiser la création d'un masque</h3>
+
+<p>Si vous devez créer plusieurs masques à partir de booléens, il est possible d'automatiser ce processus :</p>
+
+<pre class="brush: js">function créerMasque () {
+  var nMask = 0, nFlag = 0, nLen = arguments.length &gt; 32 ? 32 : arguments.length;
+  for (nFlag; nFlag &lt; nLen; nMask |= arguments[nFlag] &lt;&lt; nFlag++);
+  return nMask;
+}
+var masque1 = créerMasque(true, true, false, true); // 11, i.e.: 1011
+var masque2 = créerMasque(false, false, true); // 4, i.e.: 0100
+var masque3 = créerMasque(true); // 1, i.e.: 0001
+// etc.
+
+console.log(masque1); // affiche 11, i.e.: 1011
+</pre>
+
+<h3 id="Algorithme_réciproque_obtenir_un_tableau_de_booléen_à_partir_d'un_masque">Algorithme réciproque : obtenir un tableau de booléen à partir d'un masque</h3>
+
+<p>Si on souhaite créer un tableau de booléens à partir d'un masque, on pourra utiliser le code suivant :</p>
+
+<pre class="brush: js">function tableauMasque (nMask) {
+  // nMask doit être compris entre -2147483648 et 2147483647
+  if (nMask &gt; 0x7fffffff || nMask &lt; -0x80000000) {
+    throw new TypeError("tableauMasque - intervalle de valeur dépassé");
+  }
+  for (var nShifted = nMask, aFromMask = []; nShifted;
+       aFromMask.push(Boolean(nShifted &amp; 1)), nShifted &gt;&gt;&gt;= 1);
+  return aFromMask;
+}
+
+var tableau1 = tableauMasque(11);
+var tableau2 = tableauMasque(4);
+var tableau3 = tableauMasque(1);
+
+console.log("[" + tableau1.join(", ") + "]");
+// affiche "[true, true, false, true]", i.e.: 11, i.e.: 1011
+</pre>
+
+<p>On peut ainsi utiliser les deux algorithmes :</p>
+
+<pre class="brush: js">var test = 19; // un masque quelconque
+var résultat = créerMasque.apply(this, tableauMasque(test));
+
+console.log(résultat); // 19
+</pre>
+
+<p>Pour l'exemple (car il existe la méthode <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Number/toString">Number.toString(2)</a></code>), on peut également modifier l'algorithme précédent pour créer une chaîne à partir de la représentation binaire d'un nombre :</p>
+
+<pre class="brush: js">function créerChaîneBinaire(nMask) {
+  // nMask doit être compris entre -2147483648 et 2147483647
+  for (var nFlag = 0, nShifted = nMask, sMask = ""; nFlag &lt; 32;
+       nFlag++, sMask += String(nShifted &gt;&gt;&gt; 31), nShifted &lt;&lt;= 1);
+  return sMask;
+}
+
+var string1 = créerChaîneBinaire(11);
+var string2 = créerChaîneBinaire(4);
+var string3 = créerChaîneBinaire(1);
+
+console.log(string1);
+// affiche 00000000000000000000000000001011, i.e. 11
+</pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">Statut</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.7')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Définis au sein de plusieurs sections de la spécification : <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4.8">Opérateur NON binaire</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.7">Opérateurs binaires de décalage</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.10">Opérateurs binaires</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-bitwise-shift-operators')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Définis au sein de plusieurs sections de la spécification : <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-bitwise-not-operator">Opérateur NON binaire</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-bitwise-shift-operators">Opérateurs binaires de décalage</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-binary-bitwise-operators">Opérateurs binaires</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-bitwise-shift-operators')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Defined in several sections of the specification: <a href="http://tc39.github.io/ecma262/#sec-bitwise-not-operator">opérateur NON binaire</a>, <a href="http://tc39.github.io/ecma262/#sec-bitwise-shift-operators">opérateurs binaires de décalage</a>, <a href="http://tc39.github.io/ecma262/#sec-binary-bitwise-operators">opérateurs binaires</a></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.operators.bitwise")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_logiques">Les opérateurs logiques</a></li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/operators_d0fb75b0fac950a91a017a1f497c6a1f/index.html b/files/fr/conflicting/web/javascript/reference/operators_d0fb75b0fac950a91a017a1f497c6a1f/index.html
new file mode 100644
index 0000000000..6b82320d69
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/operators_d0fb75b0fac950a91a017a1f497c6a1f/index.html
@@ -0,0 +1,256 @@
+---
+title: Opérateurs logiques
+slug: Web/JavaScript/Reference/Opérateurs/Opérateurs_logiques
+tags:
+  - JavaScript
+  - Operator
+  - Reference
+translation_of: Web/JavaScript/Reference/Operators
+translation_of_original: Web/JavaScript/Reference/Operators/Logical_Operators
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>Les opérateurs logiques sont typiquement utilisés avec des valeurs booléennes (logiques) ; lorsque c'est le cas, ils renvoient une valeur booléenne également. Cependant, les opérateurs <code>&amp;&amp;</code> et <code>||</code> renvoient en réalité la valeur d'un des opérandes spécifiés. Si ces opérateurs sont utilisés avec des valeurs non booléennes, ils peuvent donc également renvoyer une valeur non booléenne.</p>
+
+<p>{{EmbedInteractiveExample("pages/js/expressions-logicaloperator.html")}}</p>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<h2 id="Description">Description</h2>
+
+<p>Les opérateurs logiques sont décrits dans le tableau suivant (les expressions indiquées comme opérandes peuvent être de n'importe quel type et pas nécessairement être booléennes au sens strict) :</p>
+
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <th>Opérateur</th>
+   <th>Usage</th>
+   <th>Description</th>
+  </tr>
+  <tr>
+   <td>ET logique (<code>&amp;&amp;</code>)</td>
+   <td><code><em>expr1</em> &amp;&amp;<em>expr2</em> </code></td>
+   <td>Renvoie <code>expr1</code> si cette expression peut être convertie en <code>false</code>, sinon renvoie <code>expr2</code>.</td>
+  </tr>
+  <tr>
+   <td>OU logique (<code>||</code>)</td>
+   <td><code><em>expr1</em> ||<em>expr2</em> </code></td>
+   <td>Renvoie <code>expr1</code> si cette expression peut être convertie en <code>true</code>, sinon renvoie <code>expr2</code>.</td>
+  </tr>
+  <tr>
+   <td>NON logique (<code>!</code>)</td>
+   <td><code>!<em>expr</em> </code></td>
+   <td>Renvoie <code>false</code> si son opérande unique peut être converti en <code>true</code>, sinon il renvoie <code>true</code>.</td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Si une valeur peut être convertie en <code>true</code>, on dit en anglais qu'elle est <em>truthy</em>. Pour <code>false</code> on dit qu'elle est <em>falsy</em>.</p>
+
+<p>Parmi les expressions qui peuvent être converties en <code>false</code>, citons celles qui seront évaluées à :</p>
+
+<ul>
+ <li><code>null</code>,</li>
+ <li><code>NaN</code>,</li>
+ <li><code>0</code>,</li>
+ <li>la chaîne vide (<code>""</code> ou <code>''</code> ou <code>``</code>),</li>
+ <li><code>undefined</code>.</li>
+</ul>
+
+<p>Même si les opérateurs <code>&amp;&amp;</code> et <code>||</code> peuvent être utilisés avec des opérandes qui ne sont pas des valeurs booléennes, ils peuvent toujours être considérés comme des opérateurs booléens puisque leurs valeurs de retour peuvent toujours être converties en valeurs booléennes.</p>
+
+<h3 id="Évaluation_court-circuit">Évaluation court-circuit</h3>
+
+<p>Comme les expressions logiques sont évaluées de gauche à droite, leur évaluation sera éventuellement « court-circuitée » à l'aide des règles suivantes :</p>
+
+<ul>
+ <li>l'évaluation de <code>false &amp;&amp;<em> n'importe quoi</em> </code> est court-circuitée en <code>false</code>.</li>
+ <li>l'évaluation de <code>true ||<em> n'importe quoi</em> </code> est court-circuitée en <code>true</code>.</li>
+</ul>
+
+<p>Les règles de la logique garantissent que ces évaluations seront toujours correctes. Notons que la partie<em>n'importe quoi</em> des expressions mentionnées ci-dessus ne sera jamais évaluée, et que tout effet de bord éventuel induit par cette évaluation ne se produira pas.</p>
+
+<p>Ainsi, les deux fonctions suivantes sont équivalentes :</p>
+
+<pre>function courtCircuit() {
+  // OU logique
+  faireQuelqueChose() || faireAutreChose();
+
+ faireQuelqueChose() &amp;&amp; faireAutreChose();
+}
+
+function évaluationÉquivalente() {
+  var orFlag = faireQuelqueChose();
+  if (!orFlag) {
+    faireAutreChose();
+  }
+
+  var andFlag = faireQuelqueChose();
+  if (andFlag) {
+    faireAutreChose();
+  }
+}
+</pre>
+
+<h3 id="Précédence_des_opérateurs">Précédence des opérateurs</h3>
+
+<p>Les expressions suivantes ne sont pas équivalentes en raison de <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Précédence_des_opérateurs">la précédence des opérateurs</a>. Cela permet de noter que l'opérande droit ne doit être qu'une seule expression (si nécessaire entourée de parenthèses).</p>
+
+<pre>true || false &amp;&amp; false   // renvoie true car &amp;&amp; est appliqué en premier
+(true || false) &amp;&amp; false // renvoie false car || est appliqué en premier grâce aux parenthèses</pre>
+
+<h3 id="ET_logique"><a name="Logical_AND">ET logique (<code>&amp;&amp;</code>)</a></h3>
+
+<p>Le code qui suit illustre comment utiliser l'opérateur <code>&amp;&amp;</code> (ET logique).</p>
+
+<pre>a1 = true  &amp;&amp; true      // t &amp;&amp; t renvoie true
+a2 = true  &amp;&amp; false     // t &amp;&amp; f renvoie false
+a3 = false &amp;&amp; true      // f &amp;&amp; t renvoie false
+a4 = false &amp;&amp; (3 == 4)  // f &amp;&amp; f renvoie false
+a5 = "Yip" &amp;&amp; "Yop"     // t &amp;&amp; t renvoie "Yop"
+a6 = false &amp;&amp; "Yop"     // f &amp;&amp; t renvoie false
+a7 = "Yop" &amp;&amp; false     // t &amp;&amp; f renvoie false
+a8 = ""    &amp;&amp; true      // f &amp;&amp; f renvoie ""
+a9 = false &amp;&amp; ""        // f &amp;&amp; f renvoie false
+</pre>
+
+<h3 id="OU_logique"><a name="Logical_OR">OU logique (<code>||</code>)</a></h3>
+
+<p>Le code qui suit illustre quelques exemples d'utilisation de l'opérateur <code>||</code> (OU logique).</p>
+
+<pre>o1 = true  || true       // t || t renvoie true
+o2 = false || true       // f || t renvoie true
+o3 = true  || false      // t || f renvoie true
+o4 = false || (3 == 4)   // f || f renvoie false
+o5 = "Yip" || "Yop"      // t || t renvoie "Yip"
+o6 = false || "Yip"      // f || t renvoie "Yip"
+o7 = "Yip" || false      // t || f renvoie "Yip"
+o8 = ""    || false      // f || f renvoie false
+o9 = false || ""         // f || f renvoie ""
+010 = false|| monObjet   // f || objet renvoie monObjet
+</pre>
+
+<h3 id="NON_logique!"><a name="Logical_NOT">NON logique(<code>!</code>)</a></h3>
+
+<p>Le code qui suit illustre quelques exemples d'utilisation de l'opérateur <code>!</code> (NON logique).</p>
+
+<pre>n1 = !true              // !t renvoie false
+n2 = !false             // !f renvoie true
+n3 = !""                // !f renvoie true
+n3 = !"Yop"             // !t renvoie false
+</pre>
+
+<h4 id="Utilisation_de_la_double_négation">Utilisation de la double négation</h4>
+
+<p>Il est possible d'utiliser deux fois le NON logique à la suite afin de forcer la conversion d'une valeur en un booléen. On obtiendra ainsi le booléen <code>true</code> si la valeur est équivalente à vrai et <code>false</code> si la valeur est équivalente à faux. Cette opération de conversion peut également être réalisée grâce à la fonction {{jsxref("Boolean")}}.</p>
+
+<pre class="brush: js">n1 = !!true;                 // une valeur équivalente à true renvoie true
+n2 = !!{};                   // un objet, même vide est toujours équivalent à true
+n3 = !!(new Boolean(false)); // même lorsque leur constructeur est Boolean !
+n4 = !!false;                // une valeur équivalente à false renvoie false
+n5 = !!"";                   // idem
+n6 = !!Boolean(false);       // ici Boolean n'est pas utilisé comme constructeur
+                             // et la valeur produite est bien équivalente à false</pre>
+
+<h3 id="Règles_de_conversions">Règles de conversions</h3>
+
+<h4 id="Convertir_un_ET_logique_avec_des_OU_logiques">Convertir un ET logique avec des OU logiques</h4>
+
+<p>L'opération suivante</p>
+
+<pre>condition1 &amp;&amp; condition2</pre>
+
+<p>sera toujours égale à :</p>
+
+<pre>!(!condition1 || !condition2)</pre>
+
+<h4 id="Convertir_un_OU_logique_avec_des_ET_logiques">Convertir un OU logique avec des ET logiques</h4>
+
+<p>L'opération suivante :</p>
+
+<pre>condition1 || condition2</pre>
+
+<p>sera toujours égale à :</p>
+
+<pre>!(!condition1 &amp;&amp; !condition2)</pre>
+
+<h4 id="Convertir_des_NON_logiques_successifs">Convertir des NON logiques successifs</h4>
+
+<p>Si on a l'opération suivante avec un booléen :</p>
+
+<pre>!!condition
+</pre>
+
+<p>elle sera toujours équivalente à</p>
+
+<pre>condition</pre>
+
+<h3 id="Retirer_les_parenthèses_imbriquées">Retirer les parenthèses imbriquées</h3>
+
+<p>Les expressions logiques sont évaluées de gauche à droite, il est donc possible de retirer certaines parenthèses d'une expression complexe grâce à quelques règles.</p>
+
+<h4 id="Retirer_les_parenthèses_dun_ET_imbriqué">Retirer les parenthèses d'un ET imbriqué</h4>
+
+<p>Cette opération :</p>
+
+<pre>condition1 || (condition2 &amp;&amp; condition3)</pre>
+
+<p>sera toujours équivalente à :</p>
+
+<pre>condition1 || condition2 &amp;&amp; condition3</pre>
+
+<h4 id="Retirer_les_parenthèses_dun_OU_imbriqué">Retirer les parenthèses d'un OU imbriqué</h4>
+
+<p>Cette opération :</p>
+
+<pre>condition1 &amp;&amp; (condition2 || condition3)</pre>
+
+<p>sera toujours équivalente à :</p>
+
+<pre>!(!condition1 || !condition2 &amp;&amp; !condition3)</pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Définition initiale.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.11')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Définis dans plusieurs sections de la spécification : <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.4.9">opérateur NON logique</a>, <a href="https://www.ecma-international.org/ecma-262/5.1/#sec-11.11">opérateurs logiques binaires</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-binary-logical-operators')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Définis dans plusieurs sections de la spécification : <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-logical-not-operator">opérateur NON logique</a>, <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-binary-logical-operators">opérateurs logiques binaires</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-binary-logical-operators')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Définis dans plusieurs sections de la spécification : <a href="https://tc39.github.io/ecma262/#sec-logical-not-operator">opérateur NON logique</a>, <a href="https://tc39.github.io/ecma262/#sec-binary-logical-operators">opérateurs logiques binaires</a></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<p class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p>
+
+<p>{{Compat("javascript.operators.logical")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li><a href="/fr/docs/Web/JavaScript/Reference/Op%C3%A9rateurs/Op%C3%A9rateurs_binaires">Les opérateurs binaires</a></li>
+ <li><a href="/fr/docs/Web/JavaScript/Guide/Types_et_grammaire#Les_littéraux_booléens">Le type primitif booléen</a></li>
+ <li>Le constructeur objet {{jsxref("Boolean")}}</li>
+</ul>
diff --git a/files/fr/conflicting/web/javascript/reference/statements/switch/index.html b/files/fr/conflicting/web/javascript/reference/statements/switch/index.html
new file mode 100644
index 0000000000..e2cc368115
--- /dev/null
+++ b/files/fr/conflicting/web/javascript/reference/statements/switch/index.html
@@ -0,0 +1,124 @@
+---
+title: default
+slug: Web/JavaScript/Reference/Instructions/default
+tags:
+  - JavaScript
+  - Keyword
+  - Reference
+translation_of: Web/JavaScript/Reference/Statements/switch
+translation_of_original: Web/JavaScript/Reference/Statements/default
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>Le mot-clé <strong><code>default</code> </strong>peut être utilisé à deux endroits en JavaScript : au sein d'une instruction {{jsxref("Instructions/switch", "switch")}} ou dans une instruction {{jsxref("Instructions/export", "export")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/statement-default.html")}}</div>
+
+<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p>
+
+<h2 id="Syntaxe">Syntaxe</h2>
+
+<p>Dans une instruction {{jsxref("Instructions/switch", "switch")}} :</p>
+
+<pre class="syntaxbox">switch (expression) {
+  case valeur1:
+    // Les instructions exécutées quand le résultat
+    // de l'expression vaut valeur1
+    [break;]
+  default:
+    // Les instructions exécutées quand aucune des valeurs
+    // ne correspond à la valeur de l'expression
+    [break;]
+}</pre>
+
+<p>Dans une instruction {{jsxref("Instructions/export", "export")}} :</p>
+
+<pre class="syntaxbox">export default <em>nomN</em> </pre>
+
+<h2 id="Description">Description</h2>
+
+<p>Pour plus de détails, voir les pages sur :</p>
+
+<ul>
+ <li>L'instruction {{jsxref("Instructions/switch", "switch")}} et</li>
+ <li>L'instruction {{jsxref("Instructions/export", "export")}}.</li>
+</ul>
+
+<h2 id="Exemples">Exemples</h2>
+
+<h3 id="Utiliser_default_dans_une_instruction_switch">Utiliser <code>default</code> dans une instruction <code>switch</code></h3>
+
+<p>Dans l'exemple qui suit, si <code>expr</code> vaut "Bananes" ou "Pommes", le programme exécutera les instructions correspondantes à chacune de ces valeurs. Le mot-clé <code>default</code> permettra d'indiquer des instructions à exécuter dans les autres cas (<code>expr</code> ne correspond à aucun des cas).</p>
+
+<pre class="brush: js">switch (expr) {
+  case "Bananes":
+    console.log("Les bananes sont à 1.59€ le kilo.");
+    break;
+  case "Pommes":
+    console.log("Les pommes sont à 0.78€ le kilo.");
+    break;
+  default:
+    console.log("Désolé, nous n'avons plus de " + expr + ".");
+}</pre>
+
+<h3 id="Utiliser_default_avec_export">Utiliser <code>default</code> avec <code>export</code></h3>
+
+<p>Si on souhaite exporter une seule valeur ou avoir une valeur par défaut dans un module, on peut utiliser un export avec <code>default</code> :</p>
+
+<pre class="brush: js">// module "mon-module.js"
+let cube = function cube(x) {
+  return x * x * x;
+}
+export default cube;</pre>
+
+<p>Dans un autre script, on pourra simplement faire référence à l'export par défaut :</p>
+
+<pre class="brush: js">// module "autre-module.js"
+import maFonction from 'mon-module';
+console.log(maFonction(3)); // 27
+</pre>
+
+<h2 id="Spécifications">Spécifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spécification</th>
+   <th scope="col">État</th>
+   <th scope="col">Commentaires</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-switch-statement', 'Instruction switch')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-exports', 'Exports')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-switch-statement', 'switch statement')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-exports', 'Exports')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2>
+
+<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
+
+<p>{{Compat("javascript.statements.default")}}</p>
+
+<h2 id="Voir_aussi">Voir aussi</h2>
+
+<ul>
+ <li>{{jsxref("Instructions/export", "export")}}</li>
+ <li>{{jsxref("Instructions/switch", "switch")}}</li>
+</ul>