fixes #4012 - update pages vs en-US (#4151)

* fixes #4012 - update pages vs en-US

* taking review into account

2 files changed, 110 insertions, 118 deletions

diff --git a/files/fr/web/javascript/reference/global_objects/date/tolocaledatestring/index.md b/files/fr/web/javascript/reference/global_objects/date/tolocaledatestring/index.md
index 3d0c471682..f1264dfd14 100644
--- a/files/fr/web/javascript/reference/global_objects/date/tolocaledatestring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/tolocaledatestring/index.md
@@ -1,151 +1,148 @@
 ---
 title: Date.prototype.toLocaleDateString()
 slug: Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString
-tags:
-  - Date
-  - Internationalisation
-  - JavaScript
-  - Méthode
-  - Prototype
-  - Reference
-  - i18n
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/toLocaleDateString
+browser-compat: javascript.builtins.Date.toLocaleDateString
 ---
 {{JSRef}}
 
-La méthode **`toLocaleDateString()`** renvoie une chaine de caractères correspondant à la date (le fragment de l'objet qui correspond à la date : jour, mois, année) exprimée selon une locale. Les arguments `locales` et `options` permettent aux applications de définir le langage utilisé pour les conventions de format et permettent de personnaliser le comportement de la fonction. Les anciennes implémentations ignorent ces arguments, la locale utilisée et le format de la chaine dépendent uniquement de l'implémentation.
+La méthode **`toLocaleDateString()`** renvoie une chaine de caractères correspondant à la date (le fragment de l'objet qui correspond à la date : jour, mois, année) exprimée selon une locale donnée et pour le fuseau horaire de l'agent utilisateur.
+
+Les arguments `locales` et `options` permettent aux applications de définir le langage utilisé pour les conventions de format et permettent de personnaliser le comportement de la fonction. Les anciennes implémentations ignoraient ces arguments, la locale utilisée et le format de la chaine dépendaient uniquement de l'implémentation.
 
 {{EmbedInteractiveExample("pages/js/date-tolocaledatestring.html")}}
 
 ## Syntaxe
 
-    dateObj.toLocaleDateString([locales [, options]])
+```js
+toLocaleDateString()
+toLocaleDateString(locales)
+toLocaleDateString(locales, options)
+```
 
 ### Paramètres
 
-Voir le tableau de [compatibilité des navigateurs](#compat) afin de déterminer quels navigateurs respectent les arguments `locales` et `options` ainsi que l'exemple [Vérifier le support des arguments locales et options](#check) qui permet de détecter cette fonctionnalité.
+Les arguments `locales` et `options` permettent d'adapter le comportement de la fonction et aux applications d'indiquer la locale pour laquelle utiliser les conventions de formatage.
 
-{{page('fr/docs/JavaScript/Reference/Objets_globaux/DateTimeFormat','Paramètres')}}
+Pour les implémentations qui ignorent les arguments `locales` et `options`, la locale utilisée et la forme de la chaîne de caractères résultante dépendent intégralement de l'implémentation.
 
-La valeur par défaut de chacun des composants de la date vaut {{jsxref("undefined")}}, si les propriétés `weekday`, `year`, `month`, `day` sont toutes `undefined`, on suppose alors que `year`, `month`, et `day` sont « numériques ».
+Voir [la page du constructeur `Intl.DateTimeFormat()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/DateTimeFormat) pour plus de détails sur ces paramètres et leur utilisation.
+
+La valeur par défaut pour chaque propriété composant la date/heure est [`undefined`](/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined), mais si les propriétés `weekday`, `year`, `month`, `day` valent toutes [`undefined`](/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined), alors `year`, `month`, et `day` sont considérés comme `"numeric"`.
 
 ### Valeur de retour
 
-Une chaîne de caractères qui représente le jour de la date indiquée selon des options de locales.
+Une chaîne de caractères qui représente le jour de la date courante (l'objet [`Date`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Date) sur lequel est appelée la méthode), dont le format dépend des options de locale fournies.
+
+## Performance
+
+Lorsqu'on formate une grande quantité de dates, mieux vaudra créer un objet [`Intl.DateTimeFormat`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat) et utiliser la fonction fournie par sa propriété [`format`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/format).
 
 ## Exemples
 
 ### Utiliser `toLocaleDateString()`
 
-Voici un usage simple qui ne définit pas de locale : une chaine de caractères dans une locale et avec des options par défaut est renvoyée.
+Voici un usage simple qui ne définit pas de locale : une chaine de caractères dans une locale et avec des options par défaut est renvoyée.
 
 ```js
-var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0));
+let date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0));
 
 // toLocaleDateString() sans argument, on utilise donc
 // les valeurs par défaut (de l'implémentation)
 // pour la locale, et le fuseau horaire
-date.toLocaleDateString();
-// → "12/12/2012" si exécuté dans une locale fr et le fuseau horaire CEST
+console.log(date.toLocaleDateString());
+// → "12/12/2012" si exécuté dans une locale fr et le fuseau horaire UTC+01:00
 ```
 
-### Vérifier le support des arguments `locales` et `options`
+### Vérifier la prise en charge des arguments `locales` et `options`
 
-Les arguments `locales` et `options` ne sont pas encore supportés par tous les navigateurs. Afin de vérifier si l'implementation utilisée les supporte, vous pouvez utiliser le pré-requis suivant : les locales incorrectes sont rejetées avec une exception` RangeError` :
+Afin de vérifier si l'implémentation prend en charge les arguments `locales` et `options`, vous pouvez utiliser le test suivant qui vérifie si les locales incorrectes sont rejetées avec une exception `RangeError` :
 
 ```js
 function toLocaleDateStringSupportsLocales() {
-    try {
-        new Date().toLocaleDateString("i");
-    } catch (e) {
-        return e​.name === "RangeError";
-    }
-    return false;
+  try {
+    new Date().toLocaleDateString("i");
+  } catch (e) {
+    return e.name === "RangeError";
+  }
+  return false;
 }
 ```
 
 ### Utiliser l'argument `locales`
 
-Cet exemple montre quelques variations dues aux formats de dates localisés. Afin d'obtenir le langage utilisé au sein de l'interface utilisateur de votre application, vérifiez de bien fournir ce langage (et éventuellement des locales de recours) en utilisant l'argument `locales` :
+Cet exemple montre quelques variations dues aux formats de dates localisés. Afin d'obtenir le langage utilisé au sein de l'interface utilisateur de votre application, vérifiez de bien fournir ce langage (et éventuellement des locales de recours) en utilisant l'argument `locales` :
 
 ```js
-var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+let date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
 
 // les formats qui suivent se basent sur le
 // fuseau horaire CEST
 
 // l'anglais américain utilise l'ordre mois-jour-année
-alert(date.toLocaleDateString("en-US"));
+console.log(date.toLocaleDateString("en-US"));
 // → "12/20/2012"
 
 // l'anglais britannique utilise l'ordre jour-mois-année
-alert(date.toLocaleDateString("en-GB"));
+console.log(date.toLocaleDateString("en-GB"));
 // → "20/12/2012"
 
 // le coréen utilise l'ordre année-mois-jour
-alert(date.toLocaleDateString("ko-KR"));
+console.log(date.toLocaleDateString("ko-KR"));
 // → "2012. 12. 20."
 
+// le perse utilise un calendrier solaire
+console.log(date.toLocaleDateString("fa-IR"));
+// → "۱۳۹۱/۹/۳۰"
+
 // l'arabe, dans la plupart des pays arabophones, utilise les chiffres arabes
-alert(date.toLocaleDateString("ar-EG"));
+console.log(date.toLocaleDateString("ar-EG"));
 // → "٢٠‏/١٢‏/٢٠١٢"
 
 // en ce qui concerne le japonais, les applications peuvent
 // souhaiter utiliser le calendrier japonais
 // pour lequel 2012 était l'année 24 de l'ère Heisei
-alert(date.toLocaleDateString("ja-JP-u-ca-japanese"));
+console.log(date.toLocaleDateString("ja-JP-u-ca-japanese"));
 // → "24/12/20"
 
-// quand un langage non support est demandé (ex : le balinais)
+// quand un langage non pris en charge est demandé (par exemple le balinais)
 // il est possible de fournir un langage de recours (ici l'indonésien)
-alert(date.toLocaleDateString(["ban", "id"]));
+console.log(date.toLocaleDateString(["ban", "id"]));
 // → "20/12/2012"
 ```
 
 ### Utiliser l'argument `options`
 
-Les résultats fournis par `toLocaleDateString()` peuvent être personnalisés grâce à l'argument `options` :
+Les résultats fournis par `toLocaleDateString()` peuvent être personnalisés grâce à l'argument `options` :
 
 ```js
-var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+let date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
 
-// fournir le jour de la semaine avec une date longe
-var options = {weekday: "long", year: "numeric", month: "long", day: "numeric"};
-alert(date.toLocaleDateString("de-DE", options));
+// fournir le jour de la semaine avec une date longue
+let options = {weekday: "long", year: "numeric", month: "long", day: "numeric"};
+console.log(date.toLocaleDateString("de-DE", options));
 // → "Donnerstag, 20. Dezember 2012"
 
 // une application peut vouloir utiliser
 // UTC et l'afficher
 options.timeZone = "UTC";
 options.timeZoneName = "short";
-alert(date.toLocaleDateString("en-US", options));
-// → "Thursday, December 20, 2012, GMT"
+console.log(date.toLocaleDateString("en-US", options));
+// → "Thursday, December 20, 2012, UTC"
 ```
 
-## Performance
-
-Lorsque des grands nombres ou de grandes dates sont formatés, il est préférable de créer un objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} et d'utiliser la fonction fournie par sa propriété {{jsxref("DateTimeFormat.prototype.format", "format")}}.
-
 ## Spécifications
 
-| Spécification                                                                                                                                    | État                             | Commentaires                                          |
-| ------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | ----------------------------------------------------- |
-| {{SpecName('ES3')}}                                                                                                                         | {{Spec2('ES3')}}             | Définition initiale. Implémentée avec JavaScript 1.0. |
-| {{SpecName('ES5.1', 'sec-15.9.5.6', 'Date.prototype.toLocaleDateString')}}                                             | {{Spec2('ES5.1')}}         |                                                       |
-| {{SpecName('ES6', '#sec-date.prototype.tolocaledatestring', 'Date.prototype.toLocaleDateString')}}             | {{Spec2('ES6')}}             |                                                       |
-| {{SpecName('ESDraft', '#sec-date.prototype.tolocaledatestring', 'Date.prototype.toLocaleDateString')}}         | {{Spec2('ESDraft')}}     |                                                       |
-| {{SpecName('ES Int 1.0', '#sec-13.3.2', 'Date.prototype.toLocaleDateString')}}                                         | {{Spec2('ES Int 1.0')}} | Définition des arguments `locales` et `options`.      |
-| {{SpecName('ES Int 2.0', '#sec-13.3.2', 'Date.prototype.toLocaleDateString')}}                                         | {{Spec2('ES Int 2.0')}} |                                                       |
-| {{SpecName('ES Int Draft', '#sec-Date.prototype.toLocaleDateString', 'Date.prototype.toLocaleDateString')}} | {{Spec2('ES Int Draft')}} |                                                       |
+{{Specifications}}
 
 ## Compatibilité des navigateurs
 
-{{Compat("javascript.builtins.Date.toLocaleDateString")}}
+{{Compat}}
 
 ## Voir aussi
 
-- {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}
-- {{jsxref("Date.prototype.toLocaleString()")}}
-- {{jsxref("Date.prototype.toLocaleTimeString()")}}
-- {{jsxref("Date.prototype.toString()")}}
+- [`Intl.DateTimeFormat`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat)
+- [`Date.prototype.toLocaleString()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString)
+- [`Date.prototype.toLocaleTimeString()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString)
+- [`Date.prototype.toString()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Date/toString)
diff --git a/files/fr/web/javascript/reference/global_objects/date/tolocalestring/index.md b/files/fr/web/javascript/reference/global_objects/date/tolocalestring/index.md
index 22c2f30587..f0bcc40dc2 100644
--- a/files/fr/web/javascript/reference/global_objects/date/tolocalestring/index.md
+++ b/files/fr/web/javascript/reference/global_objects/date/tolocalestring/index.md
@@ -1,34 +1,37 @@
 ---
 title: Date.prototype.toLocaleString()
 slug: Web/JavaScript/Reference/Global_Objects/Date/toLocaleString
-tags:
-  - Date
-  - Internationalisation
-  - JavaScript
-  - Méthode
-  - Prototype
-  - Reference
-  - i18n
 translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleString
 original_slug: Web/JavaScript/Reference/Objets_globaux/Date/toLocaleString
+browser-compat: javascript.builtins.Date.toLocaleString
 ---
 {{JSRef}}
 
-La méthode **`toLocaleString()`** renvoie une chaine de caractères représentant la date selon une locale. Les arguments `locales` et `options` permettent aux applications de définir le langage à utiliser pour les conventions de format et permettent de personnaliser le comportement de la fonction. Les anciennes implémentations ignorent ces arguments, la locale utilisée et le format de la chaine dépendent uniquement de l'implémentation.
+La méthode **`toLocaleString()`** renvoie une chaine de caractères représentant la date selon une locale.
+
+Les arguments `locales` et `options` permettent aux applications de définir le langage à utiliser pour les conventions de format et permettent de personnaliser le comportement de la fonction.
+
+Les anciennes implémentations ignoraient ces arguments, la locale et le format de la chaine alors utilisés dépendaient uniquement de l'implémentation.
 
 {{EmbedInteractiveExample("pages/js/date-tolocalestring.html")}}
 
 ## Syntaxe
 
-    dateObj.toLocaleString([locales [, options]])
+```js
+toLocaleString()
+toLocaleString(locales)
+toLocaleString(locales, options)
+```
 
 ### Paramètres
 
-Voir le tableau de [compatibilité des navigateurs](#compat "#Compatibilit.C3.A9_des_navigateurs") afin de déterminer quels navigateurs respectent les arguments `locales` et `options` ainsi que l'exemple [Vérifier le support des arguments `locales` et `options`](#check) qui permet de détecter cette fonctionnalité.
+Les arguments `locales` et `options` permettent d'adapter le comportement de la fonction et aux applications d'indiquer la locale pour laquelle utiliser les conventions de formatage.
+
+Pour les implémentations qui ignorent les arguments `locales` et `options`, la locale utilisée et la forme de la chaîne de caractères résultante dépendent intégralement de l'implémentation.
 
-{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/DateTimeFormat','Paramètres')}}
+Voir [la page du constructeur `Intl.DateTimeFormat()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/DateTimeFormat) pour plus de détails sur ces paramètres et leur utilisation.
 
-La valeur par défaut de chacun des composants de la date-heure vaut {{jsxref("undefined")}}, mais si les propriétés `weekday`, `year`, `month`, `day`, `hour`, `minute`, `second` sont toutes {{jsxref("undefined")}},  alors  `weekday`, `year`, `month`, `day`, `hour`, `minute` et `second` sont supposés être "numeric".
+La valeur par défaut de chacun des composants de la date-heure vaut [`undefined`](/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined), mais si les propriétés `weekday`, `year`, `month`, `day`, `hour`, `minute`, `second` sont toutes [`undefined`](/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined), alors `weekday`, `year`, `month`, `day`, `hour`, `minute` et `second` sont supposés être `"numeric"`.
 
 ### Valeur de retour
 
@@ -38,50 +41,50 @@ Une chaîne de caractères représentant la date indiquée selon des conventions
 
 ### Utiliser `toLocaleString()`
 
-Voici un usage simple qui ne définit pas de locale : une chaine de caractères dans une locale et avec des options par défaut est renvoyée.
+Voici un usage simple qui ne définit pas de locale : une chaine de caractères dans une locale et avec des options par défaut est renvoyée.
 
 ```js
-var date = new Date(Date.UTC(2014, 11, 21, 3, 0, 0));
+let date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0));
 
 // toLocaleString() sans argument, on utilise donc
 // les valeurs par défaut (de l'implémentation)
 // pour la locale, et le fuseau horaire
-date.toLocaleString();
-// → "21/12/2014 04:00:00" si exécuté dans une locale fr et le fuseau horaire CEST
+console.log(date.toLocaleString());
+// → "12/12/2012, 04:00:00" si exécuté dans une locale fr et le fuseau horaire UTC+01:00
 ```
 
-### Vérifier le support des arguments `locales` et `options`
+### Vérifier la prise en charge des arguments `locales` et `options`
 
-Les arguments `locales` et `options` ne sont pas encore supportés par tous les navigateurs. Afin de vérifier si l'implementation utilisée les supporte, vous pouvez utiliser le pré-requis suivant : les locales incorrectes sont rejetées avec une exception {{jsxref("RangeError")}} :
+Afin de vérifier si l'implémentation prend en charge les arguments `locales` et `options`, vous pouvez utiliser le test suivant qui vérifie si les locales incorrectes sont rejetées avec une exception `RangeError` :
 
 ```js
 function toLocaleStringSupportsLocales() {
-    try {
-        new Date().toLocaleString("i");
-    } catch (e) {
-        return e​ instanceof RangeError;
-    }
-    return false;
+  try {
+    new Date().toLocaleString("i");
+  } catch (e) {
+    return e.name === "RangeError";
+  }
+  return false;
 }
 ```
 
 ### Utiliser `locales`
 
-Cet exemple montre quelques variations dues aux formats de dates localisés. Afin d'obtenir le langage utilisé au sein de l'interface utilisateur de votre application, vérifiez de bien fournir ce langage (et éventuellement des locales de recours) en utilisant l'argument `locales` :
+Cet exemple montre quelques variations dues aux formats de dates localisés. Afin d'obtenir le langage utilisé au sein de l'interface utilisateur de votre application, vérifiez de bien fournir ce langage (et éventuellement des locales de recours) en utilisant l'argument `locales` :
 
 ```js
-var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+let date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
 
 // les formats qui suivent se basent sur le
 // fuseau horaire CEST
 
-l'anglais américain utilise l'ordre mois-jour-année
+// l'anglais américain utilise l'ordre mois-jour-année
 console.log(date.toLocaleString("en-US"));
 // → "12/20/2012, 4:00:00 AM"
 
 // l'anglais britannique utilise l'ordre jour-mois-année
 console.log(date.toLocaleString("en-GB"));
-// → "20/12/2012 04:00:00"
+// → "20/12/2012, 04:00:00"
 
 // le coréen utilise l'ordre année-mois-jour
 console.log(date.toLocaleString("ko-KR"));
@@ -95,9 +98,9 @@ console.log(date.toLocaleString("ar-EG"));
 // souhaiter utiliser le calendrier japonais
 // pour lequel 2012 était l'année 24 de l'ère Heisei
 console.log(date.toLocaleString("ja-JP-u-ca-japanese"));
-// → "24/12/20 4:00:00"
+// → "H24/12/20 4:00:00"
 
-// quand un langage non support est demandé (ex : le balinais)
+// quand un langage non pris en charge est demandé (par exemple le balinais)
 // il est possible de fournir un langage de recours (ici l'indonésien)
 console.log(date.toLocaleString(["ban", "id"]));
 // → "20/12/2012 04.00.00"
@@ -105,64 +108,56 @@ console.log(date.toLocaleString(["ban", "id"]));
 
 ### Utiliser `options`
 
-Les résultats fournis par `toLocaleString()` peuvent être personnalisés grâce à l'argument `options` :
+Les résultats fournis par `toLocaleString()` peuvent être personnalisés grâce à l'argument `options` :
 
 ```js
-var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+let date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
 
 // obtenir le jour de la semaine avec une date longue
-var options = {weekday: "long", year: "numeric", month: "long", day: "numeric"};
+let options = {weekday: "long", year: "numeric", month: "long", day: "numeric"};
+
 console.log(date.toLocaleString("de-DE", options));
 // → "Donnerstag, 20. Dezember 2012"
 
 // une application peut vouloir utiliser UTC et le rendre visible
 options.timeZone = "UTC";
 options.timeZoneName = "short";
+
 console.log(date.toLocaleString("en-US", options));
-// → "Thursday, December 20, 2012, GMT"
+// → "Thursday, December 20, 2012, UTC"
 
 // parfois, même les USA ont besoin d'avoir une heure sur 24h
 console.log(date.toLocaleString("en-US", {hour12: false}));
 // → "12/19/2012, 19:00:00"
 ```
 
-### Comparaison des dates formatées et des valeurs statiques
+### Éviter de comparer des dates formatées et des valeurs statiques
+
+La plupart du temps, le format renvoyé par `toLocaleString()` est cohérent. Toutefois, cela peut évoluer à l'avenir et n'est pas garanti pour l'ensemble des langues (de telles variations sont souhaitables et permises par la spécification).
 
-La plupart du temps, le format renvoyé par `toLocaleString()` est cohérent. Toutefois, cela peut évoluer à l'avenir et n'est pas garanti pour l'ensemble des langues (de telles variations sont souhaitables et permises par la spécification). Ainsi, IE et Edge ajoutent des caractères de contrôle bidirectionnels autour des dates afin que le texte produit ait une directionalité cohérente avec le texte avec lequel elles seront concaténées.
+Ainsi, IE et Edge ajoutent des caractères de contrôle bidirectionnels autour des dates afin que le texte produit ait une directionalité cohérente avec le texte avec lequel elles seront concaténées.
 
-Aussi, mieux vaut ne pas comparer un résultat fourni par `format()` avec une valeur statique :
+Aussi, mieux vaut ne pas comparer un résultat fourni par `toLocaleString()` avec une valeur statique :
 
 ```js example-bad
-"1.1.2019, 01:00:00" === new Date("2019-01-01T00:00:00.000000Z").toLocaleString();
+"1/1/2019, 01:00:00" === new Date("2019-01-01T00:00:00Z").toLocaleString("en-US");
 // true pour Firefox et les autres
 // false pour IE et Edge
 ```
 
-> **Note :** Voir aussi ce fil [StackOverflow](https://stackoverflow.com/questions/25574963/ies-tolocalestring-has-strange-characters-in-results) pour plus de détails et d'exemples.
-
-## Performance
-
-Quand vous formatez d'importants volumes de dates, il est préférable de créer un objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}} et d'utiliser la fonction fournie via la propriété {{jsxref("DateTimeFormat.prototype.format", "format")}}.
+> **Note :** Voir aussi [ce fil StackOverflow](https://stackoverflow.com/questions/25574963/ies-tolocalestring-has-strange-characters-in-results) pour plus de détails et d'exemples.
 
 ## Spécifications
 
-| Spécification                                                                                                                        | État                             | Commentaires                                          |
-| ------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------- | ----------------------------------------------------- |
-| {{SpecName('ES1')}}                                                                                                             | {{Spec2('ES1')}}             | Définition initiale. Implémentée avec JavaScript 1.0. |
-| {{SpecName('ES5.1', '#sec-15.9.5.5', 'Date.prototype.toLocaleString')}}                                     | {{Spec2('ES5.1')}}         |                                                       |
-| {{SpecName('ES6', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleString')}}             | {{Spec2('ES6')}}             |                                                       |
-| {{SpecName('ESDraft', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleString')}}         | {{Spec2('ESDraft')}}     |                                                       |
-| {{SpecName('ES Int 1.0', '#sec-13.3.1', 'Date.prototype.toLocaleString')}}                                 | {{Spec2('ES Int 1.0')}} | Définition des arguments `locales` et `options`.      |
-| {{SpecName('ES Int 2.0', '#sec-13.3.1', 'Date.prototype.toLocaleString')}}                                 | {{Spec2('ES Int 2.0')}} |                                                       |
-| {{SpecName('ES Int Draft', '#sec-Date.prototype.toLocaleString', 'Date.prototype.toLocaleString')}} | {{Spec2('ES Int Draft')}} |                                                       |
+{{Specifications}}
 
 ## Compatibilité des navigateurs
 
-{{Compat("javascript.builtins.Date.toLocaleString")}}
+{{Compat}}
 
 ## Voir aussi
 
-- {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}
-- {{jsxref("Date.prototype.toLocaleDateString()")}}
-- {{jsxref("Date.prototype.toLocaleTimeString()")}}
-- {{jsxref("Date.prototype.toString()")}}
+- [`Intl.DateTimeFormat`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat)
+- [`Date.prototype.toLocaleDateString()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString)
+- [`Date.prototype.toLocaleTimeString()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString)
+- [`Date.prototype.toString()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Date/toString)