From 39f2114f9797eb51994966c6bb8ff1814c9a4da8 Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 12:36:08 +0100 Subject: unslug fr: move --- .../intl/collator/compare/index.html | 102 +++++ .../global_objects/intl/collator/index.html | 178 +++++++++ .../intl/collator/resolvedoptions/index.html | 98 +++++ .../intl/collator/supportedlocalesof/index.html | 98 +++++ .../intl/datetimeformat/format/index.html | 126 ++++++ .../intl/datetimeformat/formatrange/index.html | 82 ++++ .../datetimeformat/formatrangetoparts/index.html | 73 ++++ .../intl/datetimeformat/formattoparts/index.html | 166 ++++++++ .../global_objects/intl/datetimeformat/index.html | 297 ++++++++++++++ .../intl/datetimeformat/resolvedoptions/index.html | 105 +++++ .../datetimeformat/supportedlocalesof/index.html | 98 +++++ .../intl/getcanonicallocales/index.html | 73 ++++ .../reference/global_objects/intl/index.html | 163 ++++++++ .../intl/listformat/format/index.html | 68 ++++ .../intl/listformat/formattoparts/index.html | 90 +++++ .../global_objects/intl/listformat/index.html | 153 ++++++++ .../intl/listformat/resolvedoptions/index.html | 82 ++++ .../intl/listformat/supportedlocalesof/index.html | 88 +++++ .../global_objects/intl/locale/basename/index.html | 75 ++++ .../global_objects/intl/locale/calendar/index.html | 156 ++++++++ .../intl/locale/casefirst/index.html | 94 +++++ .../intl/locale/collation/index.html | 167 ++++++++ .../intl/locale/hourcycle/index.html | 95 +++++ .../global_objects/intl/locale/index.html | 74 ++++ .../global_objects/intl/locale/language/index.html | 69 ++++ .../global_objects/intl/locale/maximize/index.html | 78 ++++ .../global_objects/intl/locale/minimize/index.html | 80 ++++ .../intl/locale/numberingsystem/index.html | 425 +++++++++++++++++++++ .../global_objects/intl/locale/numeric/index.html | 69 ++++ .../global_objects/intl/locale/region/index.html | 71 ++++ .../global_objects/intl/locale/script/index.html | 68 ++++ .../global_objects/intl/locale/tostring/index.html | 69 ++++ .../intl/numberformat/format/index.html | 97 +++++ .../intl/numberformat/formattoparts/index.html | 152 ++++++++ .../global_objects/intl/numberformat/index.html | 203 ++++++++++ .../intl/numberformat/resolvedoptions/index.html | 112 ++++++ .../numberformat/supportedlocalesof/index.html | 98 +++++ .../global_objects/intl/pluralrules/index.html | 160 ++++++++ .../intl/pluralrules/resolvedoptions/index.html | 95 +++++ .../intl/pluralrules/select/index.html | 79 ++++ .../intl/pluralrules/supportedlocalesof/index.html | 84 ++++ .../intl/relativetimeformat/format/index.html | 103 +++++ .../relativetimeformat/formattoparts/index.html | 86 +++++ .../intl/relativetimeformat/index.html | 162 ++++++++ .../relativetimeformat/resolvedoptions/index.html | 100 +++++ .../supportedlocalesof/index.html | 87 +++++ 46 files changed, 5348 insertions(+) create mode 100644 files/fr/web/javascript/reference/global_objects/intl/collator/compare/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/collator/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/collator/resolvedoptions/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/collator/supportedlocalesof/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/datetimeformat/format/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formatrange/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formatrangetoparts/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formattoparts/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/datetimeformat/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/datetimeformat/resolvedoptions/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/datetimeformat/supportedlocalesof/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/getcanonicallocales/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/listformat/format/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/listformat/formattoparts/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/listformat/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/listformat/resolvedoptions/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/listformat/supportedlocalesof/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/locale/basename/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/locale/calendar/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/locale/casefirst/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/locale/collation/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/locale/hourcycle/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/locale/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/locale/language/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/locale/maximize/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/locale/minimize/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/locale/numberingsystem/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/locale/numeric/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/locale/region/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/locale/script/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/locale/tostring/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/numberformat/format/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/numberformat/formattoparts/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/numberformat/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/numberformat/resolvedoptions/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/numberformat/supportedlocalesof/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/pluralrules/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/pluralrules/resolvedoptions/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/pluralrules/select/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/pluralrules/supportedlocalesof/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/format/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/formattoparts/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/resolvedoptions/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/supportedlocalesof/index.html (limited to 'files/fr/web/javascript/reference/global_objects/intl') diff --git a/files/fr/web/javascript/reference/global_objects/intl/collator/compare/index.html b/files/fr/web/javascript/reference/global_objects/intl/collator/compare/index.html new file mode 100644 index 0000000000..b120729383 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/collator/compare/index.html @@ -0,0 +1,102 @@ +--- +title: Intl.Collator.prototype.compare +slug: Web/JavaScript/Reference/Objets_globaux/Intl/Collator/compare +tags: + - Collator + - Internationalisation + - Intl + - JavaScript + - Méthode + - Prototype + - Reference + - i18n +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator/compare +--- +
{{JSRef}}
+ +

La méthode Intl.Collator.prototype.compare() compare deux chaînes de caractères en tenant compte des options spécifiées pour la locale et l'ordre de tri dans l'objet {{jsxref("Collator")}}.

+ +
{{EmbedInteractiveExample("pages/js/intl-collator-prototype-compare.html")}}
+ + + +

Syntaxe

+ +
collator.compare(chaine1, chaine2)
+ +

Paramètres

+ +
+
chaine1
+
chaine2
+
Les chaînes de caractères à comparer.
+
+ +

Description

+ +

L'accesseur compare renvoie un nombre qui indique le résultat de la comparaison entre chaine1 et chaine2 selon l'ordre de tri de l'objet {{jsxref("Collator")}} : la valeur obtenue sera négative si chaine1 précède chaine2, positive si chaine1 succède à chaine2, nulle si les deux chaînes sont considérées égales.

+ +

Exemples

+ +

Utiliser compare() pour trier un tableau

+ +

Dans cet exemple, on utilise la fonction de l'accesseur compare pour trier des tableaux. On observe que la fonction est liée à l'objet Collator, on peut donc directement la passer à la méthode {{jsxref("Array.prototype.sort()")}}.

+ +
var a = ["Offenbach", "Österreich", "Odenwald"];
+var collator = new Intl.Collator("de-u-co-phonebk");
+a.sort(collator.compare);
+console.log(a.join(", "));
+// → "Odenwald, Österreich, Offenbach"
+ +

Utiliser compare() pour chercher dans un tableau

+ +

Ici, on utilise la fonction de l'accesseur compare pour trouver les chaînes égales à une chaîne donnée parmi un tableau :

+ +
var a = ["Congrès", "congres", "Assemblée", "poisson"];
+var collator = new Intl.Collator("fr", {usage: "search", sensitivity: "base"});
+var s = "congres";
+var matches = a.filter(function (v) {
+    return collator.compare(v, s) === 0;
+});
+console.log(matches.join(", "));
+// → "Congrès, congres"
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpécificationStatutCommentaires
{{SpecName('ES Int 1.0', '#sec-10.3.2', 'Intl.Collator.prototype.compare')}}{{Spec2('ES Int 1.0')}}Définition initiale.
{{SpecName('ES Int 2.0', '#sec-10.3.2', 'Intl.Collator.prototype.compare')}}{{Spec2('ES Int 2.0')}} 
{{SpecName('ES Int Draft', '#sec-Intl.Collator.prototype.compare', 'Intl.Collator.prototype.compare')}}{{Spec2('ES Int Draft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.Collator.compare")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/collator/index.html b/files/fr/web/javascript/reference/global_objects/intl/collator/index.html new file mode 100644 index 0000000000..3130eed3b8 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/collator/index.html @@ -0,0 +1,178 @@ +--- +title: Intl.Collator +slug: Web/JavaScript/Reference/Objets_globaux/Intl/Collator +tags: + - Collator + - Constructeur + - Internationalisation + - Intl + - JavaScript + - Reference + - i18n +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator +--- +
{{JSRef}}
+ +

L'objet Intl.Collator est un constructeur de « collecteurs », des objets permettant de comparer des chaînes de caractères en tenant compte de la locale.

+ +
{{EmbedInteractiveExample("pages/js/intl-collator.html")}}
+ + + +

Syntaxe

+ +
new Intl.Collator([locales [, options]])
+ +

Paramètres

+ +
+
locales
+
+

Une chaîne de caractères avec une balise de langue BCP 47 ou un tableau qui contient des chaînes dans ce format. Pour plus d'informations sur le format et l'interprétation de l'argument locales, voir la page {{jsxref("Objets_globaux/Intl", "Intl", "#Choix_de_la_locale")}}. Pour ce constructeur, les clés d'extensions Unicode suivantes sont acceptées :

+ +
+
co
+
Les variantes dans les méthodes de regroupement (« collation ») des chaînes de caractères. Les valeurs autorisées pour cette clé sont : "big5han", "dict", "direct", "ducet", "gb2312", "phonebk", "phonetic", "pinyin", "reformed", "searchjl", "stroke", "trad", "unihan". Les valeurs "standard" et "search" sont ignorées. Elles sont remplacées par la propriété usage de l'argument options (voir ci-après).
+
kn
+
Indique si on ordonne les nombres (par exemple : "1" < "2" < "10"). Les valeurs possibles sont "true" et "false". Cette option est également disponible via une propriété de l'objet options. Si l'extension Unicode et la propriété de l'objet options sont définies, ce sera cette dernière qui sera prise en compte.
+
kf
+
Indique si on ordonne les majuscules avant les minuscules ou l'inverse. Les valeurs possibles sont "upper", "lower", ou "false" (on utilise alors l'ordre par défaut de la locale). Cette option est également disponible via une propriété de l'objet options. Si l'extension Unicode et la propriété de l'objet options sont définies, ce sera cette dernière qui sera prise en compte.
+
+
+
options
+
+

Un objet qui disposent des propriétés suivantes :

+ +
+
localeMatcher
+
L'algorithme de correspondance à utiliser pour les locales. Les valeurs possibles sont "lookup" et "best fit". La valeur par défaut est "best fit". Voir la {{jsxref("Objets_globaux/Intl", "Intl", "#Choix_de_la_locale")}} pour plus d'informations à ce sujet.
+
usage
+
Indique l'usage de le comparaison : le tri ou la recherche de chaînes correspondantes. Les valeurs possibles sont "sort" pour le tri et "search" pour la recherche. La valeur par défaut est "sort".
+
sensitivity
+
Indique les différences entre les chaînes de caractères qui font qu'une chaîne est considérée différente d'une autre. Les valeurs possibles sont : +
    +
  • "base" : Seules les chaînes dont les lettres de base sont différentes sont considérées inégales. Par exemple : a ≠ b, a = á, a = A.
    • +
  • "accent" : Seules les chaînes de caractères dont les lettres de bases ou les accents ou les autres marques diacritiques diffèrent sont considérées inégales. Par exemple : a ≠ b, a ≠ á, a = A.
    • +
  • "case" : Seules les chaines dont les lettres de base ou la casse sont diffèrent sont considérées comme inégales. Par exemple : a ≠ b, a = á, a ≠ A.
    • +
  • "variant" : Les chaînes qui diffèrent par leurs caractères de base, leurs accents et autres marques diacritiques, la casse sont considérées comme inégales. D'autres différences peuvent également être prises en compte. Par exemple : a ≠ b, a ≠ á, a ≠ A.
    • +
+ +

La valeur par défaut est "variant" si on utilise la comparaison pour du tri (usage="sort"). Pour l'utilisation "search" (recherche), la valeur par défaut dépend de la locale.

+
+
ignorePunctuation
+
Indique si la ponctuation doit être ignorée. Les valeurs possibles sont true et false. La valeur par défaut est false.
+
numeric
+
Indique si on ordonne les nombres (par exemple : "1" < "2" < "10"). Les valeurs possibles sont true et false. La valeur par défaut est false. Si l'extension Unicode correspondante et la propriété de l'objet options sont définies, ce sera cette dernière qui sera prise en compte.
+
caseFirst
+
Indique si on ordonne les majuscules avant les minuscules ou l'inverse. Les valeurs possibles sont "upper", "lower", ou "false" (on utilise alors l'ordre par défaut de la locale), la valeur par défaut est "false". Si l'extension Unicode correspondante et la propriété de l'objet options sont définies, ce sera cette dernière qui sera prise en compte.
+
+
+
+ +

Description

+ +

L'objet Intl.Collator possède les propriétés et méthodes suivantes :

+ +

Propriétés

+ +
+
{{jsxref("Collator.prototype", "Intl.Collator.prototype")}}
+
Permet d'ajouter des propriétés à toutes les instances.
+
+ +

Méthodes

+ +
+
{{jsxref("Collator.supportedLocalesOf", "Intl.Collator.supportedLocalesOf()")}}
+
Renvoie un tableau qui contient les locales supportées pour lesquelles il n'est pas nécessaire de revenir à la locale par défaut de l'environnement.
+
+ +

Instances de Collator

+ +

Propriétés

+ +

Les instances de Collator héritent des propriétés suivantes grâce à leur prototype :

+ +
{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Collator/prototype','Propriétés')}}
+ +

Méthodes

+ +
+

Les instances de Collator héritent des méthodes suivantes grâce à leur prototype :

+{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Collator/prototype','Méthodes')}}
+ +

Exemples

+ +

Utiliser Collator

+ +

L'exemple qui suit illustre les différents résultats qu'on peut obtenir :

+ +
console.log(new Intl.Collator().compare('a', 'c')); // → une valeur négative
+console.log(new Intl.Collator().compare('c', 'a')); // → une valeur positive
+console.log(new Intl.Collator().compare('a', 'a')); // → 0
+
+ +

Les résultats indiqués sont génériques et en pratique peuvent varier entre les navigateurs et les versions des navigateurs. En effet les valeurs obtenues dépendent de l'implémentation. Les spécifications indiquent uniquement le signe (positif ou négatif) du résultat.

+ +

Utiliser locales

+ +

Les résultats fournis par {{jsxref("Collator.prototype.compare()")}} varient selon les locales. Afin d'obtenir le bon ordre lexicographique dans votre application, il est nécessaire de spécifier la locale de l'utilisateur (et éventuellement des locales pour des cas de replis) en utilisant l'argument locales :

+ +
// en allemand, 'ä' est équivalent à 'a' pour le tri
+console.log(new Intl.Collator("de").compare("ä", "z"));
+// → une valeur négative
+
+// en suédois, 'ä' arrive après 'z'
+console.log(new Intl.Collator("sv").compare("ä", "z"));
+// → une valeur positive
+
+ +

Utiliser options

+ +

Les résultats fournis par {{jsxref("Collator.prototype.compare()")}} peuvent être adaptés grâce à l'argument options :

+ +
// en allemand, 'ä' est composé de la lettre de base 'a'
+console.log(new Intl.Collator("de", {sensitivity: "base"}).compare("ä", "a"));
+// → 0
+
+// en suédois, 'ä' et 'a' sont distincts en termes de base
+console.log(new Intl.Collator("sv", {sensitivity: "base"}).compare("ä", "a"));
+// → une valeur positive
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES Int 1.0', '#sec-10.1', 'Intl.Collator')}}{{Spec2('ES Int 1.0')}}Définition initiale.
{{SpecName('ES Int 2.0', '#sec-10.1', 'Intl.Collator')}}{{Spec2('ES Int 2.0')}} 
{{SpecName('ES Int Draft', '#collator-objects', 'Intl.Collator')}}{{Spec2('ES Int Draft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.Collator")}}

+ +

Voir aussi

+ +

{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl','Voir_aussi')}}

diff --git a/files/fr/web/javascript/reference/global_objects/intl/collator/resolvedoptions/index.html b/files/fr/web/javascript/reference/global_objects/intl/collator/resolvedoptions/index.html new file mode 100644 index 0000000000..d7cd3ad5e0 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/collator/resolvedoptions/index.html @@ -0,0 +1,98 @@ +--- +title: Intl.Collator.prototype.resolvedOptions() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/Collator/resolvedOptions +tags: + - Collator + - Internationalisation + - Intl + - JavaScript + - Méthode + - Prototype + - Reference + - i18n +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator/resolvedOptions +--- +
{{JSRef}}
+ +

La méthode Intl.Collator.prototype.resolvedOptions() renvoie un nouvel objet dont les propriétés reflètent les options de locale et de collation calculées à l'initialisation de l'objet {{jsxref("Collator")}}.

+ +
{{EmbedInteractiveExample("pages/js/intl-collator-prototype-resolvedoptions.html")}}
+ + + +

Syntaxe

+ +
collator.resolvedOptions()
+ +

Valeur de retour

+ +

Un nouvel objet dont les propriétés reflètent les options de locale et de collations calculées lors de l'initialisation de l'objet {{jsxref("Collator")}}.

+ +

Description

+ +

L'objet renvoyé par cette méthode contient les propriétés suivantes :

+ +
+
locale
+
La balise de langue BCP 47 qui est réellement utilisée. Si des extensions Unicode étaient fournies avec la balise d'origine et sont supportées pour la locale utilisée, les paires de clés-valeurs seront incluses dans locale.
+
usage
+
sensitivity
+
ignorePunctuation
+
Les valeurs demandées pour ces propriétés via l'argument options ou celles utilisées par défaut.
+
collation
+
La valeur demandée pour l'extension Unicode "co" si elle est supportée par la locale utilisée, sinon "default".
+
numeric
+
caseFirst
+
Les valeurs demandées pour ces propriétés via l'argument options ou l'utilisation des extensions Unicode "kn" et "kf" ou les valeurs par défaut. Si l'implémentation utilisée ne supporte pas ces propriétés, elles sont omises.
+
+ +

Exemples

+ +
var de = new Intl.Collator('de', { sensitivity: 'base' })
+var usedOptions = de.resolvedOptions();
+
+usedOptions.locale;            // "de"
+usedOptions.usage;             // "sort"
+usedOptions.sensitivity;        // "base"
+usedOptions.ignorePunctuation; // false
+usedOptions.collation;         // "default"
+usedOptions.numeric;           // false
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES Int 1.0', '#sec-10.3.3', 'Intl.Collator.prototype.resolvedOptions')}}{{Spec2('ES Int 1.0')}}Définition initiale.
{{SpecName('ES Int 2.0', '#sec-10.3.3', 'Intl.Collator.prototype.resolvedOptions')}}{{Spec2('ES Int 2.0')}}
{{SpecName('ES Int Draft', '#sec-Intl.Collator.prototype.resolvedOptions', 'Intl.Collator.prototype.resolvedOptions')}}{{Spec2('ES Int Draft')}}
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.Collator.resolvedOptions")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/collator/supportedlocalesof/index.html b/files/fr/web/javascript/reference/global_objects/intl/collator/supportedlocalesof/index.html new file mode 100644 index 0000000000..6b5bdb5414 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/collator/supportedlocalesof/index.html @@ -0,0 +1,98 @@ +--- +title: Intl.Collator.supportedLocalesOf() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/Collator/supportedLocalesOf +tags: + - Collator + - Internationalisation + - Intl + - JavaScript + - Méthode + - Reference + - i18n +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Collator/supportedLocalesOf +--- +
{{JSRef}}
+ +

La méthode Intl.Collator.supportedLocalesOf() renvoie, parmi les locales fournies, un tableau contenant les locales supportées et qui ne nécessitent pas d'utiliser la locale par défaut de l'environnement.

+ +
{{EmbedInteractiveExample("pages/js/intl-collator-prototype-supportedlocalesof.html")}}
+ + + +

Syntaxe

+ +
Intl.Collator.supportedLocalesOf(locales [, options])
+ +

Paramètres

+ +
+
locales
+
Une chaîne de caractères qui est une balise de langue BCP 47 ou bien un tableau de telles chaînes. Pour plus d'informations concernant la forme générale de l'argument locales, voir la page {{jsxref("Objets_globaux/Intl", "Intl", "#L'identification_et_le_choix_de_la_locale")}}.
+
options{{optional_inline}}
+
+

Paramètre facultatif. Un objet qui peut posséder les propriétés suivantes :

+ +
+
localeMatcher
+
+

L'algorithme utilisé pour la correspondance entre chaînes de caractères. Les valeurs possibles sont "lookup" et "best fit". La valeur par défaut est "best fit". Pour plus d'informations, voir la page {{jsxref("Objets_globaux/Intl", "Intl", "#Choix_de_la_locale")}}.

+
+
+
+
+ +

Valeur de retour

+ +

Un tableau de chaînes de caractères qui représente un sous-ensemble des balises de langues qui sont prises en charge pour la collation sans qu'il faille utiliser la locale par défaut de l'environnement d'exécution.

+ +

Description

+ +

Cette méthode renvoie un tableau qui est un sous-ensemble des balises de locales fournies avec l'argument locales. Les balises renvoyées sont celles supportées par l'environnement navigateur en termes de collation (comparaison) et qui ne nécessitent pas d'utiliser la locale par défaut.

+ +

Exemples

+ +

Si on dispose d'un environnement (un navigateur par exemple) qui supporte la comparaison de chaînes dans les locales indonésienne, allemande mais pas balinaise,  supportedLocalesOf renvoie les balises pour l'indonésien et l'allemand quand bien même la collation avec pinyin n'est pas utilisée avec l'indonésien et qu'il n'existe pas une version spécifique de l'allemand pour l'Indonésie. On illustre ici l'algorithme "lookup". SI on utilisait "best fit" pour trouver les locales correspondantes, on aurait pu avoir une balise supplémentaire pour le balinais en plus car la plupart des balinais comprennent l'indonésien.

+ +
var locales = ["ban", "id-u-co-pinyin", "de-ID"];
+var options = {localeMatcher: "lookup"};
+console.log(Intl.Collator.supportedLocalesOf(locales, options).join(", "));
+// → "id-u-co-pinyin, de-ID"
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES Int 1.0', '#sec-10.2.2', 'Intl.Collator.supportedLocalesOf')}}{{Spec2('ES Int 1.0')}}Définition initiale.
{{SpecName('ES Int 2.0', '#sec-10.2.2', 'Intl.Collator.supportedLocalesOf')}}{{Spec2('ES Int 2.0')}} 
{{SpecName('ES Int Draft', '#sec-Intl.Collator.supportedLocalesOf', 'Intl.Collator.supportedLocalesOf')}}{{Spec2('ES Int Draft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.Collator.supportedLocalesOf")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/format/index.html b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/format/index.html new file mode 100644 index 0000000000..06acb8065b --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/format/index.html @@ -0,0 +1,126 @@ +--- +title: Intl.DateTimeFormat.prototype.format +slug: Web/JavaScript/Reference/Objets_globaux/Intl/DateTimeFormat/format +tags: + - Internationalisation + - Intl + - JavaScript + - Propriété + - Prototype + - Reference + - i18n +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/format +--- +
{{JSRef}}
+ +

La méthode Intl.DateTimeFormat.prototype.format() est un accesseur formate une date selon les options de locale et de format de l'objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}.

+ +
{{EmbedInteractiveExample("pages/js/intl-datetimeformat-prototype-format.html")}}
+ + + +

Syntaxe

+ +
dateTimeFormat.format(date)
+ +

Paramètres

+ +
+
date
+
La date à formater.
+
+ +

Description

+ +

L'accesseur format permet de formater une date en une chaîne de caractères en fonction des options de locale et de format définies pour l'objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}.

+ +

Exemples

+ +

Utiliser format

+ +

On peut utiliser la fonction renvoyée par l'accesseur format pour formater une date. Par exemple selon la locale serbe :

+ +
var options = {weekday: "long", year: "numeric", month: "long", day: "numeric"};
+var dateTimeFormat = new Intl.DateTimeFormat("sr-RS", options);
+console.log(dateTimeFormat.format(new Date()));
+// → "недеља, 7. април 2013."
+ +

Utiliser format avec map()

+ +

On peut également utiliser la fonction renvoyée par l'accesseur format pour formater toutes les dates d'un tableau. On observe que la fonction est liée à l'objet DateTimeFormat dont elle provient, on peut donc la passer directement à {{jsxref("Array.prototype.map()")}}.

+ +
var a = [new Date(2012, 08), new Date(2012, 11), new Date(2012, 03)];
+var options = {year: "numeric", month: "long"};
+var dateTimeFormat = new Intl.DateTimeFormat("pt-BR", options);
+var formatted = a.map(dateTimeFormat.format);
+console.log(formatted.join("; "));
+// → "setembro de 2012; dezembro de 2012; abril de 2012"
+ +

Comparaison des dates formatées et des valeurs statiques

+ +

La plupart du temps, le format renvoyé par format() 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.

+ +

Aussi, mieux vaut ne pas comparer un résultat fourni par format() avec une valeur statique :

+ +
let d = new Date("2019-01-01T00:00:00.000000Z");
+let formattedDate = Intl.DateTimeFormat(undefined, {
+  year: 'numeric',
+  month: 'numeric',
+  day: 'numeric',
+  hour: 'numeric',
+  minute: 'numeric',
+  second: 'numeric'
+}).format(d);
+
+"1.1.2019, 01:00:00" === formattedDate;
+// true pour Firefox et les autres
+// false pour IE et Edge
+
+ +
+

Note : Voir aussi ce fil StackOverflow pour plus de détails et d'exemples.

+
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES Int 1.0', '#sec-12.3.2', 'Intl.DateTimeFormat.format')}}{{Spec2('ES Int 1.0')}}Définition initiale.
{{SpecName('ES Int 2.0', '#sec-12.3.2', 'Intl.DateTimeFormat.format')}}{{Spec2('ES Int 2.0')}} 
{{SpecName('ES Int Draft', '#sec-Intl.DateTimeFormat.prototype.format', 'Intl.DateTimeFormat.format')}}{{Spec2('ES Int Draft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.DateTimeFormat.format")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formatrange/index.html b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formatrange/index.html new file mode 100644 index 0000000000..1fbca49cc2 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formatrange/index.html @@ -0,0 +1,82 @@ +--- +title: Intl.DateTimeFormat.prototype.formatRange() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/DateTimeFormat/formatRange +tags: + - Internationalisation + - Intl + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/formatRange +--- +

{{JSRef}}

+ +

La méthode Intl.DateTimeFormat.prototype.formatRange() permet de formater un intervalle de dates de la façon la plus concise en fonction de la locale et des options fournies lors de l'initialisation de l'objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}.

+ +
{{EmbedInteractiveExample("pages/js/intl-datetimeformat-prototype-formatrange.html")}}
+ + + +

Syntaxe

+ +
Intl.DateTimeFormat.prototype.formatRange(dateDébut, dateFin)
+ +

Exemples

+ +

Utilisation simple de formatRange()

+ +

Cette méthode reçoit comme arguments deux objets {{jsxref("Date")}} et renvoie l'intervalle de la façon la plus concise possible (selon les options fournies lors de l'instanciation du formateur Intl.DateTimeFormat).

+ +
let date1 = new Date(Date.UTC(2007, 0, 10, 10, 0, 0));
+let date2 = new Date(Date.UTC(2007, 0, 10, 11, 0, 0));
+let date3 = new Date(Date.UTC(2007, 0, 20, 10, 0, 0));
+// > 'Wed, 10 Jan 2007 10:00:00 GMT'
+// > 'Wed, 10 Jan 2007 11:00:00 GMT'
+// > 'Sat, 20 Jan 2007 10:00:00 GMT'
+
+let fmt1 = new Intl.DateTimeFormat("en", {
+    year: '2-digit',
+    month: 'numeric',
+    day: 'numeric',
+    hour: 'numeric',
+    minute: 'numeric'
+});
+console.log(fmt1.format(date1));
+console.log(fmt1.formatRange(date1, date2));
+console.log(fmt1.formatRange(date1, date3));
+// > '1/10/07, 10:00 AM'
+// > '1/10/07, 10:00 – 11:00 AM'
+// > '1/10/07, 10:00 AM – 1/20/07, 10:00 AM'
+
+let fmt2 = new Intl.DateTimeFormat("en", {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric'
+});
+console.log(fmt2.format(date1));
+console.log(fmt2.formatRange(date1, date2));
+console.log(fmt2.formatRange(date1, date3));
+// > 'Jan 10, 2007'
+// > 'Jan 10, 2007'
+// > 'Jan 10 – 20, 2007'
+
+ +

Spécifications

+ + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Intl.DateTimeFormat.prototype.formatRangeBrouillon de niveau 3
+ +

Voir aussi

+ +

{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl', 'Voir_aussi')}}

diff --git a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formatrangetoparts/index.html b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formatrangetoparts/index.html new file mode 100644 index 0000000000..593df591fb --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formatrangetoparts/index.html @@ -0,0 +1,73 @@ +--- +title: Intl.DateTimeFormat.prototype.formatRangeToParts() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/DateTimeFormat/formatRangeToParts +tags: + - Internationalization + - JavaScript + - Localization + - i18n +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/formatRangeToParts +--- +

{{JSRef}}

+ +

La fonction Intl.DateTimeFormat.prototype.formatRangeToParts() permet, selon la locale utilisée, de représenter chaque élément de l'intervalle de dates via DateTimeFormat.

+ +

Syntaxe

+ +
Intl.DateTimeFormat.prototype.formatRangeToParts(dateDebut, dateFin)
+ +

Exemples

+ +

Usage basique de formatRangeToParts

+ +

Cette fonction reçoit deux Dates et retourne un Array d'objets contenant les élements qui représentent chaque partie de l'intervalle de date formatée, selon la locale utilisée.

+ +
let date1 = new Date(Date.UTC(2007, 0, 10, 10, 0, 0));
+let date2 = new Date(Date.UTC(2007, 0, 10, 11, 0, 0));
+// > 'Wed, 10 Jan 2007 10:00:00 GMT'
+// > 'Wed, 10 Jan 2007 11:00:00 GMT'
+
+let fmt = new Intl.DateTimeFormat("en", {
+    hour: 'numeric',
+    minute: 'numeric'
+});
+
+console.log(fmt.formatRange(date1, date2));
+// > '10:00 – 11:00 AM'
+
+fmt.formatRangeToParts(date1, date2);
+// retourne la valeur:
+// [
+//   { type: 'hour',      value: '10',  source: "startRange" },
+//   { type: 'literal',   value: ':',   source: "startRange" },
+//   { type: 'minute',    value: '00',  source: "startRange" },
+//   { type: 'literal',   value: ' – ', source: "shared"     },
+//   { type: 'hour',      value: '11',  source: "endRange"   },
+//   { type: 'literal',   value: ':',   source: "endRange"   },
+//   { type: 'minute',    value: '00',  source: "endRange"   },
+//   { type: 'literal',   value: ' ',   source: "shared"     },
+//   { type: 'dayPeriod', value: 'AM',  source: "shared"     }
+// ]
+ +

Spécifications

+ + + + + + + + + + + + + + +
SpecificationStatusComment
Intl.DateTimeFormat.prototype.formatRangeStage 3
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.DateTimeFormat.formatRangeToParts")}}

diff --git a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formattoparts/index.html b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formattoparts/index.html new file mode 100644 index 0000000000..8ec6657b12 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/formattoparts/index.html @@ -0,0 +1,166 @@ +--- +title: Intl.DateTimeFormat.prototype.formatToParts() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/DateTimeFormat/formatToParts +tags: + - DateTimeFormat + - Internationalisation + - Intl + - JavaScript + - Méthode + - Prototype + - Reference + - i18n +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/formatToParts +--- +
{{JSRef}}
+ +

La méthode Intl.DateTimeFormat.prototype.formatToParts() permet de mettre en forme des chaînes de caractères avec des informations temporelles selon la locale utilisée.

+ +

Syntaxe

+ +
Intl.DateTimeFormat.prototype.formatToParts(date)
+ +

Paramètres

+ +
+
date {{optional_inline}}
+
La date qu'on souhaite mettre en forme.
+
+ +

Valeur de retour

+ +

Un tableau ({{jsxref("Array")}}) d'objets qui contiennent les composants de la date mis en forme.

+ +

Description

+ +

La méthode formatToParts() est utile lorsqu'on souhaite mettre en forme des dates de façon personnalisée. Elle renvoie un tableau d'objets qui contiennent les fragments spécifiques à la locale, à partir desquels on peut construire des chaînes tout en conservant les parties spécifique à la locale. La structure de l'objet renvoyé par la méthode est semblable à celle-ci :

+ +
[
+  { type: "day", value: "17" },
+  { type: "weekday", value "Monday" }
+]
+ +

Les types possibles sont :

+ +
+
day
+
La chaîne utilisée pour désigner le jour, par exemple "17".
+
dayPeriod
+
La chaîne utilisée pour désigner le moment de la journée, par exemple "AM" (qui désigne la matinée, avant midi) ou "PM" (qui désigne l'après-midi).
+
era
+
La chaîne utilisée pour l'ère (par exemple "BC" ou "AD").
+
hour
+
La chaîne utilisée pour l'heure (par exemple "3" or "03").
+
literal
+
La chaîne utilisée pour séparée le jour de l'heure (par exemple " : , / ").
+
minute
+
La chaîne utilisée pour les minutes (par exemple "00").
+
month
+
La chaîne utilisée pour le mois (par exemple "12").
+
second
+
La chaîne utilisée pour les secondes (par exemple "02").
+
timeZoneName
+
La chaîne utilisée pour désigner le fuseau horaire (par exemple "UTC").
+
weekday
+
La chaîne de caractères utilisée pour le jour de la semaine, par exemple "M", "Monday" ou "Montag".
+
year
+
La chaîne utilisée pour désigner l'année (par exemple "2012" ou "96").
+
+ +

Exemples

+ +

DateTimeFormat produit des chaînes localisées opaques qui ne peuvent pas être manipulées directement :

+ +
var date = Date.UTC(2012, 11, 17, 3, 0, 42);
+
+var formatter = new Intl.DateTimeFormat("en-us", {
+  weekday: 'long',
+  year: 'numeric',
+  month: 'numeric',
+  day: 'numeric',
+  hour: 'numeric',
+  minute: 'numeric',
+  second: 'numeric',
+  hour12: true,
+  timeZone: "UTC"
+});
+
+formatter.format(date);
+// "Monday, 12/17/2012, 3:00:42 AM"
+
+ +

Cependant, pour de nombreuses interfaces utilisateur, on peut vouloir personnaliser la mise en forme de cette chaîne de caractères. La méthode formatToParts permet une mise en forme dans le souci de la locale en manipulant les différentes composantes :

+ +
formatter.formatToParts(date);
+
+// return value:
+[
+  { type: 'weekday',   value: 'Monday' },
+  { type: 'separator', value: ', '     },
+  { type: 'month',     value: '12'     },
+  { type: 'literal', value: '/'      },
+  { type: 'day',       value: '17'     },
+  { type: 'literal', value: '/'      },
+  { type: 'year',      value: '2012'   },
+  { type: 'literal', value: ', '     },
+  { type: 'hour',      value: '3'      },
+  { type: 'literal', value: ':'      },
+  { type: 'minute',    value: '00'     },
+  { type: 'literal', value: ':'      },
+  { type: 'second',    value: '42'     },
+  { type: 'literal', value: ' '      },
+  { type: 'dayPeriod', value: 'AM'     }
+]
+
+ +

L'information étant décomposée, on peut alors la mettre en forme et la recomposée de façon adaptée :

+ +
var dateString = formatter.formatToParts(date).map(({type, value}) => {
+  switch (type) {
+    case 'dayPeriod': return `<strong>${value}</strong>`;
+    default : return value;
+  }
+}).reduce((string, part) => string + part);
+
+console.log(formatter.format(date));
+// "Monday, 12/17/2012, 3:00:42 AM"
+
+console.log(dateString);
+// "Monday, 12/17/2012, 3:00:42 <strong>AM</strong>"
+ +

Prothèse d'émulation (polyfill)

+ +

Une prothèse de cette fonctionnalité est disponible sur le dépôt décrivant la proposition de fonctionnalité.

+ +

Spécifications

+ + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES Int Draft', '#sec-Intl.DateTimeFormat.prototype.formatToParts', 'Intl.DateTimeFormat.prototype.formatToParts')}}{{Spec2('ES Int Draft')}}Définition initiale.
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.DateTimeFormat.formatToParts")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/index.html b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/index.html new file mode 100644 index 0000000000..eb7c535c80 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/index.html @@ -0,0 +1,297 @@ +--- +title: Intl.DateTimeFormat +slug: Web/JavaScript/Reference/Objets_globaux/Intl/DateTimeFormat +tags: + - Internationalisation + - Intl + - JavaScript + - Reference + - i18n +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat +--- +
{{JSRef}}
+ +

L'objet Intl.DateTimeFormat est un constructeur d'objets permettant de formatter des dates et des heures selon une langue.

+ +
{{EmbedInteractiveExample("pages/js/intl-datetimeformat.html")}}
+ + + +

Syntaxe

+ +
new Intl.DateTimeFormat([locales[, options]])
+Intl.DateTimeFormat.call(this[, locales[, options]])
+ +

Paramètres

+ +
+
locales{{optional_inline}}
+
+

Ce paramètre optionnel est une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour utiliser la locale par défaut du navigateur, on pourra omettre cet argument (ou passer la valeur undefined). Pour le format général et l'interprétation de l'argument locales, voir la page {{jsxref("Objets_globaux/Intl","Intl","#L'identification_et_le_choix_de_la_locale")}}. Les clefs d'extensions Unicode suivantes sont autorisées :

+ +
+
nu
+
Système de numérotation. Les valeurs possibles incluent : "arab", "arabext", "bali", "beng", "deva", "fullwide", "gujr", "guru", "hanidec", "khmr", "knda", "laoo", "latn", "limb", "mlym", "mong", "mymr", "orya", "tamldec", "telu", "thai", "tibt".
+
ca
+
Calendrier. Les valeurs possibles incluent : "buddhist", "chinese", "coptic", "ethiopia", "ethiopic", "gregory", "hebrew", "indian", "islamic", "islamicc", "iso8601", "japanese", "persian", "roc".
+
hc
+
Le type de cycle horaire à utiliser. Les valeurs possibles sont "h11", "h12", "h23", "h24".
+
+
+
options
+
+

Un objet avec certaines ou toutes les propriétés suivantes :

+ +
+
localeMatcher
+
L'algorithme de correspondance à utiliser pour la locale. Les valeurs possibles sont "lookup" et "best fit" ; le défaut est "best fit". Pour des informations sur cette option, voir la page {{jsxref("Objets_globaux/Intl","Intl","##Choix_de_la_locale")}}
+
timeZone
+
Le fuseau horaire à utiliser. La seule valeur que doivent reconnaitre les implémentations est "UTC" ; la valeur par défaut est le fuseau horaire du moteur JavaScript. Les implémentations peuvent aussi reconnaitre les noms de fuseau horaire de la base de données IANA de fuseaux horaires, tel que "Asia/Shanghai", "Asia/Kolkata", "America/New_York".
+
hour12
+
S'il faut utiliser le format horaire sur 12 heures (au lieu de celui-ci sur 24 heures). Les valeurs possibles sont true et false ; la valeur par défaut dépend de la locale. Cette option surcharge l'étiquette hc et/ou l'option hourCycle.
+
hourCycle
+
Le cycle horaire à utiliser. Les valeurs possibles sont "h11", "h12", "h23", "h24". Cette option surcharge l'étiquette hc mais sera remplacée par hour12 si cette dernière est présente.
+
formatMatcher
+
L'algorithme de correspondance à utiliser pour le formattage. Les valeurs possibles sont "basic" et "best fit" ; par défaut "best fit". Voir les paragraphes suivants pour des informations concernant l'usage de cette propriété.
+
+ +

Les propriétés suivantes décrivent les composants date-heure à utiliser pour le formattage de la sortie.  Les implémentations ont pour obligation de supporter au minimum les ensembles suivants :

+ +
    +
  • weekday, year, month, day, hour, minute, second
    • +
  • weekday, year, month, day
    • +
  • year, month, day
    • +
  • year, month
    • +
  • month, day
    • +
  • hour, minute, second
    • +
  • hour, minute
    • +
+ +

Les implémentations peuvent supporter d'autres sous-ensembles, et les demandes seront évaluées face à toutes les combinaisons de sous-ensembles disponibles pour trouver la meilleure correspondance. Deux algorithmes sont disponibles pour cette évaluation et choisis par la propriété formatMatcher : un algorithme "basic" complètement spécifié et un algorithme "best fit" dépendant de l'implémentation.

+ +
+
weekday
+
La représentation du jour de la semaine. Les valeurs possibles sont : +
    +
  • "long" (par exemple Thursday)
    • +
  • "short" (par exemple Thu)
    • +
  • "narrow" (par exemple T). Deux jours de la semaines pourront partager la même représentation dans certaines locales (par exemple, en anglais Tuesday sera également représenté avec T en notation étroite).
    • +
+
+
era
+
La représentation de l'ère. Les valeurs possibles sont : +
    +
  • "long" (par exemple Anno Domini)
    • +
  • "short" (par exemple AD)
    • +
  • "narrow" (par exemple A)
    • +
+
+
year
+
La représentation de l'année. Les valeurs possibles sont : +
    +
  • "numeric" (par exemple 2012)
    • +
  • "2-digit" (par exemple 12)
    • +
+
+
month
+
La représentation du mois. Les valeurs possibles sont : +
    +
  • "numeric" (par exemple 2)
    • +
  • "2-digit" (par exemple 02)
    • +
  • "long" (par exemple March)
    • +
  • "short" (par exemple Mar)
    • +
  • "narrow" (par exemple M). Dans certaines locales, deux mois pourront partager la même représentation avec le style étroit (par exemple, May en anglais, sera également représenté avec M).
    • +
+
+
day
+
La représentation du jour. Les valeurs possibles sont : +
    +
  • "numeric" (par exemple 1)
    • +
  • "2-digit" (par exemple 01)
    • +
+
+
hour
+
La représentation de l'heure. Les valeurs possibles sont : +
    +
  • "numeric" (par exemple 1)
    • +
  • "2-digit" (par exemple 01)
    • +
+
+
minute
+
La représentation des minutes. Les valeurs possibles sont : +
    +
  • "numeric" (par exemple 1)
    • +
  • "2-digit" (par exemple 01)
    • +
+
+
second
+
La représentation des secondes. Les valeurs possibles sont : +
    +
  • "numeric" (par exemple 1)
    • +
  • "2-digit" (par exemple 01)
    • +
+
+
timeZoneName
+
La représentation du fuseau horaire. Les valeurs possibles sont : +
    +
  • "long" (par exemple British Summer Time)
    • +
  • "short" (par exemple GMT+1)
    • +
+
+
+ +

La valeur par défaut pour chaque composante est {{jsxref("undefined")}}, mais si toutes les composantes valent undefined, alors year, month, et day seront considérés comme "numeric".

+
+
+ +

Description

+ +

Propriétés

+ +
+
{{jsxref("DateTimeFormat.prototype", "Intl.DateTimeFormat.prototype")}}
+
Permet l'ajout de propriétés à tous les objets.
+
+ +

Méthodes

+ +
+
{{jsxref("DateTimeFormat.supportedLocalesOf", "Intl.DateTimeFormat.supportedLocalesOf()")}}
+
Renvoie un tableau contenant les locales supportées parmis les locales fournies, sans qu'il soit nécessaire de recourir à la locale par défaut de l'implémentation.
+
+ +

Instances de DateTimeFormat

+ +

Propriétés

+ +

Les instances de DateTimeFormat() héritent des propriétés suivantes depuis leur prototype :

+ +
{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/DateTimeFormat/prototype','Properties')}}
+ +

Méthodes

+ +
+

Les instances de DateTimeFormat() héritent des propriétés suivantes depuis leur prototype :

+{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/DateTimeFormat/prototype','Méthodes')}}
+ +

Exemples

+ +

Utiliser DateTimeFormat()

+ +

Dans une utilisation basique sans préciser de locale, DateTimeFormat() utilise la locale et les options par défaut

+ +
var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+
+// DateTimeFormat sans arguments dépend de l'implémentation,
+// la locale par défaut, et le fuseau horaire par défaut
+console.log(new Intl.DateTimeFormat().format(date));
+// → "20/12/2012" avec une locale fr-Fr et un fuseau horaire CEST
+ +

Utiliser locales

+ +

Cet exemple montre quelques variations de formattage pour les dates et les heures localisées. 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 :

+ +
var 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
+console.log(new Intl.DateTimeFormat("en-US").format(date));
+// → "12/20/2012"
+
+// l'anglais britannique utilise l'ordre jour-mois-année
+console.log(new Intl.DateTimeFormat("en-GB").format(date));
+// → "20/12/2012"
+
+// le coréen utilise l'ordre année-mois-jour
+console.log(new Intl.DateTimeFormat("ko-KR").format(date));
+// → "2012. 12. 20."
+
+// l'arabe, dans la plupart des pays arabophones, utilise les chiffres arabes
+console.log(new Intl.DateTimeFormat("ar-EG").format(date));
+// → "٢٠‏/١٢‏/٢٠١٢"
+
+// 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
+console.log(new Intl.DateTimeFormat("ja-JP-u-ca-japanese").format(date));
+// → "24/12/20"
+
+// quand un langage non support est demandé (ex : le balinais)
+// il est possible de fournir un langage de recours (ici l'indonésien)
+console.log(new Intl.DateTimeFormat(["ban", "id"]).format(date));
+// → "20/12/2012"
+
+ +

Utiliser options

+ +

Les formats de la date et de l'heure peuvent être personnalisés en utilisant l'argument options :

+ +
var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+
+// fournir le jour de la semaine avec une date longue
+var options = {weekday: "long", year: "numeric", month: "long", day: "numeric"};
+console.log(new Intl.DateTimeFormat("de-DE", options).format(date));
+// → "Donnerstag, 20. Dezember 2012"
+
+// une application peut vouloir utiliser UTC et le rendre visible
+options.timeZone = "UTC";
+options.timeZoneName = "short";
+console.log(new Intl.DateTimeFormat("en-US", options).format(date));
+// → "Thursday, December 20, 2012, GMT"
+
+// parfois, vous voulez être précis
+options = {hour: "numeric", minute: "numeric", second: "numeric",
+           timeZoneName: "short"};
+console.log(new Intl.DateTimeFormat("en-AU", options).format(date));
+// → "2:00:00 pm AEDT"
+
+// parfois, même les USA ont besoin d'afficher une heure sur 24h
+options = {year: "numeric", month: "numeric", day: "numeric",
+           hour: "numeric", minute: "numeric", second: "numeric",
+           hour12: false};
+console.log(new Intl.DateTimeFormat("en-US", options));
+// → "12/19/2012, 19:00:00"
+
+// pour utiliser la locale par défaut du navigateur :
+console.log(new Intl.DateTimeFormat('default', options).format(date));
+// → "12/19/2012, 19:00:00" (peut varier selon la locale du navigateur)
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES Int 1.0', '#sec-12.1', 'Intl.DateTimeFormat')}}{{Spec2('ES Int 1.0')}}Première définition.
{{SpecName('ES Int 2.0', '#sec-12.1', 'Intl.DateTimeFormat')}}{{Spec2('ES Int 2.0')}}
{{SpecName('ES Int Draft', '#datetimeformat-objects', 'Intl.DateTimeFormat')}}{{Spec2('ES Int Draft')}}
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.DateTimeFormat")}}

+ +

Voir aussi

+ +
{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl', 'Voir_aussi')}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/resolvedoptions/index.html b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/resolvedoptions/index.html new file mode 100644 index 0000000000..b91083bb16 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/resolvedoptions/index.html @@ -0,0 +1,105 @@ +--- +title: Intl.DateTimeFormat.prototype.resolvedOptions() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/DateTimeFormat/resolvedOptions +tags: + - Internationalisation + - Intl + - JavaScript + - Méthode + - Prototype + - Reference + - i18n +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/resolvedOptions +--- +
{{JSRef}}
+ +

La méthode Intl.DateTimeFormat.prototype.resolvedOptions() renvoie un nouvel objet dont les propriétés reflètent les options de format et de locale pour les heures et dates, calculées pendant l'initialisation de l'objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}.

+ +
{{EmbedInteractiveExample("pages/js/intl-datetimeformat-prototype-resolvedoptions.html")}}
+ + + +

Syntaxe

+ +
dateTimeFormat.resolvedOptions()
+ +

Valeur de retour

+ +

Un nouvel objet dont les propriétés reflètent les options de format et de locale pour les heures et dates, calculées pendant l'initialisation de l'objet {{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}

+ +

Description

+ +

La valeur renvoyée par cette méthode contient les propriétés suivantes :

+ +
+
locale
+
La balise de langue BCP 47 qui est réellement utilisée. Si des extensions Unicode étaient fournies avec la balise d'origine et sont supportées pour la locale utilisée, les paires de clés-valeurs seront incluses dans locale.
+
calendar
+
Le calendrier utilisé (ex. "gregory" pour le calendrier grégorien).
+
numberingSystem
+
Les valeurs demandées pour les extensions Unicode "ca" et "nu" ou leurs valeurs par défaut.
+
timeZone
+
La valeur fournie par l'argument options pour cette propriété ou {{jsxref("undefined")}} (qui représente le fuseau horaire de l'environnement) si aucune valeur n'a été fournie. Les applications ne doivent pas s'appuyer sur ce dernier cas. En effet, de futures versions pourraient renvoyer une chaîne de caractères représentant le fuseau horaire de l'environnement et non pas undefined.
+
hour12
+
La valeur fournie pour cette propriété dans l'argument options.
+
weekday
+
era
+
year
+
month
+
day
+
hour
+
minute
+
second
+
timeZoneName
+
Les valeurs qui correspondent entre les propriétés de l'argument options et les combinaisons disponibles dans l'environnement pour les formats de date et d'heure pour la locale. Certaines de ces propriétés peuvent ne pas être présentes, cela indique que les composants indiqués ne seront pas représentés.
+
+ +

Exemples

+ +
var germanFakeRegion = new Intl.DateTimeFormat("de-XX", { timeZone: "UTC" });
+var usedOptions = germanFakeRegion.resolvedOptions();
+
+usedOptions.locale;          // "de"
+usedOptions.calendar;        // "gregory"
+usedOptions.numberingSystem; // "latn"
+usedOptions.timeZone;        // "UTC"
+usedOptions.month;           // "numeric"
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES Int 1.0', '#sec-12.3.3', 'Intl.DateTimeFormat.prototype.resolvedOptions')}}{{Spec2('ES Int 1.0')}}Définition initiale.
{{SpecName('ES Int 2.0', '#sec-Intl.DateTimeFormat.prototype.resolvedOptions', 'Intl.DateTimeFormat.prototype.resolvedOptions')}}{{Spec2('ES Int 2.0')}} 
{{SpecName('ES Int Draft', '#sec-Intl.DateTimeFormat.prototype.resolvedOptions', 'Intl.DateTimeFormat.prototype.resolvedOptions')}}{{Spec2('ES Int Draft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.DateTimeFormat.resolvedOptions")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/supportedlocalesof/index.html b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/supportedlocalesof/index.html new file mode 100644 index 0000000000..079c20ae21 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/supportedlocalesof/index.html @@ -0,0 +1,98 @@ +--- +title: Intl.DateTimeFormat.supportedLocalesOf() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/DateTimeFormat/supportedLocalesOf +tags: + - Internationalisation + - Intl + - JavaScript + - Méthode + - Prototype + - Reference + - i18n +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/supportedLocalesOf +--- +
{{JSRef}}
+ +

À partir d'une locale ou d'un tableau de locales Intl.DateTimeFormat.supportedLocalesOf() renvoie un tableau qui contient les locales supportées pour le formatage des dates et des heures qui ne nécessitent pas d'avoir recours à la locale par défaut de l'environnement.

+ +
{{EmbedInteractiveExample("pages/js/intl-datetimeformat-prototype-supportedlocalesof.html")}}
+ + + +

Syntaxe

+ +
Intl.DateTimeFormat.supportedLocalesOf(locales[, options])
+ +

Paramètres

+ +
+
locales
+
Un chaîne de caractères au format d'une balise de langue BCP 47 ou bien un tableau de telles chaînes. Pour plus d'informations sur le format de l'argument locales, voir la page {{jsxref("Intl", "Intl", "#L'identification_et_le_choix_de_la_locale")}}.
+
options
+
+

Paramètre optionnel, un objet pouvant avoir la propriété suivante :

+ +
+
localeMatcher
+
L'algorithme de correspondance entre locales à utiliser. Les valeurs possibles sont "lookup" et "best fit". Pour plus d'informations sur ce sujet, voir la page {{jsxref("Intl", "Intl", "#Choix_de_la_locale")}}.
+
+
+
+ +

Valeur de retour

+ +

Un tableau de chaînes de caractères qui représente un sous-ensemble des balises de langue qui sont prises en charge pour la mise en forme de l'heure et de la date sans qu'il soit nécessaire d'utiliser la locale par défaut de l'environnement d'exécution.

+ +

Description

+ +

Renvoie un tableau qui est un sous-ensemble de locales. Les balises de langues renvoyées sont celles supportées par l'environnement pour le formatage des heures et des dates. Ces balises sont déterminées en fonction de l'algorithme de correspondances de locale et des locales utilisées. Le tableau résultant fournit les locales qui permettent de ne pas avoir à utiliser la locale par défaut.

+ +

Exemple

+ +

Utiliser supportedLocalesOf

+ +

Si on dispose d'un environnement qui supporte les locales indonésienne et allemande mais pas balinaise pour le formatage des dates et des heures,  supportedLocalesOf renverra les balises BCP 47 pour l'indonésien et l'allemand (bien que la collation pinyin ne soit pas pertinente pour les dates ni pour l'indonésien et qu'il soit peu probable qu'une variante indonésienne existe pour l'allemand). Pour l'exemple, on l'utilise l'algorithme "lookup". Si on utilisait "best fit", on pourrait considérer que l'indonésien est adéquat pour la locale balinaise (sachant que la plupart des balinais comprend l'indonésien) et donc également renvoyer la balise balinaise.

+ +
var locales = ["ban", "id-u-co-pinyin", "de-ID"];
+var options = {localeMatcher: "lookup"};
+console.log(Intl.DateTimeFormat.supportedLocalesOf(locales, options).join(", "));
+// → "id-u-co-pinyin, de-ID"
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES Int 1.0', '#sec-12.2.2', 'Intl.DateTimeFormat.supportedLocalesOf')}}{{Spec2('ES Int 1.0')}}Définition initiale.
{{SpecName('ES Int 2.0', '#sec-12.2.2', 'Intl.DateTimeFormat.supportedLocalesOf')}}{{Spec2('ES Int 2.0')}} 
{{SpecName('ES Int Draft', '#sec-Intl.DateTimeFormat.supportedLocalesOf', 'Intl.DateTimeFormat.supportedLocalesOf')}}{{Spec2('ES Int Draft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.DateTimeFormat.supportedLocalesOf")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/getcanonicallocales/index.html b/files/fr/web/javascript/reference/global_objects/intl/getcanonicallocales/index.html new file mode 100644 index 0000000000..e0fc40a55d --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/getcanonicallocales/index.html @@ -0,0 +1,73 @@ +--- +title: Intl.getCanonicalLocales() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/getCanonicalLocales +tags: + - Internationalisation + - Intl + - JavaScript + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/getCanonicalLocales +--- +
{{JSRef}}
+ +

La méthode Intl.getCanonicalLocales() renvoie un tableau contenant les noms canoniques des locales. Les doublons seront fusionnés et les éléments passés en arguments doivent être des étiquettes de langues valides.

+ +
{{EmbedInteractiveExample("pages/js/intl-getcanonicallocales.html")}}
+ + + +

Syntaxe

+ +
Intl.getCanonicalLocales(locales)
+ +

Paramètres

+ +
+
locales
+
Une liste de chaînes ({{jsxref("String")}}) dont on veut obtenir les noms canoniques pour les locales correspondantes.
+
+ +

Valeur de retour

+ +

Un tableau qui contient les noms canoniques des locales.

+ +

Exemples

+ +
Intl.getCanonicalLocales("EN-US"); // ["en-US"]
+Intl.getCanonicalLocales(["EN-US", "Fr"]); // ["en-US", "fr"]
+
+Intl.getCanonicalLocales("EN_US");
+// RangeError:'EN_US' is not a structurally valid language tag
+
+ +

Spécifications

+ + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES Int Draft', '#sec-intl.getcanonicallocales', 'Intl.getCanonicalLocales')}}{{Spec2('ES Int Draft')}}Définition initiale.
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.getCanonicalLocales")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/index.html b/files/fr/web/javascript/reference/global_objects/intl/index.html new file mode 100644 index 0000000000..26062d308d --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/index.html @@ -0,0 +1,163 @@ +--- +title: Intl +slug: Web/JavaScript/Reference/Objets_globaux/Intl +tags: + - Espace de noms + - Internationalisation + - Intl + - JavaScript + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl +--- +
{{JSRef}}
+ +

L'objet Intl est l'espace de noms pour l'API d'Internationalisation d'ECMAScript. Elle fournit des outils de comparaison de chaînes de caractères, de formatage des nombres, de dates et de l'heure selon les langues. Intl donne accès à plusieurs constructeurs et fonctionnalités communs aux constructeurs destinés à l'internationalion et à d'autres fonctions dépendantes des langues.

+ +

Propriétés constructrices

+ +
+
{{jsxref("Objets_globaux/Collator", "Intl.Collator")}}
+
Le constructeur pour les ordonnanceurs (collators en anglais) et les objets qui permettent la comparaison de chaînes de caractères selon les règles spécifiques d'une langue.
+
{{jsxref("Objets_globaux/DateTimeFormat", "Intl.DateTimeFormat")}}
+
Le constructeur pour les objets qui permettent le formatage des dates et de l'heure selon les règles spécifiques d'une langue.
+
{{jsxref("Global_Objects/Intl/DisplayNames/DisplayNames", "Intl.DisplayNames()")}}
+
Le constructeur pour les objets qui permettent de fournir des traductions constantes de noms de langues, régions et systèmes d'écriture.
+
{{jsxref("Objets_globaux/ListFormat", "Intl.ListFormat")}}
+
Le constructeur pour les objets qui permettent le formatage des listes selon les règles spécifiques d'une langue.
+
{{jsxref("Global_Objects/Intl/Locale/Locale", "Intl.Locale()")}}
+
Le constructeur pour les objets qui représentent un identifiant de langue Unicode.
+
{{jsxref("Objets_globaux/NumberFormat", "Intl.NumberFormat")}}
+
Le constructeur pour les objets qui permettent le formatage des nombres selon les règles spécifiques d'une langue.
+
{{jsxref("Objets_globaux/PluralRules","Intl.PluralRules")}}
+
Le constructeur pour les objets qui permettent le formatage prenant en compte le pluriel et les règles de pluriel spécifiques d'une langue.
+
{{jsxref("Objets_globaux/RelativeTimeFormat","Intl.RelativeTimeFormat")}}
+
Le constructeur pour les objets qui permettent le formatage d'intervalles de temps spécifiques d'une langue.
+
+ +

Méthodes statiques

+ +
+
{{jsxref("Intl.getCanonicalLocales()")}}
+
Méthode renvoyant les noms canoniques des locales.
+
+ +

Identification et choix de la locale

+ +

Les constructeurs d'internationalisation, ainsi que plusieurs autres méthodes spécifiques à une langue dans d'autres constructeurs (voir ci-dessous {{anch("See_also", "Voir aussi")}}), utilisent un schéma commun pour identifier les locales et déterminer celle qu'ils utiliseront effectivement : ils acceptent tous les arguments locales et options, et ils négocient les locales demandées face aux locales qu'ils supportent, en utilisant un algorithme spécifié dans la propriété options.localeMatcher.

+ +

Argument locales

+ +

L'argument locales peut être soit une chaîne de caractères comportant une balise de langue BCP 47, soit un tableau de telles balises. Si l'argument n'est pas fourni ou est indéfini, la locale par défaut de l'environnement d'exécution est utilisée.

+ +

Une balise de langue BCP 47 définit un langage et contient au minimum un code de langue principale. Dans sa forme la plus fréquente, elle peut contenir, dans l'ordre : un code de langue, un code de script et un code de pays ou de région, tous séparés par des tirets. Bien que la balise ne soit sensible à la casse, il est recommandé d'utiliser des initiales majuscules pour le code de script, des majuscules pour les codes de pays et de région, et des minuscules pour tout le reste.

+ +

Exemples :

+ + + +

Les sous balises identifiant les langues, les scripts, les pays (régions) et les variantes (rarement utilisées) dans les balises de langue BCP 47 peuvent être trouvées dans le registre IANA des Sous balises de Langues

+ +

La BCP 47 permet également des extensions. Les fonctions d'internalisation de JavaScript utilisent l'extension "u" (Unicode), qui peut utilisée pour demander une personnalisation supplémentaire des objets {{jsxref("Collator")}}, {{jsxref("NumberFormat")}}, ou {{jsxref("DateTimeFormat")}}. Exemples :

+ + + +

Négociation de la locale

+ +

L'argument locales, après retrait de toutes les extensions Unicode, est interprété comme une requête classée par priorité émanant de l'application. L'environnement d'exécution le compare aux locales dont il dispose et choisit la meilleure disponible. Il existe deux algorithmes d'association : l'apparieur "lookup" suit l'algorithme Lookup spécifié dans BCP 47; l'apparieur "meilleure correspondance" laisse l'environnement d'exécution fournir une locale qui est au moins aussi, mais possiblement mieux, adaptée à la demande que le résultat de l'algorithme Lookup. Si l'application ne fournit pas d'argument locales ou que l'environnement d'exécution ne dispose pas d'une locale qui corresponde à la requête, alors la locale par défaut de l'environnement d'exécution est utilisée. L'apparieur peut être choisi en utilisant une propriété de l'argument options (voir ci-dessous).

+ +

Si la balise de la langue choisie comporte une sous chaîne d'extension Unicode, cette extension est maintenant utilisée pour personnaliser l'objet construit ou le comportement de la fonction. Chaque constructeur ou fonction ne supporte qu'un sous-ensemble des clés définies pour le extension Unicode, et les valeurs supportées dépendent souvent de la balise de langue. Par exemple, la clé "co" (collation) n'est supportée que par le constructeur {{jsxref("Collator")}}, et sa valeur "phonebk" n'est supportée que pour l'allemand.

+ +

Argument options

+ +

L'argument options doit être un objet ayant des propriétés qui varient suivant qu'il s'agit des constructeurs ou des fonctions. Si l'argument options n'est pas fourni ou est indéfini, des valeurs par défaut seront utilisées pour toutes les propriétés.

+ +

Une propriété est supportée par tous les constructeurs et toutes les fonctions fondés sur les locales : la propriété localeMatcher, dont la valeur doit être la chaîne "lookup" ou "best fit", et qui sélectionne l'un des algorithmes d'appariement décrits ci-dessus.

+ +

Exemples

+ +

Formater des dates et nombres

+ +

Vous pouvez utiliser Intl pour formater des dates et nombres dans un format qui est conventionnel pour une langue et une région spécifiques :

+ +
const compte = 26254.39;
+const date = new Date("2012-05-24");
+
+function afficher (langue) {
+  console.log(
+    `${new Intl.DateTimeFormat(langue).format(date)} ${new Intl.NumberFormat(langue).format(compte)}`
+  );
+}
+
+afficher("en-US");
+// résultat attendu : 5/24/2012 26,254.39
+
+afficher("de-DE");
+// résultat attendu : 24.5.2012 26.254,39
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES Int 1.0', '#sec-8', 'Intl')}}{{Spec2('ES Int 1.0')}}Définition initiale.
{{SpecName('ES Int 2.0', '#sec-8', 'Intl')}}{{Spec2('ES Int 2.0')}}
{{SpecName('ES Int Draft', '#intl-object', 'Intl')}}{{Spec2('ES Int Draft')}}Ajout de Intl.getCanonicalLocales dans la 4e édition.
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/listformat/format/index.html b/files/fr/web/javascript/reference/global_objects/intl/listformat/format/index.html new file mode 100644 index 0000000000..330767cb8c --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/listformat/format/index.html @@ -0,0 +1,68 @@ +--- +title: Intl​.ListFormat.prototype​.format() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/ListFormat/format +tags: + - Internationalisation + - Intl + - JavaScript + - ListFormat + - Méthode + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/format +--- +
{{JSRef}}
+ +

La méthode format() renvoie une chaîne de caractères représentant la liste passée en argument, mise en forme selon la langue choisie (lors de la construction de l'objet Intl.ListFormat).

+ +
{{EmbedInteractiveExample("pages/js/intl-listformat.html")}}
+ +

Description

+ +

La méthode format() renvoie une chaîne de caractères qui a été formatée en fonction des paramètres fournis à l'objet Intl.ListFormat. Les paramètres locales et options permettent de personnaliser le comportement de format() et de gérer différentes conventions linguistiques au sein d'une application, notamment pour la mise en forme des listes.

+ +

Syntaxe

+ +
listFormat.format([list]);
+ +

Paramètres

+ +
+
list
+
Un objet itérable (ex. un tableau / {{jsxref("Array")}}).
+
+ +

Valeur de retour

+ +

Une chaîne de caractères représentant les éléments de la liste et mise en forme en fonction de la langue souhaitée (grâce au paramètre locales passé au constructeur Intl.ListFormat).

+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.ListFormat.prototype.formatProposition de niveau 3
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.ListFormat.format")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/listformat/formattoparts/index.html b/files/fr/web/javascript/reference/global_objects/intl/listformat/formattoparts/index.html new file mode 100644 index 0000000000..fb3abe8afd --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/listformat/formattoparts/index.html @@ -0,0 +1,90 @@ +--- +title: Intl​.List​Format​.prototype​.formatToParts() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/ListFormat/formatToParts +tags: + - Internationalisation + - Intl + - JavaScript + - ListFormat + - Méthode + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/formatToParts +--- +
{{JSRef}}{{Draft}}
+ +

La méthode Intl.ListFormat.prototype.formatToParts() renvoie un tableau ({{jsxref("Array")}}) d'objets représentants les différentes composantes de la chaine de caractères qui est le résultat du formatage de la liste (selon les options de locale et de style indiquées).

+ +

Syntaxe

+ +
Intl.ListFormat.prototype.formatToParts(list)
+
+ +

Paramètres

+ +
+
list
+
Un tableau ({{jsxref("Array")}}) de valeurs à mettre en forme selon une locale et des options de style.
+
+ +

Valeur de retour

+ +

Un tableau ({{jsxref("Array")}}) de fragments composants la chaîne de caractères pour la liste formatée.

+ +

Description

+ +

Alors que la méthode {{jsxref("ListFormat.prototype.format()", "Intl.ListFormat.prototype.format()")}} renvoie une chaîne de caractères avec la liste formatée (en fonction de la locale et des options de style), formatToParts() renvoie un tableau des différentes composantes de cette chaîne.

+ +

Chaque élément du tableau résultant possède deux propriétés : type et value. La propriété type pourra valoir "element" (pour indiquer une valeur de la liste) ou "literal" (pour indiquer un élément linguistique). La propriété value fournit quant à elle le contenu du fragment sous forme d'une chaîne de caractères.

+ +

Les options de locale et de style utilisées pour le formatage sont fournies lors de la construction de l'instance {{jsxref("ListFormat", "Intl.ListFormat")}}.

+ +

Exemples

+ +
const fruits = ['Apple', 'Orange', 'Pineapple'];
+const myListFormat = new Intl.ListFormat('en-GB', { style: 'long', type: 'conjunction' });
+
+console.table(myListFormat.formatToParts(fruits));
+// [
+//  { "type": "element", "value": "Apple" },
+//  { "type": "literal", "value": ", " },
+//  { "type": "element", "value": "Orange" },
+//  { "type": "literal", "value": ", and " },
+//  { "type": "element", "value": "Pineapple" }
+// ]
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Intl.ListFormat.prototype.formatToParts proposalStage 3
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.ListFormat.formatToParts")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/listformat/index.html b/files/fr/web/javascript/reference/global_objects/intl/listformat/index.html new file mode 100644 index 0000000000..03dac95c7f --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/listformat/index.html @@ -0,0 +1,153 @@ +--- +title: Intl.ListFormat +slug: Web/JavaScript/Reference/Objets_globaux/Intl/ListFormat +tags: + - Experimental + - Internationalisation + - Intl + - JavaScript + - ListFormat + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/ListFormat +--- +
{{JSRef}}
+ +

L'objet Intl.ListFormat est un constructeur d'objets qui permettent de formater des listes de façon différente selon la langue utilisée.

+ +
{{EmbedInteractiveExample("pages/js/intl-listformat.html")}}
+ + + +

Syntax

+ +
new Intl.ListFormat([locales[, options]])
+
+ +

Paramètres

+ +
+
locales{{optional_inline}}
+
+

Paramètre optionnel. Une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour le format général et l'interprétation de l'argument locales, voir la page {{jsxref("Intl","Intl","#L'identification_et_le_choix_de_la_locale")}}.

+
+
options{{optional_inline}}
+
+

Paramètre optionnel. Un objet avec certaines ou toutes les propriétés suivantes :

+ +
+
localeMatcher
+
L'algorithme de correspondance à utiliser pour la locale. Les valeurs possibles sont "lookup" et "best fit" ; le défaut est "best fit". Pour des informations sur cette option, voir la page {{jsxref("Intl","Intl","##Choix_de_la_locale")}}.
+
type
+
Le format de sortie pour le message. Les valeurs possibles sont : +
    +
  • "conjunction" : qui concaténera les éléments de la liste avec des et. Cela produira par exemple, en anglais : A, B, and C
    • +
  • "disjunction" : qui concaténera les éléments de la liste avec des ou. Cela produira par exemple, en anglais : A, B, or C
    • +
  • "unit" : qui permet de gérer des listes de valeurs avec des unités. Cela produira par exemple 5 livres, 12 onces
    • +
+
+
style
+
Le niveau de concision/longueur du message obtenu. Les valeurs possibles sont : +
    +
  • "long" : par exemple A, B, and C
    • +
  • "narrow" : cette valeur permet uniquement d'utiliser le type unit et affichera un message concis : par exemple A, B, C
    • +
  • "short" : par exemple A, B, C
    • +
+
+
+
+
+ +

Description

+ +

Propriétés

+ +
+
{{jsxref("ListFormat.prototype", "Intl.ListFormat.prototype")}}
+
Cette propriété permet d'ajouter des propriétés à l'ensemble des objets de ce type.
+
+ +

Méthodes

+ +
+
{{jsxref("ListFormat.supportedLocalesOf", "Intl.ListFormat.supportedLocalesOf()")}}
+
Cette méthode renvoie un tableau des locales prises en charge par le moteur pour le formatage des heures sans qu'il y ait besoin d'utiliser la locale de l'environnement d'exécution.
+
+ +

Instances de Intl.ListFormat

+ +

Toutes les instances de Intl.ListFormat héritent de Intl.ListFormat.prototype.

+ +

Propriétés

+ +
+
Intl.ListFormat.prototype.constructor
+
Définit la fonction qui crée le prototype d'un objet.
+
+ +

Méthodes

+ +
+
{{jsxref("ListFormat.prototype.format","Intl.ListFormat.prototype.format()")}}
+
Renvoie une chaîne de caractères mise en forme selon la langue voulue et qui représente les éléments de la liste.
+
+ +

Exemples

+ +

Utiliser format()

+ +

Dans l'exemple qui suit, on voit comment créer un formateur de liste pour l'anglais.

+ +
const list = ['Motorcycle', 'Bus', 'Car'];
+
+ console.log(new Intl.ListFormat('en-GB', { style: 'long', type: 'conjunction' }).format(list));
+// > Motorcycle, Bus and Car
+
+ console.log(new Intl.ListFormat('en-GB', { style: 'short', type: 'disjunction' }).format(list));
+// > Motorcycle, Bus or Car
+
+ console.log(new Intl.ListFormat('en-GB', { style: 'narrow', type: 'unit' }).format(list));
+// > Motorcycle Bus Car
+
+ +

Utiliser formatToParts()

+ +

Dans l'exemple qui suit, on voit comment créer un formateur de liste, renvoyant les fragments, pour l'anglais

+ +
const list = ['Motorcycle', 'Bus', 'Car'];
+console.log(new Intl.ListFormat('en-GB', { style: 'long', type: 'conjunction' }).formatToParts(list));
+
+// > [ { "type": "element", "value": "Motorcycle" },
+       { "type": "literal", "value": ", " },
+       { "type": "element", "value": "Bus" },
+       { "type": "literal", "value": ", and " },
+       { "type": "element", "value": "Car" } ];
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.ListFormatProposition de niveau 3
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.ListFormat")}}

+ +

Voir aussi

+ +
{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl', 'Voir_aussi')}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/listformat/resolvedoptions/index.html b/files/fr/web/javascript/reference/global_objects/intl/listformat/resolvedoptions/index.html new file mode 100644 index 0000000000..3b0f36ea4e --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/listformat/resolvedoptions/index.html @@ -0,0 +1,82 @@ +--- +title: Intl​.List​Format​.prototype​.resolvedOptions() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/ListFormat/resolvedOptions +tags: + - Internationalisation + - Intl + - JavaScript + - ListFormat + - Méthode + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/resolvedOptions +--- +
{{JSRef}}{{Draft}}
+ +

La méthode  Intl.ListFormat.prototype.resolvedOptions() renvoie un nouvel objet dont les propriétés reflètent les options de locale et de style calculées à l'initialisation de l'objet {{jsxref("ListFormat")}}.

+ +

Syntaxe

+ +
listFormat.resolvedOptions()
+ +

Valeur de retour

+ +

Un nouvel objet dont les propriétés reflètent les options de locale et de style calculées lors de l'initialisation de l'objet {{jsxref("ListFormat")}}.

+ +

Description

+ +

L'objet renvoyé par resolvedOptions() possède les propriétés suivantes :

+ +
+
locale
+
La balise de langue BCP 47 qui est réellement utilisée. Si des extensions Unicode étaient fournies avec la balise d'origine et sont supportées pour la locale utilisée, les paires de clés-valeurs seront incluses dans locale.
+
style
+
La valeur fournie au constructeur via l'argument options ou la valeur utilisée par défaut ("long"). Cette propriété peut valoir "long", "short" ou "narrow".
+
type
+
La valeur fournie au constructeur via l'argument options ou la valeur par défaut ("conjunction"). Cette propriété peut valoir "conjunction", "disjunction" ou "unit".
+
+ +

Exemples

+ +
const deListFormatter = new Intl.ListFormat("de-DE", { style: "short" });
+
+const usedOptions = de.resolvedOptions();
+console.log(usedOptions.locale); // "de-DE"
+console.log(usedOptions.style);  // "short"
+console.log(usedOptions.type);   // "conjunction" (la valeur par défaut)
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.ListFormat.prototype.resolvedOptions()Proposition de niveau 3
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.ListFormat.resolvedOptions")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/listformat/supportedlocalesof/index.html b/files/fr/web/javascript/reference/global_objects/intl/listformat/supportedlocalesof/index.html new file mode 100644 index 0000000000..90abe4f56d --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/listformat/supportedlocalesof/index.html @@ -0,0 +1,88 @@ +--- +title: Intl.ListFormat.supportedLocalesOf() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/ListFormat/supportedLocalesOf +tags: + - Intl + - JavaScript + - ListFormat + - Méthode + - Reference + - i18n +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/supportedLocalesOf +--- +
{{JSRef}}
+ +

The Intl.ListFormat.supportedLocalesOf() renvoie, parmi les locales fournies, un tableau contenant les locales supportées pour le formatage des listes et qui ne nécessitent pas d'utiliser la locale par défaut de l'environnement.

+ +

Syntaxe

+ +
Intl.ListFormat.supportedLocalesOf(locales[, options])
+ +

Paramètres

+ +
+
locales
+
Une chaîne de caractères qui est une balise de langue BCP 47 ou bien un tableau de telles chaînes. Pour plus d'informations concernant la forme générale de l'argument locales, voir la page {{jsxref("Objets_globaux/Intl", "Intl", "#L'identification_et_le_choix_de_la_locale")}}.
+
options{{optional_inline}}
+
+

Paramètre facultatif. Un objet qui peut posséder les propriétés suivantes :

+ +
+
localeMatcher
+
+

L'algorithme utilisé pour la correspondance entre chaînes de caractères. Les valeurs possibles sont "lookup" et "best fit". La valeur par défaut est "best fit". Pour plus d'informations, voir la page {{jsxref("Objets_globaux/Intl", "Intl", "#Choix_de_la_locale")}}.

+
+
+
+
+ +

Valeur de retour

+ +

Un tableau de chaînes de caractères qui représente un sous-ensemble des balises de langues qui sont prises en charge pour le formatage des listes sans qu'il faille utiliser la locale par défaut de l'environnement d'exécution.

+ +

Description

+ +

Cette méthode renvoie un tableau qui est un sous-ensemble des balises de locales fournies avec l'argument locales. Les balises renvoyées sont celles supportées par l'environnement navigateur en termes de formatage des listes et qui ne nécessitent pas d'utiliser la locale par défaut.

+ +

Exemples

+ +

Utiliser supportedLocalesOf

+ +

Si on dispose d'un environnement (un navigateur par exemple) qui supporte le formatage des listes dans les locales indonésienne, allemande mais pas balinaise,  supportedLocalesOf renvoie les balises pour l'indonésien et l'allemand quand bien même le formatage des listes pinyin n'est pas utilisée avec l'indonésien et qu'il n'existe pas une version spécifique de l'allemand pour l'Indonésie. On illustre ici l'algorithme "lookup". SI on utilisait "best fit" pour trouver les locales correspondantes, on aurait pu avoir une balise supplémentaire pour le balinais en plus car la plupart des balinais comprennent l'indonésien.

+ +
const locales = ['ban', 'id-u-co-pinyin', 'de-ID'];
+const options = { localeMatcher: 'lookup' };
+console.log(Intl.ListFormat.supportedLocalesOf(locales, options).join(', '));
+// → "id-u-co-pinyin, de-ID"
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.ListFormat.supportedLocalesOfProposition de niveau 3 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.ListFormat.supportedLocalesOf")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/basename/index.html b/files/fr/web/javascript/reference/global_objects/intl/locale/basename/index.html new file mode 100644 index 0000000000..6b20ebee57 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/basename/index.html @@ -0,0 +1,75 @@ +--- +title: Intl.Locale.prototype.baseName +slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/baseName +tags: + - Internationalisation + - Intl + - JavaScript + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/baseName +--- +
{{JSRef}}
+ +

La propriété Intl.Locale.prototype.baseName renvoie un extrait de la chaîne de caractères représentant l'objet Locale. Cet extrait contient les informations essentielles à propos de l'objet Locale.

+ +

Description

+ +

Un objet Intl.Locale représente une locale ainsi que des options qui lui sont associées. La propriété baseName renvoie des informations essentielles quant à la locale sous la forme d'une chaîne de caractères. Cette chaîne est un extrait de la représentation textuelle complète de l'objet Locale. Cet extrait contient notamment la langue, le script utilisé ainsi que la région (s'ils sont disponibles).

+ +

Si on utilise la grammaire Unicode, baseName renvoie la sous-séquence language ["-" script] ["-" region] *("-" variant).

+ +

Exemples

+ +

Exemple simple

+ +
let myLoc = new Intl.Locale("fr-Latn-CA"); // Sets locale to Candanian French
+console.log(myLoc.toString()); // Prints out "fr-Latn-CA-u-ca-gregory"
+console.log(myLoc.baseName); // Prints out "fr-Latn-CA"
+ +

Exemple avec certaines options

+ +
// Sets language to Japanese, region to Japan,
+
+// calendar to Gregorian, hour cycle to 24 hours
+let japan = new Intl.Locale("ja-JP-u-ca-gregory-hc-24");
+console.log(japan.toString()); // Prints out "ja-JP-u-ca-gregory-hc-h24"
+console.log(japan.baseName); // Prints out "ja-JP"
+ +

Exemple avec options qui surchargent

+ +
// Input string indicates language as Dutch and region as Belgium,
+
+// but options object overrides the region and sets it to the Netherlands
+let dutch = new Intl.Locale("nl-Latn-BE", {region: "NL"});
+
+console.log(dutch.baseName); // Prints out "nl-Latn-NL"
+ +

Spécifications

+ + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.Locale.prototype.baseNameProposition de niveau 3
+ +

Compatibilité des navigateurs

+ + + +
{{Compat("javascript.builtins.Intl.Locale.baseName")}}
+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/calendar/index.html b/files/fr/web/javascript/reference/global_objects/intl/locale/calendar/index.html new file mode 100644 index 0000000000..cbe7f8db93 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/calendar/index.html @@ -0,0 +1,156 @@ +--- +title: Intl.Locale.prototype.calendar +slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/calendar +tags: + - Internationalisation + - Intl + - JavaScript + - Locale + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/calendar +--- +
{{JSRef}}
+ +

La propriété Intl.Locale.prototype.calendar est une propriété (via un accesseur) qui renvoie le type de calendrier utilisé par l'instance de Locale.

+ +

Description

+ +

La propriété calendar renvoie la partie de la locale qui indique le calendrier utilisé. Bien que la plupart des régions utilise le calendrier grégorien, il existe différents calendriers utilisés. Le tableau qui suit indique les clés Unicode pour les différents calendriers ainsi qu'une description.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Clés Unicode pour les calendriers
Clé UnicodeDescription
buddhistCalendrier bouddhiste
chineseCalendrier chinois traditionnel
copticCalendrier copte
dangiCalendrier coréen traditionnel
ethioaaCalendrier éthiopique, Amete Alem (an 0 situé environ à  5493 ans avant notre ère)
ethiopicCalendrier éthiopique, Amete Mihret (an 0 situé environ à 8 ans de notre ère)
gregoryCalendrier grégorien
hebrewCalendrier traditionnel hébreux
indianCalendrier indien
islamicCalendrier islamique
islamic-umalquraCalendrier islamique, Umm al-Qura
islamic-tblaCalendrier islamique tabulaire (années intercalaires [2,5,7,10,13,16,18,21,24,26,29] - origine des temps astronomique)
islamic-civilCalendrier islamique tabulaire (années intercalaires [2,5,7,10,13,16,18,21,24,26,29] - origine des temps civile)
islamic-rgsaCalendrier islamique vu de l'Arabie saoudite
iso8601Calendrier ISO (calendrier grégorien utilisant la numérotation des semaines ISO 8601)
japaneseCalendrier japonais impérial
persianCalendrier perse
rocCalendrier de la République de Chine
+
La clé  islamicc est désormais dépréciée et il faut utiliser islamic-civil à la place.
+ +

islamicc

+ 		Calendrier arabe civil (algorithmique)
+ +

Exemples

+ +

Indiquer le calendrier via la chaîne de définition de la locale

+ +

Les calendriers font partie des « clés d'extension ». Ces clés permettent d'ajouter des informations supplémentaires aux locales et sont ajoutées via l'extension -u. Ainsi, on peut indiquer le calendrier utilisé via la chaîne de locale passée comme argument au constructeur {{jsxref("Locale", "Intl.Locale")}}. Pour ce faire, on ajoutera d'abord -u à la chaîne « courte » de la locale puis -ca afin d'indiquer qu'on précise le calendrier et enfin la chaîne représentant la clé du calendrier.

+ +
let frBuddhist = new Intl.Locale("fr-FR-u-ca-buddhist");
+console.log(frBuddhist.calendar); // affiche "buddhist" dans la console
+ +

Spécifier un calendrier grâce à un objet de configuration

+ +

Le constructeur {{jsxref("Locale", "Intl.Locale")}} peut utiliser un argument optionnel qui est un objet permettant de configurer la locale via différentes extensions dont les calendriers. En utilisant la propriété calendar de cet objet, on définit le calendrier qui sera utilisé :

+ +
let frBuddhist = new Intl.Locale("fr-FR", {calendar: "buddhist"});
+console.log(frBuddhist.calendar); // affiche "buddhist" dans la console
+
+ +

Spécifications

+ + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.Locale.prototype.calendarProposition de niveau 3
+ +

Compatibilité des navigateurs

+ + + +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/casefirst/index.html b/files/fr/web/javascript/reference/global_objects/intl/locale/casefirst/index.html new file mode 100644 index 0000000000..7403262d3d --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/casefirst/index.html @@ -0,0 +1,94 @@ +--- +title: Intl.Locale.prototype.caseFirst +slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/caseFirst +tags: + - Internationalisation + - Intl + - JavaScript + - Locale + - Propriété + - Reference + - Unicode +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/caseFirst +--- +
{{JSRef}}
+ +

La propriété Intl.Locale.prototype.caseFirst est une propriété (via un accesseur) qui 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).

+ +

Description

+ +

Les règles de collation des locales sont utilisées afin de déterminer la façon dont les chaînes sont ordonnées pour cette locale. Certaines locales utilisent la casse (minuscule ou majuscule) dans ce processus de collation. Cette règle peut être exprimée via la propriété caseFirst d'une instance Locale.

+ +

Cette propriété peut avoir une des 3 valeurs suivantes :

+ + + + + + + + + + + + + + + + + + + + + + + +
Valeurs pour caseFirst
ValeurDescription
upperLes majuscules devraient être triées avant les minuscules.
lowerLes minuscules devraient être triées avant les majuscules.
falseLa casse n'a pas d'importance pour le tri des chaînes.
+ +

Exemples

+ +

Définir caseFirst grâce à la chaîne de description de la locale

+ +

Le constructeur Intl.Locale prend comme premier argument une chaîne de caractères qui décrit la locale. On peut allonger cette chaîne avec certaines valeurs afin de l'affiner.

+ +

Dans la spécification Unicode sur les clés des extensions, caseFirst correspond à la clé kf. kf. Il est possible d'ajouter des extensions à la chaîne identifiant la locale en la concaténant à -u puis en concaténant la clé de l'extension qu'on souhaite préciser (ici -kf) puis en ajoutant enfin la valeur pour cette extension (ici upper) :

+ +
let caseFirstStr = new Intl.Locale("fr-Latn-FR-u-kf-upper");
+console.log(caseFirstStr.caseFirst); // Prints "upper"
+ +

Définir caseFirst via l'objet de configuration

+ +

Le constructeur Intl.Locale permet d'utiliser un objet de configuration comme deuxième argument. Les propriétés de cet objet seront autant d'extensions Unicode à utiliser pour la locale. Ici, on peut utiliser un objet avec la propriété caseFirst pour indiquer l'impact de la casse sur la collation de cette locale :

+ +
let caseFirstObj= new Intl.Locale("en-Latn-US", {caseFirst: "lower"});
+console.log(us12hour.caseFirst); // affichera "lower" dans la console.
+ +

Spécifications

+ + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.LocaleProposition de niveau 3
+ +

Compatibilité des navigateurs

+ + + +
{{Compat("javascript.builtins.Intl.Locale.caseFirst")}}
+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/collation/index.html b/files/fr/web/javascript/reference/global_objects/intl/locale/collation/index.html new file mode 100644 index 0000000000..46482bcd73 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/collation/index.html @@ -0,0 +1,167 @@ +--- +title: Intl.Locale.prototype.collation +slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/collation +tags: + - Internationalisation + - Intl + - JavaScript + - Locale + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/collation +--- +
{{JSRef}}
+ +

La propriété Intl.Locale.prototype.collation est une propriété (à laquelle on accède via un accesseur) qui renvoie le type de collation pour l'instance de Locale 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.

+ +

Description

+ +

La collation est la façon dont les chaînes de caractères sont ordonnées. Elle est utilisée lorsqu'on doit trier des chaînes de caractères (des résultats de recherche, des enregistrements dans une base de donnée, etc.). Bien que cela puisse sembler trivial, la collation varie d'une région à l'autre et d'une langue à une autre. Cette propriété permet aux développeurs de connaître le type de collation pour une locale donnée.

+ +

Voici un tableau listant les types de collation possibles tels que définis dans la spécification Unicode sur la collation.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Les différents types de collation
Type de collationDescription
big5hanOrdre pinyin pour l'alphabet latin et ordre big5 pour les caractères CJK (utilisés en chinois)
compatUne version précédente de l'ordre, utilisée à des fins de compatibilité
dictOrdre à la façon d'un dictionnaire (comme utilisé en cingalais)
+
+

Le type direct a été déprécié et ne doit pas être utilisé.

+
+ +

direct

+ 		Ordre des points de code binaires (utilisé en hindoux)
ducetLa collation Unicode par défaut pour les éléments d'un tableau
emojiL'ordre recommandé pour les émojis
eorRègles d'ordre européennes
gb2312Ordre pinyin pour l'alphabet latin et ordre gb2312han pour les caractères CJK (utilisés en chinois)
phonebkOrdre à la façon d'un annuaire (tel qu'en allemand)
phoneticOrdre phonétique, basé sur la prononciation
pinyinOrdre pinyin pour les caractères de l'alphabet latin et les caractères CJK (utilisés en chniois)
reformedOrdre réformé (tel qu'en suédois)
searchCollation spéciale pour les chaînes de caractères utilisées pour des recherches
searchjlCollation spéciale pour la recherche des consonnes initiales en coréen
standardL'ordre par défaut pour chaque langue
strokeOrdre pinyin pour l'alphabet latin et ordre de dessin (stroke) pour les caractères CJK (utilisés en chinois)
tradOrdre traditionnel (tel qu'en espagnol)
unihanOrdre pinyin pour l'alphabet latin et ordre Unihan radical pour les caractères CJK (utilisés en chinois)
zhuyin +

Ordre pinyin pour l'alphabet latin, ordre zhuyin pour les caractères Bopomofo et CJK (utilisés en chinois)

+
+ +

Exemples

+ +

À l'instar des autres étiquettes, le type de collation peut être défini pour l'objet {{jsxref("Locale", "Intl.Locale")}} via la chaîne de caractères qui définit la locale ou grâce au deuxième paramètre du constructeur qui est un objet de configuration.

+ +

Définir le type de collation via la chaîne décrivant la locale

+ +

Le premier argument passé à Intl.Locale est une chaîne de caractères qui décrit la locale. Cette chaîne peut contenir des fragments additionnels (en plus de l'identifiant canonique de la locale). Pour cela, on ajoutera -u afin d'indiquer qu'on définit une extension. On ajoutera ensuite la clé identifiant cette extension, ici -co pour la collation. Enfin, on ajoutera la valeur souhaitée pour cette extension (dans cet exemple, -emoji) :

+ +
let stringColl = new Intl.Locale("en-Latn-US-u-co-emoji");
+console.log(stringColl.collation); // Affichera "emoji" dans la console
+
+ +

Définir le type de collation via l'objet de configuration

+ +

Le constructeur Intl.Locale possède un deuxième argument optionnel qui est un objet de configuration. Chaque propriété de cet objet pourra permettre de préciser une extension à la locale, y compris un type de collation. Pour définir le type de collation, on pourra utiliser une propriété collation sur cet objet avec une des valeurs indiquées ci-avant :

+ +
let configColl = new Intl.Locale("en-Latn-US", {collation: "emoji"});
+console.log(configColl.collation); // Affichera "emoji" dans la console
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.Locale.prototype.collationProposition de niveau 3
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.Locale.collation")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/hourcycle/index.html b/files/fr/web/javascript/reference/global_objects/intl/locale/hourcycle/index.html new file mode 100644 index 0000000000..f88b4c5441 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/hourcycle/index.html @@ -0,0 +1,95 @@ +--- +title: Intl.Locale.prototype.hourCycle +slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/hourCycle +tags: + - Internationalisation + - Intl + - JavaScript + - Locale + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/hourCycle +--- +
{{JSRef}}
+ +

La propriété Intl.Locale.prototype.hourCycle est une propriété accessible via un accesseur qui renvoie la convention pour le format des heures utilisée par la locale courante.

+ +

Description

+ +

Il existe deux types de conventions pour la représentation des heures : sur douze heures d'une part et sur vingt-quatre heures d'autre part. La propriété hourCycle permet aux développeurs de connaître la représentation utilisée par une locale donnée. À l'instar des autres données fournies par les instances de Locale, hourCycle représente une extension Unicode qui permet d'affiner le comportement d'une locale. Les valeurs de cette propriété/extension peuvent être :

+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
Valeurs possibles pour l'extension hourCycle
CléDescription
h12Système horaire sur les heures 1 à 12 (correspond à la notation "h" pour les motifs de recherche). L'horloge est sur douze heures et minuit commence à 12:00 AM.
h23Système horaire sur les heures 0 à 23 (correspond à la notation "H" pour les motifs de recherche). L'horloge est sur vingt-quatre heures et minuit commence à 0:00.
h11Système horaire sur les heures 0 à 11 (correspond à la notation "K" pour les motifs de recherche). L'horloge est sur douze heures et minuit commence à 0:00 AM.
h24Système horaire sur les heures 1 à 24 (correspond à la notation "K" pour les motifs de recherche). L'horloge est sur vingt-quatre heures et minuit commence à 24:00.
+ +

Exemples

+ +

Définir le format horaire grâce à la chaîne décrivant la locale

+ +

Il est possible de préciser la valeur d'une extension Unicode dans la chaîne de caractères représentant la locale. Pour indiquer l'extension, on ajoutera le suffixe -u qui indique une clé d'extension à venir, ensuite on ajoutera la clé de l'extension en question (ici -hc) et enfin on ajoutera la valeur souhaitée pour cette extension.

+ +
let fr24hour = new Intl.Locale("fr-FR-u-hc-h23");
+console.log(fr24hour.hourCycle); // Affichera "h23" dans la console
+ +

Définir le format horaire grâce à un objet de configuration

+ +

Le constructeur Intl.Locale permet d'utiliser un objet de configuration comme deuxième argument. Les propriétés de cet objet permettent de définir différentes extensions, y compris celle pour le format horaire. Pour cela, on indiquera la propriété hourCycle sur l'objet de configuration avec la valeur souhaitée et on passera cet objet au constructeur.

+ +
let us12hour = new Intl.Locale("en-US-u-hc-h12");
+console.log(us12hour.hourCycle); // Affichera "h12" dans la console
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.LocaleProposition de niveau 3
+ +

Compatibilité des navigateurs

+ + + +
{{Compat("javascript.builtins.Intl.Locale.hourCycle")}}
+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/index.html b/files/fr/web/javascript/reference/global_objects/intl/locale/index.html new file mode 100644 index 0000000000..f5e22804fa --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/index.html @@ -0,0 +1,74 @@ +--- +title: Intl.Locale +slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale +tags: + - Constructeur + - Intl + - JavaScript + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale +--- +
{{JSRef}}{{SeeCompatTable}}
+ +

Le constructeur Intl.Locale est une propriété native de l'objet Intl représentant l'identifiant d'une locale Unicode.

+ +

{{EmbedInteractiveExample("pages/js/intl-locale.html")}}

+ + + +

Syntaxe

+ +
new Intl.Locale([tag[, options]])
+ +

Paramètres

+ +
+
tag
+
La chaîne de caractère représentant l'identifiant d'une locale Unicode.
+
options
+
Un objet contenant la configuration pour la locale. Les clés (noms des propriétés) de cet objets sont des balises Unicode et les valeurs de ces propriétés doivent être des valeurs de balises Unicode valides.
+
+ +

Description

+ +

L'objet Intl.locale a été conçu afin de manipuler des locales Unicode. Les locales Unicode sont représentées par une chaîne de caractères qu'on appelle « identifiant de locale ». L'identifant de locale se compose d'un identifiant de langue et d'extensions. Les identifiants de langue sont la composante principale d'une locale et contiennent une langue, un système d'écriture et des extensions régionales. Les informations complémentaires sont stockées via les extensions. Ces extensions peuvent fournir des informations quant au type de calendrier utilisé, le format d'heure utilisé ou la numération utilisée.

+ +

L'objet Intl.Locale possède les propriétés et méthodes suivantes.

+ +

Propriétés

+ +
+
{{jsxref("Locale.prototype","Intl.Locale.prototype")}}
+
Le prototype pour le constructeur Locale.
+
+ +

Spécifications

+ + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.LocaleProposition de niveau 3
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.Locale")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/language/index.html b/files/fr/web/javascript/reference/global_objects/intl/locale/language/index.html new file mode 100644 index 0000000000..1a3f95566d --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/language/index.html @@ -0,0 +1,69 @@ +--- +title: Intl.Locale.prototype.language +slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/language +tags: + - Internationalisation + - Intl + - JavaScript + - Locale + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/language +--- +
{{JSRef}}
+ +

La propriété Intl.Locale.prototype.language est une propriété fournie via un accesseur qui renvoie la langue associée à la locale.

+ +

Description

+ +

La langue est l'une des caractéristiques majeurs d'une locale. La spécification Unicode indique que l'identifiant de la langue d'une locale est composée de l'identifiant canonique de la langue et de l'identifiant de la réponse (on pourra ainsi distinguer l'anglais britannique de l'anglais américain). Toutefois, la propriété language de {{jsxref("Locale", "Locale")}} renvoie uniquement la composante relative à la langue.

+ +

Exemples

+ +

Indiquer la langue via la chaîne décrivant la locale

+ +

Afin de pouvoir représenter une locale Unicode correctement, une chaîne doit commencer par un identifiant de langue. Le principal argument du constructeur {{jsxref("Locale", "Locale")}} doit être un identifiant valide et doit donc contenir la composante liée à la langue.

+ +
let langStr = new Intl.Locale("en-Latn-US");
+
+console.log(langStr.language); // Affichera "en" dans la console
+ +

Surcharger la langue via l'objet de configuration

+ +

Bien que la composante de la langue doive être indiquée dans le premier paramètre, le constructeur {{jsxref("Locale", "Locale")}} prend comme deuxième argument un objet de configuration qui permet de surcharger cette composante.

+ +
let langObj = new Intl.Locale("en-Latn-US", {language: "es"});
+
+console.log(langObj.language); // Affichera "es" dans la console
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.Locale.prototype.languageProposition de niveau 3
+ +

Compatibilité des navigateurs

+ + + +
{{Compat("javascript.builtins.Intl.Locale.language")}}
+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/maximize/index.html b/files/fr/web/javascript/reference/global_objects/intl/locale/maximize/index.html new file mode 100644 index 0000000000..678db44d6e --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/maximize/index.html @@ -0,0 +1,78 @@ +--- +title: Intl.Locale.prototype.maximize() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/maximize +tags: + - Internationalisation + - Intl + - JavaScript + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/maximize +--- +
{{JSRef}}
+ +

La méthode Intl.Locale.prototype.maximize() 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.

+ +

{{EmbedInteractiveExample("pages/js/intl-locale-prototype-maximize.html")}}

+ + + +

Syntaxe

+ +
locale.maximize()
+ +

Valeur de retour

+ +

Une instance {{jsxref("Locale", "Locale")}} dont la propriété baseName renvoie le résultat de l'algorithme de vraisemblance des composantes lancé sur {{jsxref("Locale/baseName", "locale.baseName")}}.

+ +

Description

+ +

Il est parfois utile d'identifier les composantes les plus probables d'une locale en fonction d'un identifiant incomplet. Cette méthode utilise un algorithme qui permet de déduire les composantes restantes les plus probables. Par exemple, si on fournit la langue "en", l'algorithme renverra "en-Latn-US", car l'anglais ne s'écrit qu'avec l'alphabet latin et est le plus largement parlé aux États-Unis. La méthode maximize() n'opère que sur les composantes principales (langue, script, région) et pas sur les extensions éventuellement indiquées après "-u" (dont Locale.hourCycle, Locale.calendar et Locale.numeric entre autres).

+ +

Exemples

+ +
let maLocale = new Intl.Locale("fr", {hourCycle: "h24", calendar: "gregory"});
+console.log(maLocale.baseName); // Affiche "fr"
+console.log(maLocale.toString()); // Affiche "fr-u-ca-gregory-hc-h24"
+let maLocMaximized = maLocale.maximize();
+
+// Affiche "fr-Latn-FR". Les composantes "Latn" et "FR" ont été ajoutées
+// car le français ne s'écrit qu'avec l'alphabet latin et est plus probablement parlé en France.
+console.log(maLocMaximized.baseName);
+
+// Affiche "fr-Latn-FR-u-ca-gregory-hc-h24".
+// On notera que les extensions (après "-u") restent inchangées.
+console.log(myLocMaximized.toString());
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.Locale.prototype.maximize()
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.Locale.maximize")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/minimize/index.html b/files/fr/web/javascript/reference/global_objects/intl/locale/minimize/index.html new file mode 100644 index 0000000000..57549456bd --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/minimize/index.html @@ -0,0 +1,80 @@ +--- +title: Intl.Locale.prototype.minimize() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/minimize +tags: + - Internationalisation + - Intl + - JavaScript + - Locale + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/minimize +--- +
{{JSRef}}
+ +

La méthode Intl.Locale.prototype.minimize() tente de retirer les informations qui auraient pu être ajoutée à une locale lors d'un appel à {{jsxref("Locale/maximize", "Locale.maximize()")}}. 

+ +

{{EmbedInteractiveExample("pages/js/intl-locale-prototype-minimize.html")}}

+ + + +

Syntaxe

+ +
locale.minimize()
+ +

Valeur de retour

+ +

Une instance {{jsxref("Locale", "Locale")}} dont la propriété baseName renvoie le résultat de l'exécution de l'algorithme de suppression des composantes probables sur locale.baseName. 

+ +

Description

+ +

Cette méthode effectue l'opération inverse de {{jsxref("Locale/maximize", "maximize()")}}, en retirant les fragments de langue/script ou de région qui sont superflus. Ainsi, "en-Latn" pourra être minimisé en "en" car l'anglais s'écrit uniquement à l'aide de l'alphabet latin.

+ +

minimize() ne modifie pas les éventuelles extensions décrites dans la chaîne de locale (après le "-u") ou via l'objet de configuration (elle ne modifie donc pas les valeurs de {{jsxref("Locale/hourCycle", "Locale.hourCycle")}}, {{jsxref("Locale/calendar", "Locale.calendar")}} et {{jsxref("Locale/numeric", "Locale.numeric")}}).

+ +

Exemples

+ +
let maLocale = new Intl.Locale("fr-Latn-FR", {hourCycle: "h24", calendar: "gregory"});
+console.log(maLocale.baseName); // Affiche "fr-Latn-FR"
+console.log(maLocale.toString()); // Affiche "fr-Latn-FR-u-ca-gregory-hc-h24"
+let maLocMinimized = maLocale.minimize();
+
+console.log(maLocMinimized.baseName);
+// Affiche "fr" car le français est écrit uniquement avec l'alphabet latin et
+// parlé le plus largement en France
+
+console.log(maLocMinimized.toString());
+// Affiche "fr-u-ca-gregory-hc-h24". On voit ici que les extensions
+// (décrites après "-u") restent inchangées.
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.Locale.prototype.minimize()
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.Locale.minimize")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/numberingsystem/index.html b/files/fr/web/javascript/reference/global_objects/intl/locale/numberingsystem/index.html new file mode 100644 index 0000000000..076b671499 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/numberingsystem/index.html @@ -0,0 +1,425 @@ +--- +title: Intl.Locale.prototype.numberingSystem +slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/numberingSystem +tags: + - Internationalisation + - Intl + - JavaScript + - Locale + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/numberingSystem +--- +
{{JSRef}}
+ +

La propriété Intl.Locale.prototype.numberingSystem est une propriété fournie par un accesseur qui renvoie le système de numération utilisée par la locale.

+ +

Description

+ +

Un système de numération est un système qui permet d'exprimer les nombres. La propriété numberingSystem permet de connaître le système de numérati Unicode. A table of the standard Unicode numeral systems can be seen belowon de la locale. Les valeurs qui peuvent être fournies par cette propriété sont standardisées par Unicode.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ValeurDescription
adlmChiffres adlams
ahomChiffres ahoms
arabChiffres arabes
arabextChiffres arabes étendus
armnNumération arménienne majuscule (algorithmique)
armnlowNumération arménienne minuscule (algorithmique)
baliChiffres balinais
bengChiffres bengalis
bhksChiffres bhaiksuki
brahChiffres brahmis
cakmChiffres chakmas
chamChiffres chams
cyrlNumération cyrillique (algorithmique)
devaChiffres devanagaris
ethiNumération éthiopienne (algorithmique)
financeNumération financière (peut être algorithmique)
fullwideChiffres à pleine chasse
georNumération géorgienne (algorithmique)
gongChiffres Gunjala Gondis
gonmChiffres Masaram Gondis
grekNumération greque majuscule (algorithmique)
greklowNumération greque minuscule (algorithmique)
gujrChiffres Gujaratis
guruChiffres Gurmukhis
hanidaysNumération du jour du mois avec caractère Han (utilisée avec les calendriers lunaires ou traditionnels)
hanidecSystème décimal positionnel utilisant les idéographes des nombres chinois comme chiffres
hansNumération chinoise simplifiée (algorithmique)
hansfinNumération chinoise simplifiée financière (algorithmique)
hantNumération chinoise traditionnelle (algorithmique)
hantfinNumération chinoise traditionnelle financière (algorithmique)
hebrNumération hébraïque (algorithmique)
hmngChiffres Pahawh Hmongs
hmnpChiffres Nyiakeng Puachue Hmongs
javaChiffres javanais
jpanNumération japonaise (algorithmique)
jpanfinNumération japonaise financière (algorithmique)
jpanyearNumération basée sur la première année Gannen du calendrier japonais
kaliChiffres Kayah Lis
khmrChiffres Khmers
kndaChiffres Kannadas
lanaChiffres Tai Tham Hora séculiers
lanathamChiffres Tai Tham Tham ecclésiastiques
laooChiffres laotien
latnChiffres latins
lepcChiffres Lepchas
limbChiffres Limbus
mathboldChiffres mathématiques en gras
mathdblChiffres mathématiques barrés en double
mathmonoChiffres mathématiques à chasse fixe
mathsanbChiffres mathématiques en gras sans empattements
mathsansChiffres mathématiques sans empattements
mlymChiffres Malayalams
modiChiffres Modis
mongChiffres mongols
mrooChiffres Mros
mteiChiffres Meetei Mayeks
mymrChiffres Myanmars
mymrshanChiffres Myanmar Shans
mymrtlngChiffres Myanmar Tai Laings
nativeChiffres natifs
newaChiffres Newas
nkooChiffres N'Kos
olckChiffres Ol Chikis
oryaChiffres Oriyas
osmaChiffres Osmanyas
rohgChiffres Hanifi Rohingyas
romanNumération romaine majuscule (algorithmique)
romanlowNumération romaine minuscule (algorithmique)
saurChiffres Saurashtras
shrdChiffres Sharadas
sindChiffres Khudawadis
sinhChiffres Sinhala Liths
soraChiffres Sora_Sompengs
sundChiffres soudanais
takrChiffres Takris
taluChiffres New Tai Lues
tamlNumération tamoule (algorithmique=
tamldecChiffres tamouls décimaux modernes
teluChiffres Telugus
thaiChiffres thaïs
tirhChiffres Tirhutas
tibtChiffres tibétains
traditioNumération traditionnelle (peut être algorithmique)
vaiiChiffres Vais
waraChiffres Warang Citis
wchoChiffres Wanchos
+ +

Exemples

+ +

Définir la valeur de numberingSystem grâce à la chaîne décrivant la locale

+ +

D'après la spécification Unicode sur les chaînes décrivant les locales, l'extension décrivant le système de numération est indiquée par la clé nu.

+ +

Le constructeur Intl.locale prend comme premier argument une chaîne de caractères décrivant la locale. Aussi, on peut indiquer le système de numération après les composantes principales de la chaîne de caractères en lui ajoutant un "-u" (indiquant la présence d'une extension), suivi d'un "-nu" (indiquant que l'extension qui sera indiquée décrit le système de numération, suivi de la valeur voulue pour le système de numération.

+ +
let numberingSystemViaStr = new Intl.Locale("fr-Latn-FR-u-nu-mong");
+console.log(numberingSystemStr.numberingSystem);
+// affichera "mong" dans la console
+ +

Définir la valeur de numberingSystem grâce à un objet de configuration

+ +

Le constructeur Intl.Locale possède un deuxième argument, optionnel, qui est un objet permettant de configurer la locale. Les propriétés de cet objet sont utilisées comme extensions pour la locale ; les clés des propriétés sont les noms des extensions et leurs valeurs sont celles utilisées pour chaque extension. On peut donc utiliser la propriété numberingSystem sur cet objet afin de définir le système de numération à utiliser pour cette locale.

+ +
let numberingSystemViaObj= new Intl.Locale("en-Latn-US", {numberingSystem: "latn"});
+console.log(us12hour.numberingSystem);
+// affichera "latn" dans la console
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.LocaleProposition de niveau 3
+ +

Compatibilité des navigateurs

+ + + +
{{Compat("javascript.builtins.Intl.Locale.numberingSystem")}}
+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/numeric/index.html b/files/fr/web/javascript/reference/global_objects/intl/locale/numeric/index.html new file mode 100644 index 0000000000..5b3c357b09 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/numeric/index.html @@ -0,0 +1,69 @@ +--- +title: Intl.Locale.prototype.numeric +slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/numeric +tags: + - Internationalisation + - Intl + - JavaScript + - Locale + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/numeric +--- +
{{JSRef}}
+ +

La propriété Intl.Locale.prototype.numeric est une propriété fournie par un accesseur et qui 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).

+ +

Description

+ +

À l'instar de {{jsxref("Locale.caseFirst", "Intl.Locale.caseFirst")}}, numeric représente une modification des règles de collation utilisée par la locale. numeric est un booléen (true ou false). Lorsque cette propriété vaut false, il n'y a pas de gestion particulière des chiffres et si cette propriété vaut true, cela indique que les caractères numériques sont pris en compte lors de la collation des chaînes. Ainsi, les séquences de chiffres décimaux seront comparés comme des nombres. Ainsi, la chaîne de caractères "A-21" sera considérée inférieure à "A-123".

+ +

Exemples

+ +

Définir numeric grâce à la chaîne de description de la locale

+ +

Selon la spécification Unicode sur les chaînes de caractères décrivant les locales, les valeurs de numeric sont associées à la clé kn. Pour utiliser cette clé dans la chaîne de description de la locale (le premier argument de Intl.Locale), après la chaîne de base, on pourra ajouter un suffixe avec "-u" afin d'indiquer la présence d'une extension, puis "-kn" afin de préciser l'extension en question et enfin la valeur souhaitée pour cette extension. Si on veut que numeric soit true, il suffit d'ajouter la clé kn. Pour indiquer la valeur false, il faudra explicitement ajouter "-false".

+ +
let numericViaStr = new Intl.Locale("fr-Latn-FR-u-kn-false");
+console.log(numericStr.numeric);
+// Affichera "false" dans la console
+ +

Définir numeric via l'objet de configuration de l'instance

+ +

Le constructeur Intl.Locale possède un deuxième argument, optionnel, qui est un objet permettant de configurer la locale. Les propriétés de cet objet sont utilisées comme extensions pour la locale ; les clés des propriétés sont les noms des extensions et leurs valeurs sont celles utilisées pour chaque extension. On peut donc utiliser la propriété numeric sur cet objet afin de définir le système de numération à utiliser pour cette locale.

+ +
let numericViaObj= new Intl.Locale("en-Latn-US", {numeric: true});
+console.log(us12hour.numeric);
+// Affichera "true" dans la console
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.LocaleProposition de niveau 3
+ +

Compatibilité des navigateurs

+ + + +
{{Compat("javascript.builtins.Intl.Locale.numeric")}}
+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/region/index.html b/files/fr/web/javascript/reference/global_objects/intl/locale/region/index.html new file mode 100644 index 0000000000..c9af9b9ac3 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/region/index.html @@ -0,0 +1,71 @@ +--- +title: Intl.Locale.prototype.region +slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/region +tags: + - Internationalisation + - Intl + - JavaScript + - Locale + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/region +--- +
{{JSRef}}
+ +

La propriété Intl.Locale.prototype.region est fournie par un accesseur qui renvoie la région du monde (il s'agit généralement d'un pays) associée à la locale courante.

+ +

Description

+ +

La région est un fragment majeur de l'identifiant de la locale car il situe la locale dans une zone donnée du monde. Connaître la région associée à la locale est crucial pour identifier les différences entre les locales. Ainsi, on parle anglais aux États-Unis et au Royaume-Uni mais il existe certaines différences d'orthographe entre ces pays. Connaître la région d'une locale peut permettre aux développeurs d'adapter leurs sites et applications selon la région depuis laquelle ils sont consultés.

+ +

Exemples

+ +

Définir la région avec la chaîne de caractères décrivant la locale

+ +

La région est la troisième composante d'une chaîne représentant un identifiant de langue Unicode. Cette chaîne de caractères est généralement passée au constructeur {{jsxref("Locale", "Locale")}}.

+ +
let regionStr = new Intl.Locale("en-Latn-US");
+
+console.log(regionStr.region);
+// Affichera "US" dans la console
+ +

Définir la région via l'objet de configuration du constructeur

+ +

Le constructeur {{jsxref("Locale", "Locale")}} prend comme second argument un objet de paramétrage dont chacune des propriétés permet de définir une extension ou une composante de la locale.

+ +
let regionObj = new Intl.Locale("fr-Latn", {region: "FR"});
+
+console.log(regionObj.region);
+// Affichera "FR" dans la console
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.Locale.prototype.regionProposition de niveau 3
+ +

Compatibilité des navigateurs

+ + + +
{{Compat("javascript.builtins.Intl.Locale.region")}}
+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/script/index.html b/files/fr/web/javascript/reference/global_objects/intl/locale/script/index.html new file mode 100644 index 0000000000..3fed9f8169 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/script/index.html @@ -0,0 +1,68 @@ +--- +title: Intl.Locale.prototype.script +slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/script +tags: + - Internationalisation + - Intl + - JavaScript + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/script +--- +
{{JSRef}}
+ +

La propriété Intl.Locale.prototype.script est fournie via un accesseur et renvoie le script utilisé pour l'écriture d'une langue donnée pour la locale courante.

+ +

Description

+ +

Un script, ou système d'écriture, est l'une des caractéristiques fondamentales d'une locale. Il décrit l'ensemble des symboles (ou glyphes) qui sont utilisés pour écrire dans une langue donnée. Ainsi, le script associé à l'anglais est l'alphabet latin, le script associé au coréen est le Hangul. Dans la plupart des cas, indiquer le script n'est pas strictement nécessaire car une langue ne s'écrit que dans un script donné. Il existe toutefois des exceptions et il est préférable d'indique le script afin d'avoir un identifiant de langue Unicode complet.

+ +

Exemples

+ +

Définir le script via la chaîne de description de la locale

+ +

Le script correspond à la deuxième partie d'un identifiant de langue Unicode valide. On peut donc le définir en passant un tel identifiant au constructeur {{jsxref("Locale", "Locale")}}. Toutefois, cette composante n'est pas obligatoire pour créer une instance de Locale.

+ +
let scriptStr = new Intl.Locale("en-Latn-US");
+
+console.log(scriptStr.script); // Affichera "Latn" dans la console
+ +

Définir le script grâce à l'objet de configuration du constructeur

+ +

Le constructeur {{jsxref("Locale", "Locale")}} permet d'utiliser un objet de configuration dont les propriétés définiront les caractéristiques de la locale :

+ +
let scriptObj = new Intl.Locale("fr-FR", {script: "Latn"});
+
+console.log(scriptObj.script); // Affichera "Latn" dans la console
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.Locale.prototype.scriptProposition de niveau 3
+ +

Compatibilité des navigateurs

+ + + +
{{Compat("javascript.builtins.Intl.Locale.script")}}
+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/tostring/index.html b/files/fr/web/javascript/reference/global_objects/intl/locale/tostring/index.html new file mode 100644 index 0000000000..723f7cd4b3 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/tostring/index.html @@ -0,0 +1,69 @@ +--- +title: Intl.Locale.prototype.toString() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/Locale/toString +tags: + - Intl + - JavaScript + - Locale + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/Locale/toString +--- +
{{JSRef}}
+ +

La méthode Intl.Locale.prototype.toString() renvoie l'identifiant de locale complet pour la locale courante.

+ +

{{EmbedInteractiveExample("pages/js/intl-locale-prototype-tostring.html")}}

+ + + +

Syntaxe

+ +
locale.toString()
+ +

Valeur de retour

+ +

La chaîne de caractères représentant l'identifiant complet de la locale.

+ +

Description

+ +

Une instance de Locale est une représentation JavaScript d'une locale au sens Unicode. Les informations décrivant une locale donnée (la langue, le système d'écriture, le type de calendrier, etc.) peuvent être encodées en une chaîne de caractères qui est l'identifiant de la locale. Lorsqu'on appelle la méthode toString() sur une instance de Locale, on obtiendra l'identifiant complet de la locale.

+ +

Exemples

+ +
let maLocale = new Intl.Locale("fr-Latn-FR", {hourCycle: "h24", calendar: "gregory"});
+console.log(maLocale.baseName); // Affiche "fr-Latn-FR"
+console.log(maLocale.toString()); // Affiche "fr-Latn-FR-u-ca-gregory-hc-h24"
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.Locale.prototype.toString()Proposition de niveau 3
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.Locale.toString")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/numberformat/format/index.html b/files/fr/web/javascript/reference/global_objects/intl/numberformat/format/index.html new file mode 100644 index 0000000000..201022bd58 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/numberformat/format/index.html @@ -0,0 +1,97 @@ +--- +title: Intl.NumberFormat.prototype.format +slug: Web/JavaScript/Reference/Objets_globaux/Intl/NumberFormat/format +tags: + - Internationalisation + - Intl + - JavaScript + - NumberFormat + - Propriété + - Prototype + - Reference + - i18n +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/format +--- +
{{JSRef}}
+ +

La méthode Intl.NumberFormat.prototype.format() formate un nombre en fonction des options de locales et de formats définis dans l'objet {{jsxref("NumberFormat", "Intl.NumberFormat")}} correspondant.

+ +
{{EmbedInteractiveExample("pages/js/intl-numberformat-prototype-format.html")}}
+ + + +

Syntaxe

+ +
numberFormat.format(nombre)
+ +

Paramètres

+ +
+
nombre
+
Le nombre qu'on souhaite formater.
+
+ +

Description

+ +

La fonction d'accesseur format permet de formater un nombre donné en une chaîne de caractères selon les options de locale et de format de l'objet {{jsxref("NumberFormat", "Intl.NumberFormat")}}.

+ +

Exemples

+ +

Utiliser format()

+ +

On peut utiliser la fonction renvoyée par format pour formater une valeur monétaire selon la locale russe :

+ +
var options = {style: "currency", currency: "RUB"};
+var numberFormat = new Intl.NumberFormat("ru-RU", options);
+console.log(numberFormat.format(654321.987));
+// → "654 321,99 руб."
+ +

Utiliser format() avec map()

+ +

On peut également utiliser la fonction format pour formater les nombres contenus dans un tableau. On notera que la fonction est liée à l'objet NumberFormat dont elle provient, on peut donc directement l'utiliser avec {{jsxref("Array.prototype.map")}}.

+ +
var a = [123456.789, 987654.321, 456789.123];
+var numberFormat = new Intl.NumberFormat("es-ES");
+var formatted = a.map(numberFormat.format);
+console.log(formatted.join("; "));
+// → "123.456,789; 987.654,321; 456.789,123"
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES Int 1.0', '#sec-11.3.2', 'Intl.NumberFormat.prototype.format')}}{{Spec2('ES Int 1.0')}}Définition initiale
{{SpecName('ES Int 2.0', '#sec-11.3.2', 'Intl.NumberFormat.prototype.format')}}{{Spec2('ES Int 2.0')}} 
{{SpecName('ES Int Draft', '#sec-Intl.NumberFormat.prototype.format', 'Intl.NumberFormat.prototype.format')}}{{Spec2('ES Int Draft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.NumberFormat.format")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/numberformat/formattoparts/index.html b/files/fr/web/javascript/reference/global_objects/intl/numberformat/formattoparts/index.html new file mode 100644 index 0000000000..12a78a6a1d --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/numberformat/formattoparts/index.html @@ -0,0 +1,152 @@ +--- +title: Intl.NumberFormat.prototype.formatToParts() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/NumberFormat/formatToParts +tags: + - Internationalisation + - Intl + - JavaScript + - Méthode + - NumberFormat + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/formatToParts +--- +
{{JSRef}}
+ +

La méthode Intl.Numberformat.prototype.formatToParts() permet de produire des fragments de chaînes à partir d'un nombre pour le mettre en forme avec des formateurs NumberTimeFormat.

+ +

Syntaxe

+ +
Intl.NumberFormat.prototype.formatToParts(nombre)
+ +

Paramètres

+ +
+
nombre {{optional_inline}}
+
Le nombre qu'on souhaite mettre en forme.
+
+ +

Valeur de retour

+ +

Un tableau {{jsxref("Array")}} contenant des objets correspondants aux différents fragments du nombres.

+ +

Description

+ +

La méthode formatToParts() est peut être utilisée lorsqu'on met en forme des chaînes de caractères représentant des valeurs numériques. Cette méthode renvoie un tableau ({{jsxref("Array")}}) d'objets qui sont les différents fragments spécifiques aux locales et qui permettent de construire des chaînes dans un format spécifiques tout en conservant les parties liées à la locale. formatToParts() renvoie une structure analogue à :

+ +
[
+  { type: "integer", value: "3" }
+  { type: "group", value: "." }
+  { type: "integer", value: "500" }
+]
+ +

Les valeurs possibles pour l'attribut type sont :

+ +
+
currency
+
Le suffixe associé à la devise. Ce peut être le symbole "$", "€" ou bien le nom de la devise "Dollar", "Euro" selon la façon dont currencyDisplay  est indiquée.
+
decimal
+
Le séparateur décimal utilisé (".").
+
fraction
+
La partie fractionnaire du nombre.
+
group
+
La chaîne de caractères utilisée pour indiquer un groupe (",").
+
infinity
+
La chaîne de caractères qui représente la valeur {{jsxref("Infinity")}} ("∞").
+
integer
+
La partie entière du nombre.
+
literal
+
Toute chaîne de caractères littérale ou blanc utilisée dans le nombre mis en forme.
+
minusSign
+
La chaîne de caractères utilisée pour le signe moins ("-").
+
nan
+
La chaîne de caractères utilisée pour représenter la valeur {{jsxref("NaN")}} ("NaN").
+
plusSign
+
La chaîne de caractères utilisée pour le signe plus ("+").
+
+ +
+
percentSign
+
La châine de caractères utilisée pour le symbole pourcent ("%").
+
+ +

Exemples

+ +

NumberFormat produit une chaîne localisée opaque qui ne peut pas être manipulée directement :

+ +
var number = 3500;
+
+var formatter = new Intl.NumberFormat('de-DE', {
+  style: 'currency',
+  currency: 'EUR'
+});
+
+formatter.format(number);
+// "3.500,00 €"
+
+ +

Toutefois, pour certaines applications, on souhaite adapter la mise en forme de cette chaîne de caractères. La méthode formatToParts permet d'obtenir cette flexibilité tout en conservant les différents fragments produits par NumberFormat :

+ +
formatter.formatToParts(number);
+
+// return value:
+[
+  { type: "integer",  value: "3"   }
+  { type: "group",    value: "."   }
+  { type: "integer",  value: "500" }
+  { type: "decimal",  value: ","   }
+  { type: "fraction", value: "00"  }
+  { type: "literal",  value: " "   }
+  { type: "currency", value: "€"   }
+]
+
+ +

Maintenant que la chaîne est décomposée, on peut la réassembler d'une façon spécifique. On peut, par exemple utiliser {{jsxref("Array.prototype.map()")}}, une fonction fléchée, une instruction switch, des littéraux de gabarits et {{jsxref("Array.prototype.reduce()")}}.

+ +
var numberString = formatter.formatToParts(number).map(({type, value}) => {
+  switch (type) {
+    case 'currency': return `<strong>${value}</strong>`;
+    default : return value;
+  }
+}).reduce((string, part) => string + part);
+
+ +

Grâce à cette fonction, on pourra mettre en gras le suffixe associé à la devise :

+ +
console.log(numberString);
+// "3.500,00 <strong>€</strong>"
+ +

Prothèse d'émulation (polyfill)

+ +

Une prothèse pour cette fonctionnalité est disponible dans le dépôt associé à la proposition.

+ +

Spécifications

+ + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES Int Draft', '#sec-Intl.NumberFormat.prototype.formatToParts', 'Intl.NumberFormat.prototype.formatToParts')}}{{Spec2('ES Int Draft')}}Définition initiale.
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.NumberFormat.formatToParts")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/numberformat/index.html b/files/fr/web/javascript/reference/global_objects/intl/numberformat/index.html new file mode 100644 index 0000000000..2408df724b --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/numberformat/index.html @@ -0,0 +1,203 @@ +--- +title: Intl.NumberFormat +slug: Web/JavaScript/Reference/Objets_globaux/Intl/NumberFormat +tags: + - Internationalisation + - Intl + - JavaScript + - Reference + - i18n +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat +--- +
{{JSRef}}
+ +

L'objet Intl.NumberFormat est un constructeur permettant de créer des objets pour formater des nombres en fonction de la locale.

+ +
{{EmbedInteractiveExample("pages/js/intl-numberformat.html")}}
+ + + +

Syntaxe

+ +
new Intl.NumberFormat([locales[, options]])
+Intl.NumberFormat.call(this[, locales[, options]])
+ +

Paramètres

+ +
+
locales
+
+

Paramètre optionnel. Une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour le format général et l'interprétation de l'argument locales, voir la page {{jsxref("Intl","Intl","#L'identification_et_le_choix_de_la_locale")}}. Les clefs d'extensions Unicode suivantes sont autorisées :

+ +
+
nu
+
Le système numérique à utiliser. Parmi les valeurs possibles, on a : "arab", "arabext", "bali", "beng", "deva", "fullwide", "gujr", "guru", "hanidec", "khmr", "knda", "laoo", "latn", "limb", "mlym", "mong", "mymr", "orya", "tamldec", "telu", "thai", "tibt".
+
+
+
options
+
+

Paramètre optionnel. Un objet avec certaines ou toutes les propriétés suivantes :

+ +
+
localeMatcher
+
L'algorithme de correspondance à utiliser pour la locale. Les valeurs possibles sont "lookup" et "best fit" ; le défaut est "best fit". Pour des informations sur cette option, voir la page {{jsxref("Intl","Intl","##Choix_de_la_locale")}}.
+
+
+
+
+
style
+
Le style de formatage. Les valeurs possibles sont "decimal" pour l'affichage de nombres simple, "currency" pour un affichage en fonction de la devise et "percent" pour afficher des pourcentages. La valeur par défaut est "decimal".
+
currency
+
La devise à utiliser pour le formatage. Les valeurs possibles sont les codes ISO 4217 pour les devises, tels que "USD" pour le dollar américain, "EUR" pour l'euro, ou "CNY" pour le yuan chinois. Voir la page listant les codes actuels pour les devises et les fonds (en anglais). Il n'y a pas de valeur par défaut. Si le style choisi avec l'option style est "currency", la propriété currency doit être définie.
+
currencyDisplay
+
La façon d'afficher la devise dans le format courant. Les valeurs possibles sont "symbol" qui permet d'utiliser un symbole localisé comme '€', "code" qui affichera le code ISO de la devise (voir ci-avant), "name"  affichera un nom localisé pour la devise comme "dollar". La valeur par défaut est "symbol".
+
useGrouping
+
Cette option indique si on doit utiliser des séparateurs de groupes (comme les séparateurs de milliers ou autres comme lakhs et crores). Les valeurs possibles sont true et false. La valeur par défaut true.
+
+ +

Les propriétés suivantes peuvent être classées en deux groupes. Dans le premier on aura minimumIntegerDigits, minimumFractionDigits, maximumFractionDigits et dans le second on aura minimumSignificantDigits et maximumSignificantDigits. S'il existe une option définie pour le second groupe, les options du premier groupe seront ignorées.

+ +
+
minimumIntegerDigits
+
Le nombre minimal de chiffres à utiliser pour la partie entière. Les valeurs possibles sont comprises entre 1 to 21. La valeur par défaut est 1.
+
minimumFractionDigits
+
Le nombre minimal de chiffres à utiliser pour la partie fractionnaire. Les valeurs possibles sont comprises entre 0 et 20. Pour les formats "decimal" et "percent", la valeur par défaut est 0. La valeur par défaut pour le formatage monétaire ("currency") correspond au nombre de chiffres défini par la liste de codes de devises ISO 4217, si cette valeur n'est pas définie dans cette liste, on aura 2 chiffres.
+
maximumFractionDigits
+
Le nombre maximal de chiffres à utiliser pour représenter la partie fractionnaire. Les valeurs possibles sont comprises entre 0 et 20. Pour le format "decimal", la valeur par défaut est le maximum entre 3 et minimumFractionDigits. Pour le format monétaire ("currency"), la valeur par défaut est le maximum entre  minimumFractionDigits et le nombre de chiffres prévus par la liste ISO 4217 des codes de devises (ou 2 si cette information n'est pas disponible dans cette liste). Pour le format en pourcent, la valeur par défaut est le maximum entre minimumFractionDigits et 0.
+
minimumSignificantDigits
+
Le nombre minimal de chiffres significatifs à utiliser. Les valeurs possibles sont comprises entre 1 et 21. La valeur par défaut est 1.
+
maximumSignificantDigits
+
Le nombre maximal de chiffres significatifs à utiliser. Les valeurs possibles sont comprises entre 1 et 21. La valeur par défaut est minimumSignificantDigits.
+
+
+
+ +

Description

+ +

Propriétés

+ +
+
{{jsxref("NumberFormat.prototype", "Intl.NumberFormat.prototype")}}
+
Permet d'ajouter des propriétés à toutes les instances.
+
+ +

Méthodes

+ +
+
{{jsxref("NumberFormat.supportedLocalesOf", "Intl.NumberFormat.supportedLocalesOf()")}}
+
Renvoie un tableau des locales supportées parmi les locales données afin d'éviter d'utiliser la locale par défaut de l'environnement.
+
+ +

Instances de NumberFormat

+ +

Propriétés

+ +

Les instances de NumberFormat héritent des propriétés suivantes grâce à leur prototype :

+ +
{{page('fr/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/prototype','Properties')}}
+ +

Méthods

+ +
+

Les instances de NumberFormat héritent des méthodes suivantes grâce à leur prototype :

+{{page('fr/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/prototype','Methods')}}
+ +

Exemples

+ +

Usage simple

+ +

Sans aucune spécification, le résultat sera une chaîne de caractères avec la locale et les options par défaut :

+ +
var nombre = 3500;
+
+console.log(new Intl.NumberFormat().format(nombre));
+// → "3 500" pour la locale fr
+
+ +

Utiliser locales

+ +

Cet exemple illustre les variations possibles des formats numériques localisés. Si vous souhaitez que votre application utilise le format de la locale de l'utilisateur, assurez vous de l'indiquer via l'argument locales (voire avec d'autres locales de secours) :

+ +
var nombre = 123456.789;
+
+// L'allemand utilise la virgule comme séparateur décimal
+// et un point pour indiquer les milliers
+console.log(new Intl.NumberFormat("de-DE").format(nombre));
+// → 123.456,789
+
+// Dans la plupart des pays arabophones, on utilise les
+// chiffres arabo-hindîs
+console.log(new Intl.NumberFormat("ar-EG").format(nombre));
+// → ١٢٣٤٥٦٫٧٨٩
+
+// L'indien utilise des séparateurs pour les milliers,
+//les lakhs et les crores
+console.log(new Intl.NumberFormat("en-IN").format(nombre));
+// → 1,23,456.789
+
+// La clé d'extension nu indique une l'utilisation d'un système numérique
+// par exemple le système chinois
+console.log(new Intl.NumberFormat("zh-Hans-CN-u-nu-hanidec").format(nombre));
+// → 一二三,四五六.七八九
+
+// Lorsqu'une locale n'est pas supportée (par exemple le balinais)
+// on peut inclure une locale de secours (ici l'indonésien)
+console.log(new Intl.NumberFormat(["ban", "id"]).format(nombre));
+// → 123.456,789
+
+ +

Utiliser options

+ +

Les résultats fournis par toLocaleString peuvent être paramétrés grâce à l'argument options :

+ +
var nombre = 123456.789;
+
+// on affiche une devise avec le style "currency"
+console.log(new Intl.NumberFormat("de-DE", {style: "currency", currency: "EUR"}).format(nombre));
+// → 123.456,79 €
+
+// Le yen japonais n'a pas de centimes
+console.log(new Intl.NumberFormat("ja-JP", {style: "currency", currency: "JPY"}).format(nombre))
+// → ￥123,457
+
+// On se limite ici à trois chiffres significatifs
+console.log(new Intl.NumberFormat("en-IN", {maximumSignificantDigits: 3}).format(nombre));
+// → 1,23,000
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES Int 1.0', '#sec-11.1', 'Intl.NumberFormat')}}{{Spec2('ES Int 1.0')}}Définition initiale.
{{SpecName('ES Int 2.0', '#sec-11.1', 'Intl.NumberFormat')}}{{Spec2('ES Int 2.0')}} 
{{SpecName('ES Int Draft', '#numberformat-objects', 'Intl.NumberFormat')}}{{Spec2('ES Int Draft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.NumberFormat")}}

+ +

Voir aussi

+ +

{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl','Voir_aussi')}}

diff --git a/files/fr/web/javascript/reference/global_objects/intl/numberformat/resolvedoptions/index.html b/files/fr/web/javascript/reference/global_objects/intl/numberformat/resolvedoptions/index.html new file mode 100644 index 0000000000..195f044176 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/numberformat/resolvedoptions/index.html @@ -0,0 +1,112 @@ +--- +title: Intl.NumberFormat.prototype.resolvedOptions() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/NumberFormat/resolvedOptions +tags: + - Internationalisation + - Intl + - JavaScript + - Méthode + - NumberFormat + - Prototype + - Reference + - i18n +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/resolvedOptions +--- +
{{JSRef}}
+ +

La méthode Intl.NumberFormat.prototype.resolvedOptions() renvoie un nouvel objet dont les propriétés correspondent aux options de locales et de format calculées à l'initialisation de l'objet {{jsxref("NumberFormat", "Intl.NumberFormat")}}.

+ +
{{EmbedInteractiveExample("pages/js/intl-numberformat-prototype-resolvedoptions.html")}}
+ + + +

Syntaxe

+ +
numberFormat.resolvedOptions()
+ +

Valeur de retour

+ +

Un objet dont les propriétés correspondent aux options de locale et de format calculées lors de l'initialisation de l'objet {{jsxref("NumberFormat", "Intl.NumberFormat")}}.

+ +

Description

+ +

Cette méthode renvoie un objet composé des propriétés suivantes :

+ +
+
locale
+
La balise de langue BCP 47 qui est utilisée. Si des extensions Unicode avaient été rajoutées à la balise BCP 47 demandée, les paires de clés-valeurs qui ont été demandées et qui sont supportées sont inscrites dans locale.
+
numberingSystem
+
La valeur requise via l'extension Unicode "nu" ou celle qui est utilisée par défaut.
+
style
+
useGrouping
+
Les valeurs fournies pour ces propriétés via l'argument options ou bien les valeurs par défaut.
+
currency
+
currencyDisplay
+
Les valeurs fournies pour ces propriétés via l'argument options ou bien les valeurs par défaut. Ces valeurs sont présentes uniquement si style vaut "currency".
+
+ +

Un seul des deux groupes suivants est inclus dans les propriétés :

+ +
+
minimumIntegerDigits
+
minimumFractionDigits
+
maximumFractionDigits
+
Les valeurs fournies pour ces propriétés via l'argument options ou bien les valeurs par défaut. Ces propriétés ne sont présentes que si minimumSignificantDigits ou maximumSignificantDigits n'ont pas été fournies à l'argument options.
+
minimumSignificantDigits
+
maximumSignificantDigits
+
Les valeurs fournies pour ces propriétés via l'argument options ou bien les valeurs par défaut. Ces propriétés sont présentes si au moins une d'entre elles a été fournie via l'argument options.
+
+ +

Exemples

+ +

Utiliser la méthode resolvedOptions()

+ +
var de = new Intl.NumberFormat('de-DE');
+var usedOptions = de.resolvedOptions();
+
+usedOptions.locale;                // "de-DE"
+usedOptions.numberingSystem;       // "latn"
+usedOption.style;                  // "decimal"
+usedOptions.minimumIntegerDigits;  // 1
+usedOptions.minimumFractionDigits; // 0
+usedOptions.maximumFractionDigits; // 3
+usedOptions.useGrouping;           // true
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES Int 1.0', '#sec-11.3.3', 'Intl.NumberFormat.prototype.resolvedOptions')}}{{Spec2('ES Int 1.0')}}Définition initiale.
{{SpecName('ES Int 2.0', '#sec-11.3.3', 'Intl.NumberFormat.prototype.resolvedOptions')}}{{Spec2('ES Int 2.0')}} 
{{SpecName('ES Int Draft', '#sec-Intl.NumberFormat.prototype.resolvedOptions', 'Intl.NumberFormat.prototype.resolvedOptions')}}{{Spec2('ES Int Draft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.NumberFormat.resolvedOptions")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/numberformat/supportedlocalesof/index.html b/files/fr/web/javascript/reference/global_objects/intl/numberformat/supportedlocalesof/index.html new file mode 100644 index 0000000000..f270e88a64 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/numberformat/supportedlocalesof/index.html @@ -0,0 +1,98 @@ +--- +title: Intl.NumberFormat.supportedLocalesOf() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/NumberFormat/supportedLocalesOf +tags: + - Internationalisation + - Intl + - JavaScript + - Méthode + - NumberFormat + - Reference + - i18n +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/supportedLocalesOf +--- +
{{JSRef}}
+ +

La méthode Intl.NumberFormat.supportedLocalesOf() renvoie un tableau de locales supportées parmi les locales fournies en argument afin d'éviter d'utiliser celle par défaut de l'environnement.

+ +
{{EmbedInteractiveExample("pages/js/intl-numberformat-prototype-supportedlocalesof.html")}}
+ + + +

Syntaxe

+ +
Intl.NumberFormat.supportedLocalesOf(locales[, options])
+ +

Paramètres

+ +
+
locales
+
Une chaîne de caractères qui est une balise BCP 47 ou un tableau composé de telles chaînes. Pour plus d'informations sur la forme générale de l'argument locales, voir la page {{jsxref("Intl","Intl","#L'identification_et_le_choix_de_la_locale")}}.
+
options
+
+

Un objet qui peut avoir la propriété suivante :

+ +
+
localeMatcher
+
L'algorithme de correspondance des locales à utiliser. Les valeurs possibles sont "lookup" et "best fit". La valeur par défaut est "best fit". Pour plus d'informations,, voir la page {{jsxref("Intl","Intl","#Choix_de_la_locale")}}.
+
+
+
+ +

Valeur de retour

+ +

Un tableau de chaînes de caractères représentant un sous-ensemble des balises de langues qui sont prises en charge pour la mise en forme des nombres sans qu'il soit nécessaire d'utiliser la locale par défaut de l'environnement d'exécution.

+ +

Description

+ +

Cette méthode renvoie un tableau de locales supportées parmi les locales fournies en argument afin d'éviter d'utiliser celle par défaut de l'environnement. Les locales renvoyées sont celles considérées comme équivalentes aux locales fournies avec l'algorithme indiqué.

+ +

Exemples

+ +

Utiliser supportedLocalesOf()

+ +

Si on dispose d'un environnement qui supporte les locales indonésienne et allemande mais pas balinaise pour le formatage des dates et des heures, supportedLocalesOf renverra les balises BCP 47 pour l'indonésien et l'allemand (bien que la collation pinyin ne soit pas pertinente pour les nombres ni pour l'indonésien et qu'il soit peu probable qu'une variante indonésienne existe pour l'allemand). Pour l'exemple, on l'utilise l'algorithme "lookup". Si on utilisait "best fit", on pourrait considérer que l'indonésien est adéquat pour la locale balinaise (sachant que la plupart des balinais comprend l'indonésien) et donc également renvoyer la balise balinaise.

+ +
var locales = ["ban", "id-u-co-pinyin", "de-ID"];
+var options = {localeMatcher: "lookup"};
+console.log(Intl.NumberFormat.supportedLocalesOf(locales, options).join(", "));
+// → "id-u-co-pinyin, de-ID"
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('ES Int 1.0', '#sec-11.2.2', 'Intl.NumberFormat.supportedLocalesOf')}}{{Spec2('ES Int 1.0')}}Définition initiale
{{SpecName('ES Int 2.0', '#sec-11.2.2', 'Intl.NumberFormat.supportedLocalesOf')}}{{Spec2('ES Int 2.0')}} 
{{SpecName('ES Int Draft', '#sec-Intl.NumberFormat.supportedLocalesOf', 'Intl.NumberFormat.supportedLocalesOf')}}{{Spec2('ES Int Draft')}} 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.NumberFormat.supportedLocalesOf")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/pluralrules/index.html b/files/fr/web/javascript/reference/global_objects/intl/pluralrules/index.html new file mode 100644 index 0000000000..0d49ec4de0 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/pluralrules/index.html @@ -0,0 +1,160 @@ +--- +title: Intl.PluralRules +slug: Web/JavaScript/Reference/Objets_globaux/Intl/PluralRules +tags: + - Internationalisation + - Intl + - JavaScript + - PluralRules + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/PluralRules +--- +
{{JSRef}}
+ +

L'objet Intl.PluralRules est un constructeur d'objets qui permettent de mettre en forme des chaînes de caractères en fonction des règles de nombre (pluriel) d'une langue donnée.

+ +

Syntaxe

+ +
new Intl.PluralRules([locales[, options]])
+
+ +

Paramètres

+ +
+
locales
+
+

Une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour le format général et l'interprétation de l'argument locales, voir la page {{jsxref("Objets_globaux/Intl","Intl","#L'identification_et_le_choix_de_la_locale")}}.

+
+
options {{optional_inline}}
+
+

Optionnel, un objet possédant tout ou partie des propriétés suivantes :

+ +
+
localeMatcher
+
L'algorithme de correspondance à utiliser pour la locale. Les valeurs possibles sont "lookup" et "best fit" ; le défaut est "best fit". Pour des informations sur cette option, voir la page {{jsxref("Objets_globaux/Intl","Intl","##Choix_de_la_locale")}}
+
type
+
Le type de numérotation à utiliser. Les valeurs possibles sont : +
    +
  • "cardinal" pour les nombres cardinaux (la quantité de telle ou telle chose). Cette valeur est la valeur par défaut.
    • +
  • "ordinal" pour les nombres ordinaux (l'ordre relatif de différentes choses « premier », « deuxième », « troisième »).
    • +
+
+
+
+
+ +

Description

+ +

Propriétés

+ +
+
{{jsxref("PluralRules.prototype", "Intl.PluralRules.prototype")}}
+
Cette propriété permet d'ajouter des propriétés aux objets Intl.PluralRules.
+
+ +

Méthodes

+ +
+
{{jsxref("PluralRules.supportedLocalesOf", "Intl.PluralRules.supportedLocalesOf()")}}
+
Cette méthode renvoie un tableau contenant les locales prises en charge sans que le moteur ait à utiliser la locale par défaut du système d'exécution.
+
+ +

Instances de PluralRules

+ +

Propriétés

+ +

Les instances de PluralRules héritent des propriétés suivantes de par leur prototype :

+ +
{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/PluralRules/prototype', 'Propriétés')}}
+ +

Méthodes

+ +

Les instances de PluralRules héritent des méthodes suivantes de par leur prototype :

+ +
{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/PluralRules/prototype', 'Méthodes')}}
+ +

Exemples

+ +

Exemple simple

+ +

Sans indiquer de locale, une chaîne formatée dans la locale par défaut et avec les options par défaut est renvoyée. On peut ainsi différencier entre le singulier et le pluriel (par exemple "chien" et "chiens").

+ +
var pr = new Intl.PluralRules();
+
+pr.select(0);
+// → 'one' si utilisée avec une locale anglais américain
+
+pr.select(1);
+// → 'one' si utilisée avec une locale anglais américain
+
+pr.select(2);
+// → 'other' si utilisée avec une locale anglais américain
+
+ +

Utiliser locales

+ +

Dans cet exemple, on voit l'impact de la locale sur les règles de nombre. Afin de respecter la langue de l'utilisateur dans votre application, assurez vous d'indiquer cette langue (et éventuellement une langue de secours) grâce à l'argument locales :

+ +
// L'arabe possède plusieurs règles
+// de nombre
+
+new Intl.PluralRules('ar-EG').select(0);
+// → 'zero'
+new Intl.PluralRules('ar-EG').select(1);
+// → 'one'
+new Intl.PluralRules('ar-EG').select(2);
+// → 'two'
+new Intl.PluralRules('ar-EG').select(6);
+// → 'few'
+new Intl.PluralRules('ar-EG').select(18);
+// → 'many'
+
+ +

Utiliser options

+ +

Les résultats obtenus peuvent être adaptés grâce à l'argument options. Celui-ci possède une propriété appelée type qui peut valoir ordinal. Cela peut être utile afin de déterminer la forme d'un indicateur ordinal (par exemple, "1er", "2e", etc.).

+ +
var pr = new Intl.PluralRules('en-US', { type: 'ordinal' });
+
+pr.select(0);
+// → 'other'
+pr.select(1);
+// → 'one'
+pr.select(2);
+// → 'two'
+pr.select(3);
+// → 'few'
+pr.select(4);
+// → 'other'
+pr.select(42);
+// → 'two'
+
+ +

Spécifications

+ + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour le constructeur Intl.PluralRules{{Spec2('ES Int Draft')}}Définition initiale.
+ +

Compatibilité des navigateurs

+ +
+ + +

{{Compat("javascript.builtins.Intl.PluralRules")}}

+
+ +

Voir aussi

+ +
{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl', 'Voir_aussi')}}
diff --git a/files/fr/web/javascript/reference/global_objects/intl/pluralrules/resolvedoptions/index.html b/files/fr/web/javascript/reference/global_objects/intl/pluralrules/resolvedoptions/index.html new file mode 100644 index 0000000000..66f4062703 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/pluralrules/resolvedoptions/index.html @@ -0,0 +1,95 @@ +--- +title: Intl.PluralRules.prototype.resolvedOptions() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/PluralRules/resolvedOptions +tags: + - Internationalisation + - Intl + - JavaScript + - Méthode + - PluralRules + - Prototype + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/PluralRules/resolvedOptions +--- +
{{JSRef}}
+ +

La méthode Intl.PluralRules.prototype.resolvedOptions() renvoie un nouvel objet dont les propriétés reflètent la locale et les options de formatage relatives aux règles de nombre calculées lors de l'initialisation de l'objet {{jsxref("PluralRules")}}.

+ +

Syntaxe

+ +
pluralRule.resolvedOptions()
+ +

Valeur de retour

+ +

Un nouvel objet dont les propriétés reflètent la locale et les options de formatage relatives aux règles de nombre calculées lors de l'initialisation de l'objet {{jsxref("PluralRules")}}.

+ +

Description

+ +

L'objet produit possède les propriétés suivantes :

+ +
+
locale
+
La balise de langue BCP 47 pour la locale réellement utilisée. Si une extension Unicode a été demandée dans la balise de langue BCP 47 ayant menée à cette locale, les paires clé/valeur qui ont été demandées et qui sont prises en charge dans cette locale sont incluses dans l'objet locale.
+
pluralCategories
+
Un tableau {{jsxref("Array")}} des règles de nombre utilisée pour la langue donnée.
+
type
+
Le type de règle utilisée (cardinal ou ordinal).
+
+ +

Seul l'un de ces deux groupes de propriétés est inclus :

+ +
+
minimumIntegerDigits
+
minimumFractionDigits
+
maximumFractionDigits
+
Les valeurs fournies pour ces propriétés via l'argument options ou les valeurs par défaut. Ces propriétés sont uniquement présentes si aucunes des propriétés minimumSignificantDigits ou maximumSignificantDigits n'a été fournie dans l'argument options.
+
minimumSignificantDigits
+
maximumSignificantDigits
+
Les valeurs fournies par ces propriétés via l'argument options ou les valeurs par défaut. Ces propriétés sont uniquement présentes si au moins l'une d'entre elles a été fournie dans l'argument options.
+
+ +

Exemples

+ +

Utiliser resolvedOptions()

+ +
var de = new Intl.PluralRules('de-DE');
+var usedOptions = de.resolvedOptions();
+
+usedOptions.locale;                // "de-DE"
+usedOptions.maximumFractionDigits; // 3
+usedOptions.minimumFractionDigits; // 0
+usedOptions.minimumIntegerDigits;  // 1
+usedOptions.pluralCategories;      // Array [ "one", "other" ]
+usedOptions.type;                  // "cardinal"
+
+ +

Spécifications

+ + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Brouillon pour les règles de nombre avec IntlBrouillonDéfinition initiale.
+ +

Compatibilité des navigateurs

+ +
+ + +

{{Compat("javascript.builtins.Intl.PluralRules.resolvedOptions")}}

+
+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/pluralrules/select/index.html b/files/fr/web/javascript/reference/global_objects/intl/pluralrules/select/index.html new file mode 100644 index 0000000000..9d9b8eac11 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/pluralrules/select/index.html @@ -0,0 +1,79 @@ +--- +title: Intl.PluralRules.select() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/PluralRules/select +tags: + - Internationalisation + - Intl + - JavaScript + - Méthode + - PluralRules + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/PluralRules/select +--- +
{{JSRef}}
+ +

La méthode Intl.PluralRules.prototype.select renvoie une chaîne de caractères qui indique la règle de nombre utilisée pour le formatage relatif à la locale.

+ +

Syntaxe

+ +
pluralRule.select(nombre)
+ +

Paramètres

+ +
+
nombre
+
Le nombre pour lequel on souhaite obtenir la règle de nombre associée.
+
+ +

Description

+ +

Cette fonction permet de sélectionner une règle de nombre en fonction de la locale et des options de formatage choisies via un objet {{jsxref("PluralRules")}}.

+ +

Exemples

+ +
 new Intl.PluralRules('ar-EG').select(0);
+// → 'zero'
+
+new Intl.PluralRules('ar-EG').select(1);
+// → 'one'
+
+new Intl.PluralRules('ar-EG').select(2);
+// → 'two'
+
+new Intl.PluralRules('ar-EG').select(6);
+// → 'few'
+
+new Intl.PluralRules('ar-EG').select(18);
+// → 'many'
+
+ +

Spécifications

+ + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Brouillon pour les règles de nombre avec Intl{{Spec2('ES Int Draft')}}Définition initiale.
+ +

Compatibilité des navigateurs

+ +
+ + +

{{Compat("javascript.builtins.Intl.PluralRules.select")}}

+
+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/pluralrules/supportedlocalesof/index.html b/files/fr/web/javascript/reference/global_objects/intl/pluralrules/supportedlocalesof/index.html new file mode 100644 index 0000000000..31faa9f6b0 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/pluralrules/supportedlocalesof/index.html @@ -0,0 +1,84 @@ +--- +title: Intl.PluralRules.supportedLocalesOf() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/PluralRules/supportedLocalesOf +tags: + - Internationalisation + - Intl + - JavaScript + - Méthode + - PluralRules + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/PluralRules/supportedLocalesOf +--- +
{{JSRef}}
+ +

La méthode Intl.PluralRules.supportedLocalesOf() renvoie un tableau contenant les locales prises en charge, parmi celles passées en argument, pour les règles de nombre (sans avoir à utiliser la locale par défaut du système d'exécution).

+ +

Syntaxe

+ +
Intl.PluralRules.supportedLocalesOf(locales[, options])
+ +

Paramètres

+ +
+
locales
+
Une chaîne de caractères représentant une balise de langue BCP 47 ou bien un tableau de telles chaînes. Pour la forme générale de l'argument locales, se référer à la page {{jsxref("Intl", "Intl", "#Identification_et_choix_de_la_locale", 1)}}.
+
options {{optional_inline}}
+
+

Optionnel. Un objet pouvant contenir la propriété suivante :

+ +
+
localeMatcher
+
L'algorithme de correspondance à utiliser pour la locale. Les valeurs possibles sont "lookup" et "best fit" ; le défaut est "best fit". Pour des informations sur cette option, voir la page {{jsxref("Objets_globaux/Intl","Intl","##Choix_de_la_locale")}}.
+
+
+
+ +

Valeur de retour

+ +

Un tableau de chaînes de caractères représentant le sous-ensemble de balises de langues prises en charge pour le formatage avec les règles de nombre (sans qu'il soit nécssaire d'utiliser la locale par défaut du système d'exploitation).

+ +

Description

+ +

Cette méthode renvoie un tableau contenant un sous-ensemble des balises de langue fournies dans l'argument locales. Les balises de langue sont celles qui sont prises en charge par l'environnement pour le formatage avec les règles de nombre et pour lesquelles la locale respecte l'algorithme de correspondance indiqué. Les locales de ce tableau évitent d'avoir à utiliser la locale du système d'exécution par défaut.

+ +

Exemples

+ +

Dans l'hypothèse où on utilise un système prenant en charge l'indonésien, l'allemand mais pas le balinais pour le formatage avec les règles de nombre, supportedLocalesOf renvoie les balises de langue indonésienne et allemande inchangées bien que la collation pinyin ne soit pas pertinente ni utilisée avec l'indonésien (et qu'il est peu probable qu'une variante indonésienne pour l'allemand soit prise en charge). On notera que l'algorithme de correspondance "lookup" est utilisé ici. L'algorithme "best fit" aurait pu déterminer que l'indonésien aurait pu remplacer le balinais car la plupart des personnes parlant le balinais comprend également l'indonésien, la fonction aurait alors pu remplacer la balise de langue balinaise.

+ +
var locales = ['ban', 'id-u-co-pinyin', 'de-ID'];
+var options = { localeMatcher: 'lookup' };
+console.log(Intl.PluralRules.supportedLocalesOf(locales, options).join(', '));
+// → "id-u-co-pinyin, de-ID"
+
+ +

Spécifications

+ + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Brouillon pour les règles de nombre avec Intl{{Spec2('ES Int Draft')}}Définition initiale.
+ +

Compatibilité des navigateurs

+ +
+ + +

{{Compat("javascript.builtins.Intl.PluralRules.supportedLocalesOf")}}

+
+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/format/index.html b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/format/index.html new file mode 100644 index 0000000000..8a065ae341 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/format/index.html @@ -0,0 +1,103 @@ +--- +title: Intl.RelativeTimeFormat.prototype.format() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/RelativeTimeFormat/format +tags: + - Internationalisation + - Intl + - JavaScript + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/format +--- +
{{JSRef}}
+ +
La méthode Intl.RelativeTimeFormat.prototype.format() permet de formater une valeur avec une unité selon des options de locale et de formatage stockées dans l'objet {{jsxref("RelativeTimeFormat")}}.
+ +
{{EmbedInteractiveExample("pages/js/intl-relativetimeformat-prototype-format.html")}}
+ + + +

Syntaxe

+ +
RelativeTimeFormat.format(valeur, unite)
+ +

Paramètres

+ +
+
valeur
+
Une valeur numérique qu'on souhaite utiliser pour exprimer un temps relatif dans un message internationalisé.
+
+ +
+
unite
+
L'unité à utiliser pour le message internationalisé exprimant le temps relatif. Les valeurs possibles pour cet argument sont "year" (année), "quarter" (trimestre), "month" (mois), "week" (semaine), "day" (jour), "hour" (heure), "minute" (minute), "second" (secondes). Les formes plurielles sont également autorisées.
+
+ +

Description

+ +

La fonction renvoyée par l'accesseur format permet de formater une valeur et une unité en une chaîne de caractères en prenant en compte la locale et les options de formatage associées à l'objet {{jsxref("RelativeTimeFormat", "Intl.RelativeTimeFormat")}} utilisé.

+ +

Exemples

+ +

Utilisation simple de format

+ +

L'exemple suivant illustre comment créer un outil de formatage pour les valeurs de temps relatifs en anglais.

+ +
// On crée un outil de formatage pour les valeurs exprimant
+// les temps relatifs en anglais, avec les valeurs par défaut
+// utilisées explicitement.
+const rtf = new Intl.RelativeTimeFormat("en", {
+    localeMatcher: "best fit", // autre valeur possible : "lookup"
+    numeric: "always", // autre valeur possible : "auto"
+    style: "long", // autres valeurs possibles : "short" ou "narrow"
+});
+
+// Formatage d'une valeur relative négative.
+rtf.format(-1, "day");
+// > "1 day ago"
+
+// Formatage d'une valeur relative positive.
+rtf.format(1, "day");
+// > "in 1 day"
+ +

Utiliser l'option auto

+ +

Si on passe l'option numeric:auto, c'est la chaîne de caractères yesterday ou tomorrow qui sera produite (en anglais) plutôt que 1 day ago ou in 1 day. Cela permet de n'avoir pas nécessairement une valeur numérique en résultat.

+ +
// On crée un formateur en anglais avec l'option
+// numeric: "auto".
+const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });
+
+// Formatage d'une valeur relative négative.
+rtf.format(-1, "day");
+// > "yesterday"
+
+// Formatage d'une valeur relative positive.
+rtf.format(1, "day");
+// > "tomorrow"
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.RelativeTimeProposition de niveau 3 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.RelativeTimeFormat.format")}}

diff --git a/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/formattoparts/index.html b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/formattoparts/index.html new file mode 100644 index 0000000000..4a107d215c --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/formattoparts/index.html @@ -0,0 +1,86 @@ +--- +title: Intl.RelativeTimeFormat.prototype.formatToParts() +slug: Web/JavaScript/Reference/Objets_globaux/Intl/RelativeTimeFormat/formatToParts +tags: + - Internationalisation + - Intl + - JavaScript + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/formatToParts +--- +
{{JSRef}}
+ +

La méthode Intl.RelativeTimeFormat.prototype.formatToParts() est une méthode analogue à format() qui renvoie un tableau d'objets contenant les différentes parties représentant le message internationalisé pour le temps relatif.

+ +
{{EmbedInteractiveExample("pages/js/intl-relativetimeformat-prototype-formattoparts.html")}}
+ + + +

Syntaxe

+ +
RelativeTimeFormat.formatToParts(valeur, unite)
+ +

Paramètres

+ +
+
valeur
+
Une valeur numérique qu'on souhaite formater pour un message internationalisé exprimant un temps relatif.
+
+ +
+
unite
+
L'unité à utiliser pour le message internationalisé exprimant le temps relatif. Les valeurs possibles pour cet argument sont "year" (année), "quarter" (trimestre), "month" (mois), "week" (semaine), "day" (jour), "hour" (heure), "minute" (minute), "second" (secondes). Les formes plurielles sont également autorisées.
+
+ +

Valeur de retour

+ +

Un tableau ({{jsxref("Array")}}) d'objets contenant les fragments composant la chaîne de caractères localisée et mise en forme pour exprimer le temps relatif.

+ +

Description

+ +
La méthode Intl.RelativeTimeFormat.prototype.formatToParts() est une méthode analogue à la méthode format() mais renvoie un tableau d'objets représentant chacun une partie du message internationalisé. Ces objets ont deux propriétés : type et value. Si un des composants provient de NumberFormat, il aura une propriété unit indiquant l'unité utilisée pour le formatage.
+ +

Exemples

+ +
const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });
+
+// Format relative time using the day unit.
+rtf.formatToParts(-1, "day");
+// > [{ type: "literal", value: "yesterday"}]
+
+rtf.formatToParts(100, "day");
+// > [{ type: "literal", value: "in " },
+      { type: "integer", value: "100", unit: "day" },
+      { type: "literal", value: " days" }]
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationsÉtatCommentaires
Proposition pour Intl.RelativeTimeProposition de niveau 3 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.RelativeTimeFormat.formatToParts")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/index.html b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/index.html new file mode 100644 index 0000000000..f15c5db724 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/index.html @@ -0,0 +1,162 @@ +--- +title: Intl.RelativeTimeFormat +slug: Web/JavaScript/Reference/Objets_globaux/Intl/RelativeTimeFormat +tags: + - Constructeur + - Internationalisation + - Intl + - JavaScript + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat +--- +
{{JSRef}}
+ +

L'objet Intl.RelativeTimeFormat est un constructeur fournissant des objets pour mettre en forme des données temporelles relatives en respectant le format des locales.

+ +
{{EmbedInteractiveExample("pages/js/intl-relativetimeformat.html")}}
+ + + +

Syntaxe

+ +
new Intl.RelativeTimeFormat([locales[, options]])
+ +

Paramètres

+ +
+
locales
+
+

Une chaine de caractères avec un identifiant de langue BCP 47, ou un tableau de ce type de chaine de caractères. Pour le format général et l'interprétation de l'argument locales, voir la page {{jsxref("Objets_globaux/Intl","Intl","#L'identification_et_le_choix_de_la_locale")}}.

+
+
options {{optional_inline}}
+
+

Optionnel, un objet possédant tout ou partie des propriétés suivantes :

+
+
+
+
localeMatcher
+
L'algorithme de correspondance à utiliser pour la locale. Les valeurs possibles sont "lookup" et "best fit" ; le défaut est "best fit". Pour des informations sur cette option, voir la page {{jsxref("Objets_globaux/Intl","Intl","##Choix_de_la_locale")}}.
+
numeric
+
Le format du message de sortie. Les valeurs possibles sont "always" (par exemple 1 day ago) ou  "auto" (par exemple yesterday). "auto" permet de ne pas toujours avoir de valeurs numériques dans le message produit.
+
+ +
+
style
+
La longueur du message internationalisé. Les valeurs possibles sont : "long" (la valeur par défaut) (par exemple : in 1 month), "short" (par exemple : in 1 mo.) ou  "narrow" (par exemple : in 1 mo.). Le style narrow peut être semblable au style short pour certaines locales.
+
+
+
+ +

Description

+ +

Propriétés

+ +
+
{{jsxref("RelativeTimeFormat.prototype", "Intl.RelativeTimeFormat.prototype")}}
+
Cette propriété permet d'ajouter des propriétés à l'ensemble des instances.
+
+ +

Méthodes

+ +
+
{{jsxref("RelativeTimeFormat.supportedLocalesOf", "Intl.RelativeTimeFormat.supportedLocalesOf()")}}
+
Cette méthode renvoie un tableau des locales, parmi celles passées en argument, qui sont pris en charge pour le formatage internationalisé des temps relatifs sans qu'il y ait besoin d'utiliser la locale par défaut de l'environnement d'exécution.
+
+ +

Les instances de RelativeTimeFormat

+ +

Propriétés

+ +

Les instances de RelativeTimeFormat héritent des propriétés suivantes grâce à leur prototype :

+ +

{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl.RelativeTimeFormat/prototype', 'Propriétés')}}

+ +

Méthodes

+ +

Les instances de RelativeTimeFormat héritent des méthodes suivantes grâce à leur prototype :

+ +

{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/Intl.RelativeTimeFormat/prototype', 'Méthodes')}}

+ +

Exemples

+ +

Utiliser format()

+ +

L'exemple suivant illustre comment créer un formateur de temps relatif en anglais :

+ +
// On crée un formateur en anglais en utilisant explicitement
+// les valeurs par défaut.
+const rtf = new Intl.RelativeTimeFormat("en", {
+    localeMatcher: "best fit", // autre valeur possible : "lookup"
+    numeric: "always", // autre valeur possible : "auto"
+    style: "long", // autre valeur possible : "short" ou "narrow"
+});
+
+// On formate un temps relatif avec une valeur négative (-1).
+rtf.format(-1, "day");
+// > "1 day ago"
+
+// On formate un temps relatif avec une valeur positive (1).
+rtf.format(1, "day");
+// > "in 1 day"
+ +

Utiliser l'option auto

+ +

Si l'option numeric:auto est passée, on aura la chaîne de caractères yesterday ou tomorrow plutôt que 1 day ago ou in 1 day. De cette façon, on peut ne pas avoir de valeur numérique dans la valeur produite.

+ +
// On crée un formateur en anglais avec l'option
+// numeric: "auto".
+const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });
+
+// On formate un temps relatif avec une valeur négative (-1).
+rtf.format(-1, "day");
+// > "yesterday"
+
+// On formate un temps relatif avec une valeur positive (1).
+rtf.format(1, "day");
+// > "tomorrow"
+
+ +

Utiliser formatToParts()

+ +

L'exemple suivant illustre comment créer un formateur de temps relatif qui renvoie les différents fragments pour exprimer le temps relatif internationalisé.

+ +
const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });
+
+// On crée un temps relatif exprimé en jour.
+rtf.formatToParts(-1, "day");
+// > [{ type: "literal", value: "yesterday"}]
+
+rtf.formatToParts(100, "day");
+// > [{ type: "literal", value: "in " },
+      { type: "integer", value: "100", unit: "day" },
+      { type: "literal", value: " days" }]
+
+ +

Spécifications

+ + + + + + + + + + + + + + +
SpécificationEtatCommentaires
Proposition pour le constructeur Intl.RelativeTimeFormatProposition de niveau 3
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.RelativeTimeFormat")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/resolvedoptions/index.html b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/resolvedoptions/index.html new file mode 100644 index 0000000000..1d6ddd6978 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/resolvedoptions/index.html @@ -0,0 +1,100 @@ +--- +title: Intl.RelativeTimeFormat.prototype.resolvedOptions() +slug: >- + Web/JavaScript/Reference/Objets_globaux/Intl/RelativeTimeFormat/resolvedOptions +tags: + - Internationalization + - Intl + - JavaScript + - Méthode + - Prototype + - Reference + - i18n +translation_of: >- + Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/resolvedOptions +--- +
{{JSRef}}
+ +

La méthode Intl.RelativeTimeFormat.prototype.resolvedOptions() renvoie un nouvel objet dont les propriétés reflètent les options de format et de locale pour les valeurs temporelles relatives, calculées pendant l'initialisation de l'objet {{jsxref("RelativeTimeFormat")}}.

+ +
{{EmbedInteractiveExample("pages/js/intl-relativetimeformat-prototype-resolvedoptions.html")}}
+ + + +

Syntaxe

+ +
relativeTimeFormat.resolvedOptions()
+ +

Valeur de retour

+ +

Un nouvel objet dont les propriétés reflètent les options de locale et de formatage calculées lors de l'initialisation de l'objet {{jsxref("RelativeTimeFormat")}}.

+ +

Description

+ +

L'objet renvoyé par cette méthode possèdera les propriétés suivantes :

+ +
+
locale
+
La balise de langue BCP 47 qui est réellement utilisée. Si des extensions Unicode étaient fournies avec la balise d'origine et sont supportées pour la locale utilisée, les paires de clés-valeurs seront incluses dans locale.
+
style
+
La longueur du message internationalisé. Les valeurs possibles sont : +
    +
  • "long" : la valeur par défaut, peu concise (par exemple in 1 month)
    • +
  • "short" : une valeur plus courte (par exemple in 1 mo.),
    • +
  • "narrow" : une valeur encore plus courte (pouvant être ambigüe selon les locales) (par exemple in 1 mo.). Les styles narrow et short peuvent être similaires voire identiques pour certaines locales.
    • +
+
+
numeric
+
Le format du message produit. Les valeurs possibles sont : +
    +
  • "always" : la valeur par défaut (par exemple  1 day ago),
    • +
  • "auto" : cette valeur indique qu'il n'est pas nécessaire d'utiliser de valeur numérique dans le message produit (par exemple yesterday).
    • +
+
+
numberingSystem
+
La valeur demandée pour la clé d'extension Unicode "nu" ou la valeur remplie par défaut.
+
+ +

Exemples

+ +
var de = new Intl.RelativeTimeFormat('de-DE');
+var usedOptions = de.resolvedOptions();
+
+usedOptions.locale;          // "de-DE"
+usedOptions.style;           // "long"
+usedOptions.numeric;         // "always"
+usedOptions.numberingSystem; // "latn"
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.RelativeTimeProposition de niveau 3 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.RelativeTimeFormat.resolvedOptions")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/supportedlocalesof/index.html b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/supportedlocalesof/index.html new file mode 100644 index 0000000000..be0599106c --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/supportedlocalesof/index.html @@ -0,0 +1,87 @@ +--- +title: Intl.RelativeTimeFormat.supportedLocalesOf() +slug: >- + Web/JavaScript/Reference/Objets_globaux/Intl/RelativeTimeFormat/supportedLocalesOf +tags: + - Internationalisation + - Intl + - JavaScript + - Méthode + - Reference +translation_of: >- + Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/supportedLocalesOf +--- +
{{JSRef}}
+ +

La méthode Intl.RelativeTimeFormat.supportedLocalesOf() renvoie un tableau contenant l'ensemble des locales, parmi celles fournies en argument, qui sont prises en charge pour le formatage internationalisé du temps relatif, sans avoir à utiliser la locale par défaut de l'environnement d'exécution.

+ +
{{EmbedInteractiveExample("pages/js/intl-relativetimeformat-prototype-supportedlocalesof.html")}}
+ + + +

Syntaxe

+ +
Intl.RelativeTimeFormat.supportedLocalesOf(locales[, options])
+ +

Paramètres

+ +
+
locales
+
Un chaîne de caractères au format d'une balise de langue BCP 47 ou bien un tableau de telles chaînes. Pour plus d'informations sur le format de l'argument locales, voir la page {{jsxref("Intl", "Intl", "#L'identification_et_le_choix_de_la_locale")}}.
+
options
+
+

Paramètre optionnel, un objet pouvant avoir la propriété suivante :

+ +
+
localeMatcher
+
L'algorithme de correspondance entre locales à utiliser. Les valeurs possibles sont "lookup" et "best fit". Pour plus d'informations sur ce sujet, voir la page {{jsxref("Intl", "Intl", "#Choix_de_la_locale")}}.
+
+
+
+ +

Valeur de retour

+ +

Un tableau de chaînes de caractères qui représente un sous-ensemble des balises de langue qui sont prises en charge pour la mise en forme du temps relatif sans qu'il soit nécessaire d'utiliser la locale par défaut de l'environnement d'exécution.

+ +

Description

+ +

Cette méthode renvoie un tableau qui est un sous-ensemble de locales. Les balises de langues renvoyées sont celles supportées par l'environnement pour le formatage des temps relatifs. Ces balises sont déterminées en fonction de l'algorithme de correspondances de locale et des locales utilisées. Le tableau résultant fournit les locales qui permettent de ne pas avoir à utiliser la locale par défaut.

+ +

Examples

+ +

Utiliser supportedLocalesOf()

+ +

Si on dispose d'un environnement qui supporte les locales indonésienne et allemande mais pas balinaise pour le formatage des temps relatifs, supportedLocalesOf renverra les balises BCP 47 pour l'indonésien et l'allemand (bien que la collation pinyin ne soit pas pertinente pour les dates ni pour l'indonésien et qu'il soit peu probable qu'une variante indonésienne existe pour l'allemand). Pour l'exemple, on l'utilise l'algorithme "lookup". Si on utilisait "best fit", on pourrait considérer que l'indonésien est adéquat pour la locale balinaise (sachant que la plupart des balinais comprend l'indonésien) et donc également renvoyer la balise balinaise.

+ +
var locales = ['ban', 'id-u-co-pinyin', 'de-ID'];var options = { localeMatcher: 'lookup' };console.log(Intl.RelativeTimeFormat.supportedLocalesOf(locales, options).join(', '));// → "id-u-co-pinyin, de-ID"
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
Proposition pour Intl.RelativeTimeProposition de niveau 3 
+ +

Compatibilité des navigateurs

+ + + +

{{Compat("javascript.builtins.Intl.RelativeTimeFormat.supportedLocalesOf")}}

+ +

Voir aussi

+ + -- cgit v1.2.3-54-g00ecf