diff options
| author | SphinxKnight <SphinxKnight@users.noreply.github.com> | 2022-01-29 09:04:51 +0100 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2022-01-29 09:04:51 +0100 |
| commit | e86435de8cd57e092bebba81cc703e9d1b518e6d (patch) | |
| tree | ee807bcb660ea2332655f49e898208415e491456 /files/fr | |
| parent | 5cc04c233d54402e58a90853916883cf514c6a2f (diff) | |
| download | translated-content-e86435de8cd57e092bebba81cc703e9d1b518e6d.tar.gz translated-content-e86435de8cd57e092bebba81cc703e9d1b518e6d.tar.bz2 translated-content-e86435de8cd57e092bebba81cc703e9d1b518e6d.zip | |
Initial translation for missing Intl pages - French (#3480)
* Initial translation for missing Intl pages
* Fix flas
Diffstat (limited to 'files/fr')
18 files changed, 1668 insertions, 0 deletions
diff --git a/files/fr/web/javascript/reference/global_objects/intl/@@tostringtag/index.md b/files/fr/web/javascript/reference/global_objects/intl/@@tostringtag/index.md new file mode 100644 index 0000000000..a6bf30a202 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/@@tostringtag/index.md @@ -0,0 +1,39 @@ +--- +title: Intl[@@toStringTag] +slug: Web/JavaScript/Reference/Global_Objects/Intl/@@toStringTag +browser-compat: javascript.builtins.Intl.@@toStringTag +--- +{{JSRef}} + +La propriété **`Intl[@@toStringTag]`** vaut initialement "Intl". + +{{EmbedInteractiveExample("pages/js/intl-prototype-tostringtag.html","shorter")}} + +{{js_property_attributes(0,0,1)}} + +## Syntaxe + +```js +Intl[Symbol.toStringTag] +``` + +## Exemples + +### Utiliser toStringTag + +```js +Object.prototype.toString.call(Intl) // "[object Intl]" +Intl.toString() // "[object Intl]" +``` + +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +## Voir aussi + +- [`Symbol.toStringTag`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toStringTag) diff --git a/files/fr/web/javascript/reference/global_objects/intl/collator/collator/index.md b/files/fr/web/javascript/reference/global_objects/intl/collator/collator/index.md new file mode 100644 index 0000000000..944a9cb7cb --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/collator/collator/index.md @@ -0,0 +1,132 @@ +--- +title: Constructeur Intl.Collator() +slug: Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator +browser-compat: javascript.builtins.Intl.Collator.Collator +--- +{{JSRef}} + +Le constructeur **`Intl.Collator()`** crée un objet [`Intl.Collator`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator) qui permet de comparer des chaînes de caractères en prenant en compte la locale. + +{{EmbedInteractiveExample("pages/js/intl-collator.html")}} + +## Syntaxe + +```js +new Intl.Collator() +new Intl.Collator(locales) +new Intl.Collator(locales, options) +``` + +### Paramètres + +- `locales` {{optional_inline}} + + - : Un argument optionnel qui est une balise de langue BCP 47 ou un tableau de telles chaînes. Pour plus de détails sur la forme et l'interprétation de ce paramètres, voir la page [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl#identification_et_choix_de_la_locale). + + Les clés d'extension Unicode suivantes sont autorisées : + + > **Note :** Ces clés peuvent généralement être paramétrées avec l'argument `options` (voir ci-après), lorsque ces clés sont indiquées dans les deux paramètres c'est `options` qui a la priorité. + + - `co` + - : Les variantes de collation pour certaines locales. Les valeurs possibles sont : + - `big5han` + - `compat` + - `dict` + - `direct` + - `ducet` + - `eor` + - `gb2312` + - `phonebk` (uniquement pris en charge pour l'allemand) + - `phonetic` + - `pinyin` + - `reformed` + - `searchjl` + - `stroke` + - `trad` + - `unihan` + - `zhuyin` + > **Note :** Cette option peut également être définie via la propriété "`collation`" du paramètre `options`. + - `kn` + - : Indique si une collation numérique devrait être utilisée (par exemple pour avoir "1" < "2" < "10"). Les valeurs possibles sont "`true`" et "`false`". Cette option peut également être indiquée via la propriété "`numeric`" du paramètre `options`. + - `kf` + - : Indique si les majuscules ou les minuscules devraient être triées en premières. Les valeurs possibles sont "`upper`", "`lower`", ou "`false`" (qui utilise la valeur par défaut pour la locale). Cette option peut également être indiquée via la propriété "`caseFirst`" du paramètre `options`. + +- `options` {{optional_inline}} + + - : Un objet avec une ou plusieurs propriétés parmi les suivantes : + + - `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'information, voir la page [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl#négociation_de_la_locale). + - `usage` + - : Indique si la comparaison est utilisée pour trier ou pour rechercher des correspondances. Les valeurs possibles sont "`sort`" et + "`search`", la valeur par défaut est "`sort`". + - `sensitivity` + - : Indique les différences dans les chaînes de caractères qui entraînent un résultat non nul. Les valeurs possibles sont : + + - "`base`" : Seules les chaînes de caractères pour lesquelles les lettres de base sont différentes sont considérées comme différentes. Avec cette option, on a : a ≠ b, a = á, a = A. + - "`accent`" : Seules les chaînes de caractères pour lesquelles les lettres de base ou les diacritiques diffèrent sont considérées comme différentes. Avec cette option, on a : a ≠ b, a ≠ á, a = A. + - "`case`" : Seules les chaînes de caractères pour lesquelles les lettres de base ou la casse diffèrent sont considérées comme différentes. Avec cette option, on a : a ≠ b, a = á, a ≠ A. + - "`variant`" : Seules les chaînes de caractères pour lesquelles les lettres de base, les accents ou autres marques diacritiques ou encore la casse diffèrent, les chaînes sont considérées comme différentes. D'autres différences peuvent également être prises en compte. Avec cette option, on a : a ≠ b, a ≠ á, a ≠ A. + + La valeur par défaut est "`variant`" pour l'usage "`sort`" ; pour l'usage "`search`", la valeur par défaut dépend de la locale. + + - `ignorePunctuation` + - : Indique si la ponctuation devrait être ignorée. Les valeurs possibles sont `true` et `false` ; la valeur par défaut est `false`. + - `numeric` + + - : Indique si une collation numérique devrait être utilisée (afin d'avoir par exemple "1" < "2" < "10"). Les valeurs possibles sont `true` et `false` ; la valeur par défaut est `false`. + + > **Note :** Cette option peut également être définie via la clé d'extension Unicode `kn` ; si des valeurs sont fournies aux deux endroits, c'est la propriété d'`options` qui a la priorité. + + - `caseFirst` + + - : Indique si les majuscules ou les minuscules devraient être triées en premières. Les valeurs possibles sont "`upper`", "`lower`", ou "`false`" (qui utilisent la valeur par défaut de la locale). + + > **Note :** Cette option peut également être définie via la clé d'extension Unicode `kf` ; si des valeurs sont fournies aux deux endroits, c'est la propriété d'`options` qui a la priorité. + + - `collation` + - : Les variantes de collations pour certaines locales. Les valeurs possibles sont : + - `big5han` + - `compat` + - `dict` + - `direct` + - `ducet` + - `eor` + - `gb2312` + - `phonebk` (uniquement pris en charge pour l'allemand) + - `phonetic` + - `pinyin` + - `reformed` + - `searchjl` + - `stroke` + - `trad` + - `unihan` + - `zhuyin` + > **Note :** Cette option peut également être définie via la clé d'extension Unicode `co` ; si des valeurs sont fournies aux deux endroits, c'est la propriété d'`options` qui a la priorité. + +## Exemples + +### Utiliser Collator() + +Dans l'exemple suivant, on illustre la comparaison de deux chaînes de caractères et le résultat obtenu selon que l'une est située avant ou après, ou de façon équivalente selon l'ordre lexicographique de la langue : + +```js +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 +``` + +On notera que les résultats obtenus avec les lignes précédentes peuvent varier d'un navigateur à l'autre et entre les différentes versions. En effet, les valeurs numériques obtenues sont spécifiques aux implémentations et la spécification n'impose que le signe de la valeur obtenue. + +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +## Voir aussi + +- [`Intl.Collator`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator) +- [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl) diff --git a/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/datetimeformat/index.md b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/datetimeformat/index.md new file mode 100644 index 0000000000..c2f9306c9f --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/datetimeformat/datetimeformat/index.md @@ -0,0 +1,256 @@ +--- +title: Constructeur Intl.DateTimeFormat() +slug: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/DateTimeFormat +browser-compat: javascript.builtins.Intl.DateTimeFormat.DateTimeFormat +--- +{{JSRef}} + +Le constructeur **`Intl.DateTimeFormat()`** permet de créer des objets [`Intl.DateTimeFormat`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat) qui formatent des horodatages en tenant compte de la locale et des options fournies. + +{{EmbedInteractiveExample("pages/js/intl-datetimeformat.html", "taller")}} + +## Syntaxe + +```js +new Intl.DateTimeFormat() +new Intl.DateTimeFormat(locales) +new Intl.DateTimeFormat(locales, options) +``` + +### Paramètres + +- `locales` {{optional_inline}} + + - : Une chaîne de caractères représentant une balise de langue BCP 47 ou un tableau de telles balises. Pour la forme générale et l'interprétation de cet argument, voir la page [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl#identification_et_choix_de_la_locale). Les clés d'extension Unicode suivantes sont autorisées : + + - `nu` + - : Le système de numération à utiliser. Les valeurs possibles sont : "`arab`", "`arabext`", "`bali`", "`beng`", "`deva`", "`fullwide`", "`gujr`", "`guru`", "`hanidec`", "`khmr`", "`knda`", "`laoo`", "`latn`", "`limb`", "`mlym`", "`mong`", "`mymr`", "`orya`", "`tamldec`", "`telu`", "`thai`", "`tibt`". + - `ca` + - : Le calendrier à utiliser. Les valeurs possibles sont : "`buddhist`", "`chinese`", "`coptic`", "`ethiopia`", "`ethiopic`", "`gregory`", "`hebrew`", "`indian`", "`islamic`", "`iso8601`", "`japanese`", "`persian`", "`roc`". + - `hc` + - : Le cycle horaire à utiliser. Les valeurs possibles sont : "`h11`", "`h12`", "`h23`", "`h24`". + +- `options` {{optional_inline}} + + - : Un objet avec une ou plusieurs propriétés parmi les suivantes : + + - `dateStyle` + + - : Le style de formatage pour la date à utiliser avec `format()`. Les valeurs possibles sont : + + - "`full`" + - "`long`" + - "`medium`" + - "`short`" + + > **Note :** `dateStyle` peut être utilisée avec `timeStyle`, mais pas avec les autres options (comme `weekday`, `hour`, `month`, etc.). + + - `timeStyle` + + - : Le style de formatage des heures à utiliser avec `format()`. Les valeurs possibles sont : + + - "`full`" + - "`long`" + - "`medium`" + - "`short`" + + > **Note :** `timeStyle` peut être utilisée avec `dateStyle`, mais pas avec les autres options (comme `weekday`, `hour`, `month`, etc.). + + - `calendar` + - : Le calendrier à utiliser. Les valeurs possibles sont : "`buddhist`", "`chinese`", " `coptic`", "`ethiopia`", "`ethiopic`", "`gregory`", "`hebrew`", "`indian`", "`islamic`", "`iso8601`", "`japanese`", "`persian`", "`roc`". + - `dayPeriod` + + - : Le style de formatage à utiliser pour les périodes du jour comme « dans la matinée », « à midi », etc. Les valeurs possibles sont : + "`narrow`", "`short`", " `long`". + + > **Note :** Cette option applique un effet uniquement si une horloge sur 12 heures est utilisée. De nombreuses locales utilisent la même chaîne de caractères quelle que soit la longueur indiquée. + + - `numberingSystem` + - : Le système de numération à utiliser. Les valeurs possibles sont : "`arab`", "`arabext`", " `bali`", "`beng`", "`deva`", "`fullwide`", " `gujr`", "`guru`", "`hanidec`", "`khmr`", "`knda`", "`laoo`", "`latn`", "`limb`", "`mlym`", " `mong`", "`mymr`", "`orya`", "`tamldec`", "`telu`", "`thai`", "`tibt`". + - `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'information, voir la page [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl#négociation_de_la_locale). + - `timeZone` + - : Le fuseau horaire à utiliser. La seule valeur que doivent nécessairement reconnaître les implémentations est "`UTC`". La valeur par défaut est le fuseau horaire de l'environnement d'exécution. Les implémentations peuvent également reconnaître les noms de fuseaux horaires tels que décrits dans [la base de données des fuseaux horaires IANA](https://www.iana.org/time-zones), comme "`Asia/Shanghai`", "`Asia/Kolkata`", "`America/New_York`". + - `hour12` + - : Indique si l'heure est exprimée sur 12 heures plutôt que sur 24. Les valeurs possibles sont `true` et `false` ; la valeur par défaut dépend de la locale. Cette option surcharge la clé d'extension `hc` et/ou l'option `hourCycle`. + - `hourCycle` + - : Le cycle horaire à utiliser. Les valeurs possibles sont : "`h11`", "`h12`", "`h23`", or "`h24`". Cette option prévaut sur la clé d'extension `hc`. L'option `hour12` aura la priorité sur cette option si les deux sont utilisées. + - `formatMatcher` + - : L'algorithme de correspondance des formats à utiliser. Les valeurs possibles sont "`basic`" et "`best fit`" ; la valeur par défaut est "`best fit`". Voir les paragraphes suivants à propos de l'utilisation de cette propriété. + + Les propriétés suivantes décrivent les composantes d'horodatage qui peuvent être utilisées pour le format de production ainsi que leurs différentes représentations. Les implémentations doivent au moins prendre en charge les sous-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 moteurs peuvent prendre en charge d'autres sous-ensembles et la recherche de la meilleure correspondance aura lieu parmi toutes les combinaisons disponibles. Deux algorithmes sont disponibles pour cette recherche et la propriété `formatMatcher` permet de choisir l'un ou l'autre : [un algorithme explicitement spécifié, "`basic`"](https://www.ecma-international.org/ecma-402/1.0/#BasicFormatMatcher) et un algorithme laissé à l'implémentation : "`best fit`". + + - `weekday` + + - : La représentation du jour de la semaine. Les valeurs possibles sont : + + - "`long`" (par exemple, `mardi`) + - "`short`" (par exemple, `mar`) + - "`narrow`" (par exemple, `m`). Deux jours différents de la semaine peuvent avoir la même représentation avec ce style. + + - `era` + + - : La représentation d'une è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, `3`) + - "`2-digit`" (par exemple, `03`) + - "`long`" (par exemple, `mars`) + - "`short`" (par exemple, `mar`) + - "`narrow`" (par exemple, `m`). Deux mois différents peuvent avoir la même représentation avec ce style. + + - `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`", "`2-digit`". + - `minute` + - : La représentation des minutes. Les valeurs possibles sont : "`numeric`", "`2-digit`". + - `second` + - : La représentation des secondes. Les valeurs possibles sont : "`numeric`", "`2-digit`". + - `fractionalSecondDigits` + + - : Le nombre de chiffres à utiliser pour représenter la partie décimale des secondes (tout chiffre supplémentaire sera tronqué). Les valeurs possibles sont : + + - `0` (la partie décimale est tronquée) + - `1` + - `2` + - `3` + + - `timeZoneName` + + - : La représentation localisée du nom du fuseau horaire. Les valeurs possibles sont : + + - "`long`" pour le format long (par exemple, `Pacific Standard Time`, `Nordamerikanische Westküsten-Normalzeit`) + - "`short`" pour la forme courte localisée (par exemple, `PST`, `GMT-8`) + - "`shortOffset`" pour la forme courte GMT localisée (par exemple, `GMT-8`) + - "`longOffset`" pour la forme longue GMT localisée (par exemple, `GMT-0800`) + - "`shortGeneric`" pour la forme courte générique non-localisée (par exemple, `PT`, `Los Angeles Zeit`). + - "`longGeneric`" pour la forme longue générique non-localisée (par exemple, `Pacific Time`, `Nordamerikanische Westküstenzeit`) + + > **Note :** L'affichage du fuseau horaire pourra basculer sur un autre format si la chaîne de caractères nécessaire n'est pas disponible. Ainsi, les formats non-localisés devraient afficher le fuseau horaire sans indication de pays ou de ville, à la manière de "Pacific Time". Si ce n'est pas possible, le moteur pourra utiliser un nom de fuseau horaire localisé comme "Los Angeles Time". + + La valeur par défaut pour chaque composante de l'horodatage est [`undefined`](/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined), et si toutes les propriétés valent [`undefined`](/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined), ce sera la valeur "`numeric`" qui sera utilisée pour `year`, `month`, et `day`. + +## Exemples + +### Utiliser DateTimeFormat() + +Voici une utilisation simple du constructeur sans indiquer de locale. `DateTimeFormat` utilise alors la locale par défaut et les options par défaut. + +```js +let date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0)); + +console.log(new Intl.DateTimeFormat().format(date)); +// → "20/12/2012" si exécuté sur un environnement avec la locale en fr-FR et sur le fuseau horaire (UTC+0100) +``` + +### Utiliser timeStyle et dateStyle + +```js +let o = new Intl.DateTimeFormat("fr" , { + timeStyle: "short" +}); +console.log(o.format(Date.now())); // "09:45" + +let o2 = new Intl.DateTimeFormat("fr" , { + dateStyle: "short" +}); +console.log(o2.format(Date.now())); // "29/12/2021" + +let o3 = new Intl.DateTimeFormat("fr" , { + timeStyle: "medium", + dateStyle: "short" +}); +console.log(o3.format(Date.now())); // "29/12/2021 09:46:55" +``` + +### Utiliser dayPeriod + +On utilise l'option `dayPeriod` pour produire une chaîne de caractères qui indique le moment de la journée (« dans la matinée », « pendant la nuit », etc.). On notera que cela fonctionne uniquement avec un formatage utilisant une horloge sur 12 heures (`hourCycle: 'h12'`) et que pour de nombreuses locales, les chaînes obtenues sont les mêmes quelle que soit la valeur utilisée pour `dayPeriod`. + +```js +let date = Date.UTC(2012, 11, 17, 4, 0, 42); + +console.log(new Intl.DateTimeFormat('en-GB', { hour: 'numeric', hourCycle: 'h12', +dayPeriod: 'short', timeZone: 'UTC' }).format(date)); +// > 4 at night" (même formatage pour en-GB quelle que soit la valeur de dayPeriod) + +console.log(new Intl.DateTimeFormat('fr', { hour: 'numeric', hourCycle: 'h12', + dayPeriod: 'narrow', timeZone: 'UTC' }).format(date)); +// > "4 mat." (même formatage pour fr avec narrow ou short) + +console.log(new Intl.DateTimeFormat('fr', { hour: 'numeric', hourCycle: 'h12', + dayPeriod: 'long', timeZone: 'UTC' }).format(date)); +// > "4 du matin" +``` + +### Utiliser timeZoneName + +On utilise l'option `timeZoneName` pour produire une chaîne de caractères représentant le fuseau horaire ("GMT", "Pacific Time", etc.). + +```js +var date = Date.UTC(2021, 11, 17, 3, 0, 42); +const timezoneNames = ['short', 'long', 'shortOffset', 'longOffset', 'shortGeneric', 'longGeneric'] + +for (const zoneName of timezoneNames) { + var formatter = new Intl.DateTimeFormat('fr', { + timeZone: 'Europe/Paris', + timeZoneName: zoneName, + }); + console.log(zoneName + " : " + formatter.format(date) ); +} + +// Résultat attendu : +// short : 17/12/2021, UTC+1 +// long : 17/12/2021, heure normale d'Europe centrale +// shortOffset : 17/12/2021, UTC+1 +// longOffset : 17/12/2021, UTC+01:00 +// shortGeneric : 17/12/2021, heure : France +// longGeneric : 17/12/2021, heure d'Europe centrale +``` + +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +## Voir aussi + +- [`Intl.DateTimeFormat`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat) +- [`Intl.supportedValuesOf()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/supportedValuesOf) +- [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl) diff --git a/files/fr/web/javascript/reference/global_objects/intl/displaynames/of/index.md b/files/fr/web/javascript/reference/global_objects/intl/displaynames/of/index.md new file mode 100644 index 0000000000..747731c4ca --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/displaynames/of/index.md @@ -0,0 +1,58 @@ +--- +title: Intl.DisplayNames.prototype.of() +slug: Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/of +browser-compat: javascript.builtins.Intl.DisplayNames.of +--- +{{JSRef}} + +La méthode **`Intl.DisplayNames.prototype.of()`** prend comme argument un code et renvoie une chaîne de caractères selon les options et la locale fournies lors de l'instanciation de l'objet `Intl.DisplayNames`. + +{{EmbedInteractiveExample("pages/js/intl-displaynames.html")}} + +## Syntaxe + +```js +of(code) +``` + +### Paramètres + +- `code` + + - : La valeur du `code` à fournir dépend du `type` : + + - Si le type est `"region"`, le code sera [un code de région ISO-3166 sur deux lettres](https://www.iso.org/iso-3166-country-codes.html), ou [un code de région géographique sur trois chiffres UN M49](https://unstats.un.org/unsd/methodology/m49/). + - Si le type est `"script"`, le code sera [un code de script ISO-15924 sur quatre lettres](https://unicode.org/iso15924/iso15924-codes.html). + - Si le type est `"language"`, le code sera de la forme d'une sous-séquence _languageCode_ \["-"_scriptCode_] \["-" _regionCode_ ] \*("-" _variant_ ) de la grammaire unicode_language_id pour [la grammaire des identifiants de locales et de langues Unicode UTS 35](https://unicode.org/reports/tr35/#Unicode_language_identifier). _languageCode_ est soit un code de langue ISO 639-1 sur deux lettres ou un code de langue ISO 639-2 sur trois lettres. + - Si le type est `"currency"`, le code sera [un code à 3 lettres ISO 4217](https://www.iso.org/iso-4217-currency-codes.html). + +### Valeur de retour + +Une chaîne de caractères formatée spécifique à une locale. + +## Exemples + +### Utilisation de la méthode of() + +```js +let regionNames = new Intl.DisplayNames(['en'], {type: 'region'}); +regionNames.of('419'); // "Latin America" + +let languageNames = new Intl.DisplayNames(['en'], {type: 'language'}); +languageNames.of('fr'); // "French" + +let currencyNames = new Intl.DisplayNames(['en'], {type: 'currency'}); +currencyNames.of('EUR'); // "Euro" +``` + +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +## Voir aussi + +- [`Intl.DisplayNames`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames) diff --git a/files/fr/web/javascript/reference/global_objects/intl/displaynames/resolvedoptions/index.md b/files/fr/web/javascript/reference/global_objects/intl/displaynames/resolvedoptions/index.md new file mode 100644 index 0000000000..399a50966f --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/displaynames/resolvedoptions/index.md @@ -0,0 +1,57 @@ +--- +title: Intl.DisplayNames.prototype.resolvedOptions() +slug: Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/resolvedOptions +browser-compat: javascript.builtins.Intl.DisplayNames.resolvedOptions +--- +{{JSRef}} + +La méthode **`Intl.DisplayNames.prototype.resolvedOptions()`** renvoie un nouvel objet dont les propriétés reflètent les options de locale et de formatage calculées lors de l'instance de l'objet [`Intl.DisplayNames`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames) courant. + +## Syntaxe + +```js +resolvedOptions() +``` + +### Valeur de retour + +Un objet dont les propriétés reflètent les options de locale et de formatage obtenues lors de la construction de l'objet [`Intl.DisplayNames`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames) courant. + +## Description + +L'objet renvoyé par `resolvedOptions()` possède les propriétés suivantes : + +- `locale` + - : La balise de langue BCP 47 pour la locale effectivement utilisée Si des extensions Unicode avaient été demandées dans la balise d'origine et ont mené à cette locale, les paires de clés-valeurs requises et qui sont prises en charge pour cette locale sont incluses dans `locale`. +- `style` + - : La valeur fournie pour cette propriété dans l'argument `options` passé au constructeur ou la valeur par défaut ("`long`"). Sa valeur est soit "`long`", soit "`short`", soit "`narrow`". +- `type` + - : La valeur fournie pour cette propriété dans l'argument `options` passé au constructeur ou la valeur par défaut ("`language`"). Sa valeur est soit "`language`", soit "`region`", soit "`script`", soit "`currency`". +- `fallback` + - : La valeur fournie pour cette propriété dans l'argument `options` passé au constructeur ou la valeur par défaut ("`code`"). Sa valeur est soit "`code`", soit "`none`". + +## Exemples + +### Utiliser resolvedOptions() + +```js +const displayNames = new Intl.DisplayNames(['de-DE'], {type: 'region'}); + +const usedOptions = displayNames.resolvedOptions(); +console.log(usedOptions.locale); // "de-DE" +console.log(usedOptions.style); // "long" +console.log(usedOptions.type); // "region" +console.log(usedOptions.fallback); // "code" +``` + +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +## Voir aussi + +- [`Intl.DisplayNames`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames) diff --git a/files/fr/web/javascript/reference/global_objects/intl/displaynames/supportedlocalesof/index.md b/files/fr/web/javascript/reference/global_objects/intl/displaynames/supportedlocalesof/index.md new file mode 100644 index 0000000000..c2b4d58316 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/displaynames/supportedlocalesof/index.md @@ -0,0 +1,55 @@ +--- +title: Intl.DisplayNames.supportedLocalesOf() +slug: Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames/supportedLocalesOf +browser-compat: javascript.builtins.Intl.DisplayNames.supportedLocalesOf +--- +{{JSRef}} + +La méthode **`Intl.DisplayNames.supportedLocalesOf()`** renvoie un tableau dont les éléments sont les locales fournies qui sont prises en charge pour les noms d'affichage sans avoir à utiliser la locale par défaut de recours de l'environnement d'exécution. + +## Syntaxe + +```js +Intl.DisplayNames.supportedLocalesOf(locales) +Intl.DisplayNames.supportedLocalesOf(locales, options) +``` + +### Paramètres + +- `locales` + - : Une chaîne de caractères représentant une balise de langue BCP 47 ou un tableau de telles balises. Pour la forme générale et l'interprétation de cet argument, voir la page [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl#identification_et_choix_de_la_locale). +- `options` {{optional_inline}} + + - : 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'information, voir la page [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl#négociation_de_la_locale). + +### Valeur de retour + +Un tableau de chaînes de caractères qui est un sous-ensemble des balises de langue passées en argument et qui sont prises en charge pour les noms d'affichage sans avoir à recourir à la locale par défaut de l'environnement d'exécution. + +## Exemples + +### Utiliser supportedLocalesOf() + +Soit un environnement d'exécution qui prend en charge l'indonésien et l'allemand pour les noms d'affichage mais pas le balinais, `supportedLocalesOf` renverra les balises indonésiennes et germaniques inchangées bien que la collation `pinyin` n'est ni pertinente pour les noms d'affichage ou même utilisée pour l'indonésien et qu'un dialecte germanique pour l'indonésien sera peu probablement pris en charge. On notera que c'est l'algorithme "`lookup`" qui est utilisé ici ("`best fit`" pourrait décider que l'indonésien est une correspondance acceptable pour du balinais vu que les locuteurs balinais comprennent l'indonésien et inclure la balise de langue balinaise également). + +```js +const locales = ['ban', 'id-u-co-pinyin', 'de-ID']; +const options = { localeMatcher: 'lookup' }; +console.log(Intl.DisplayNames.supportedLocalesOf(locales, options).join(', ')); +// → "id-u-co-pinyin, de-ID" +``` + +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +## Voir aussi + +- [`Intl.DisplayNames`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/DisplayNames) diff --git a/files/fr/web/javascript/reference/global_objects/intl/listformat/listformat/index.md b/files/fr/web/javascript/reference/global_objects/intl/listformat/listformat/index.md new file mode 100644 index 0000000000..478943ff07 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/listformat/listformat/index.md @@ -0,0 +1,66 @@ +--- +title: Constructeur Intl.ListFormat() +slug: Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat +browser-compat: javascript.builtins.Intl.ListFormat.ListFormat +--- +{{JSRef}} + +Le constructeur **`Intl.ListFormat()`** permet de créer des objets [`Intl.ListFormat`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat) pour le formatage de listes adapté à la locale et aux options fournies. + +{{EmbedInteractiveExample("pages/js/intl-listformat.html", "taller")}} + +## Syntaxe + +```js +new Intl.ListFormat() +new Intl.ListFormat(locales) +new Intl.ListFormat(locales, options) +``` + +### Paramètres + +- `locales` {{optional_inline}} + - : Une chaîne de caractères représentant une balise de langue BCP 47 ou un tableau de telles balises. Pour la forme générale et l'interprétation de cet argument, voir la page [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl#identification_et_choix_de_la_locale). +- `options` {{optional_inline}} + + - : Un objet avec une ou plusieurs des propriétés suivantes : + + - `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'information, voir la page [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl#négociation_de_la_locale). + - `type` + - : Le format de sortie produit. Les valeurs possibles sont "`conjunction`" qui indique une liste additive (par exemple "`A, B, et C`"), c'est la valeur par défaut, ou "`disjunction`" qui indique une liste d'options distinctes (par exemple, "`A, B, ou C`"), ou "`unit`" qui indique une liste de valeurs avec des unités (par exemple, "`5 kg, 12 L`"). + - `style` + - : La longueur du message formaté. Les valeurs possibles sont "`long`", la valeur par défaut (par exemple "`A, B, et C`") ; "`short`" (par exemple + "`A, B, C`"), ou "`narrow`" (par exemple, "`A B C`"). Lorsque la valeur de `style` est "`short`" ou "`narrow`", seule la valeur "`unit`" est autorisée pour l'option "type". + +## Exemples + +### Utilisation de format() + +L'exemple suivant illustre comment créer un formateur de liste basé sur la langue française. + +```js +const list = ['Moto', 'Bus', 'Car']; + +console.log(new Intl.ListFormat('fr', { style: 'long', type: 'conjunction' }).format(list)); +// > Moto, Bus et Car + +console.log(new Intl.ListFormat('fr', { style: 'short', type: 'disjunction' }).format(list)); +// > Moto, Bus ou Car + +console.log(new Intl.ListFormat('fr', { style: 'narrow', type: 'unit' }).format(list)); +// > Moto Bus Car +``` + +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +## Voir aussi + +- [`Intl.ListFormat`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat) +- [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl) diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/calendars/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/calendars/index.md new file mode 100644 index 0000000000..df8cc671ba --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/calendars/index.md @@ -0,0 +1,81 @@ +--- +title: Intl.Locale.prototype.calendars +slug: Web/JavaScript/Reference/Global_Objects/Intl/Locale/calendars +browser-compat: javascript.builtins.Intl.Locale.calendars +--- +{{JSRef}} + +La propriété **`Intl.Locale.prototype.calendars`** est un accesseur qui renvoie un tableau avec le ou les identifiants des calendriers utilisés par la locale représentée par l'instance `Locale` courante. + +## Description + +La propriété `calendar` renvoie un tableau de l'ensemble des calendriers pris en charge pour la locale représentée par `Locale`. Les éléments du tableau indiquent l'ère du calendrier pour l'objet `Locale`. Le tableau qui suit indique les différents identifiants Unicode pour les calendriers, associés à l'ère calendaire qu'ils représentent. + +### Identifiants Unicode pour les calendriers + +- `buddhist` + - : Calendrier bouddhiste +- `chinese` + - : Calendrier chinois traditionnel +- `coptic` + - : Calendrier copte +- `dangi` + - : Calendrier coréen traditionnel +- `ethioaa` + - : Calendrier éthiopique, Amete Alem (an 0 situé environ à 5493 ans avant notre ère) +- `ethiopic` + - : Calendrier éthiopique, Amete Mihret (an 0 situé environ à 8 ans de notre ère) +- `gregory` + - : Calendrier grégorien +- `hebrew` + - : Calendrier traditionnel hébreux +- `indian` + - : Calendrier indien +- `islamic` + - : Calendrier islamique +- `islamic-umalqura` + - : Calendrier islamique, Umm al-Qura +- `islamic-tbla` + - : Calendrier islamique tabulaire (années intercalaires [2,5,7,10,13,16,18,21,24,26,29] - origine des temps astronomique) +- `islamic-civil` + - : Calendrier islamique tabulaire (années intercalaires [2,5,7,10,13,16,18,21,24,26,29] - origine des temps civile) +- `islamic-rgsa` + - : Calendrier islamique vu de l'Arabie saoudite +- `iso8601` + - : Calendrier ISO (calendrier grégorien utilisant la numérotation des semaines ISO 8601) +- `japanese` + - : Calendrier japonais impérial +- `persian` + - : Calendrier perse +- `roc` + - : Calendrier de la République de Chine +- `islamicc` + - : Calendrier arabe civil (algorithmique) + > **Attention :** La clé `islamicc` a été dépréciée. Mieux vaut utiliser `islamic-civil`. + +## Exemples + +### Obtenir la liste des calendriers pris en charge + +```js +let arEG = new Intl.Locale("ar-EG"); +console.log(arEG.calendars); // affiche ["gregory", "coptic", "islamic", "islamic-civil", "islamic-tbla"] +``` + +```js +let jaJP = new Intl.Locale("ja-JP"); +console.log(jaJP.calendars); // affiche ["gregory", "japanese"] +``` +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +## Voir aussi + +- [`Intl.Locale`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale) +- [`Intl.Locale.calendar`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/calendar) +- [Identifiants de calendrier Unicode](https://www.unicode.org/reports/tr35/#UnicodeCalendarIdentifier) diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/hourcycles/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/hourcycles/index.md new file mode 100644 index 0000000000..6e291361f9 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/hourcycles/index.md @@ -0,0 +1,49 @@ +--- +title: Intl.Locale.prototype.hourCycles +slug: Web/JavaScript/Reference/Global_Objects/Intl/Locale/hourCycles +browser-compat: javascript.builtins.Intl.Locale.hourCycles +--- +{{JSRef}} + +La propriété **`Intl.Locale.prototype.hourCycles`** est un accesseur qui renvoie une liste d'un ou plusieurs identifiants de cycles horaires utilisés pour la locale représentée par l'instance `Locale` courante. + +## Description + +Il existe deux conventions pour représenter une heure pendant une journée : sur une horloge à 12 heures et sur une horloge à 24 heures. La propriété `hourCycles` permet de connaître l'ensemble des cycles horaires disponibles pour la locale courante. Le type de cycle horaire correspond à [une sous-balise d'extension](https://www.unicode.org/reports/tr35/#u_Extension), qui étend les données portées par la chaîne de caractères représentant la locale. Les valeurs possibles pour représenter un cycle horaire sont indiquées dans le tableau qui suit. + +### Types de cycles horaires valides + +| Type de cycle horaire | Description | +| --------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | +| `h12` | Système horaire utilisant 1-12 ; ce qui correspond à 'h' dans les motifs. Horloge sur 12 heures, minuit commençant à 12:00 am. | +| `h23` | Système horaire utilisant 0-23 ; ce qui correspond à 'H' dans les motifs. Horloge sur 24 heures, minuit commençant à 0:00. | +| `h11` | Système horaire utilisant 0-11 ; ce qui correspond à 'K' dans les motifs. Horloge sur 12 heures, minuit commençant à 0:00 am. | +| `h24` | Système horaire utilisant 1-24 ; ce qui correspond à 'k' dans les motifs. Horloge sur 24 heures, minuit commençant à 24:00. | + +## Exemples + +### Connaître les cycles horaires pris en charge + +```js +let arEG = new Intl.Locale("ar-EG"); +console.log(arEG.hourCycles); // logs ["h12"] +``` + +```js +let jaJP = new Intl.Locale("ja-JP"); +console.log(jaJP.hourCycles); // logs ["h23"] +``` + +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +## Voir aussi + +- [`Intl.Locale`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale) +- [`Intl.Locale.hourCycle`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/hourCycle) +- [Spécification Unicode pour la clé d'extension HourCycle](https://www.unicode.org/reports/tr35/#UnicodeHourCycleIdentifier) diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/locale/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/locale/index.md new file mode 100644 index 0000000000..3a8feb59ea --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/locale/index.md @@ -0,0 +1,60 @@ +--- +title: Constructeur Intl.Locale() +slug: Web/JavaScript/Reference/Global_Objects/Intl/Locale/Locale +browser-compat: javascript.builtins.Intl.Locale.Locale +--- +{{JSRef}} + +Le constructeur **`Intl.Locale`** est une propriété native de l'objet `Intl` qui permet de créer des objets qui représentent des locales Unicode. + +{{EmbedInteractiveExample("pages/js/intl-locale.html")}} + +## Syntaxe + +```js +new Intl.Locale(tag) +new Intl.Locale(tag, options) +``` + +### Paramètres + +- `tag` + - : La balise Unicode qui représente une locale. +- `options` + - : Un objet qui contient la configuration à utiliser pour la locale. Les propriétés sont des balises de locale Unicode et les valeurs de ces propriétés sont les valeurs autorisées pour ces balises. + +## Exemples + +### Usage simple + +Sous sa forme la plus simple, le constructeur [`Intl.Locale`] prend comme argument une chaîne de caractères représentant un identifiant de locale : + +```js +let us = new Intl.Locale('en-US'); +``` + +### Utiliser le constructeur Locale avec un objet options + +Le constructeur prend un deuxième argument qui permet de configurer la locale et d'indiquer plusieurs types d'extensions. Ainsi, la propriété [`hourCycle`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/hourCycle) utilisée sur l'objet de configuration permettra d'indiquer le type de cycle horaire souhaité : + +```js +let locale = new Intl.Locale("en-US", { hourCycle: "h12" }); +console.log(locale.hourCycle); // affiche "h12" +``` + +## Prothèse d'émulation (<i lang="en">polyfill</i>) + +[Prothèse formatjs pour `Intl.Locale`](https://formatjs.io/docs/polyfills/intl-locale) + +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +## Voir aussi + +- [`Intl.Collator`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator) +- [Spécification Unicode sur les identifiants de locale](https://www.unicode.org/reports/tr35/#Canonical_Unicode_Locale_Identifiers) diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/numberingsystems/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/numberingsystems/index.md new file mode 100644 index 0000000000..dbb1e6705e --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/numberingsystems/index.md @@ -0,0 +1,132 @@ +--- +title: Intl.Locale.prototype.numberingSystems +slug: Web/JavaScript/Reference/Global_Objects/Intl/Locale/numberingSystems +browser-compat: javascript.builtins.Intl.Locale.numberingSystems +--- +{{JSRef}} + +La propriété **`Intl.Locale.prototype.numberingSystems`** est un accesseur qui renvoie un ou plusieurs identifiants pour des systèmes de numération utilisés par la locale représentée par l'instance `Intl.Locale` courante. + +## Description + +Un système de numération est utilisé pour représenter les nombres. La propriété `numberingSystems` permet de connaître les différents systèmes de numération utilisés par les différents pays, les différentes régions et cultures autour du monde. Les systèmes de numération représentés par cette propriété sont standardisés avec Unicode. Un tableau des systèmes de numération Unicode suit. + +> **Note :** La propriété `numberingSystem` (sans S) permet de connaître le système de numération principal utilisé par une locale. Celle-ci permet d'avoir la liste des différents systèmes de numération utilisés par une locale. + +| Valeur | Description | +| ---------- | ------------------------------------------------------------------------------------------------------- | +| `adlm` | Chiffres adlams | +| `ahom` | Chiffres ahoms | +| `arab` | Chiffres arabes | +| `arabext` | Chiffres arabes étendus | +| `armn` | Numération arménienne majuscule (algorithmique) | +| `armnlow` | Numération arménienne minuscule (algorithmique) | +| `bali` | Chiffres balinais | +| `beng` | Chiffres bengalis | +| `bhks` | Chiffres bhaiksuki | +| `brah` | Chiffres brahmis | +| `cakm` | Chiffres chakmas | +| `cham` | Chiffres chams | +| `cyrl` | Numération cyrillique (algorithmique) | +| `deva` | Chiffres devanagaris | +| `ethi` | Numération éthiopienne (algorithmique) | +| `finance` | Numération financière (peut être algorithmique) | +| `fullwide` | Chiffres à pleine chasse | +| `geor` | Numération géorgienne (algorithmique) | +| `gong` | Chiffres Gunjala Gondis | +| `gonm` | Chiffres Masaram Gondis | +| `grek` | Numération greque majuscule (algorithmique) | +| `greklow` | Numération greque minuscule (algorithmique) | +| `gujr` | Chiffres Gujaratis | +| `guru` | Chiffres Gurmukhis | +| `hanidays` | Numération du jour du mois avec caractère Han (utilisée avec les calendriers lunaires ou traditionnels) | +| `hanidec` | Système décimal positionnel utilisant les idéographes des nombres chinois comme chiffres | +| `hans` | Numération chinoise simplifiée (algorithmique) | +| `hansfin` | Numération chinoise simplifiée financière (algorithmique) | +| `hant` | Numération chinoise traditionnelle (algorithmique) | +| `hantfin` | Numération chinoise traditionnelle financière (algorithmique) | +| `hebr` | Numération hébraïque (algorithmique) | +| `hmng` | Chiffres Pahawh Hmongs | +| `hmnp` | Chiffres Nyiakeng Puachue Hmongs | +| `java` | Chiffres javanais | +| `jpan` | Numération japonaise (algorithmique) | +| `jpanfin` | Numération japonaise financière (algorithmique) | +| `jpanyear` | Numération basée sur la première année Gannen du calendrier japonais | +| `kali` | Chiffres Kayah Lis | +| `khmr` | Chiffres Khmers | +| `knda` | Chiffres Kannadas | +| `lana` | Chiffres Tai Tham Hora séculiers | +| `lanatham` | Chiffres Tai Tham Tham ecclésiastiques | +| `laoo` | Chiffres laotien | +| `latn` | Chiffres latins | +| `lepc` | Chiffres Lepchas | +| `limb` | Chiffres Limbus | +| `mathbold` | Chiffres mathématiques en gras | +| `mathdbl` | Chiffres mathématiques barrés en double | +| `mathmono` | Chiffres mathématiques à chasse fixe | +| `mathsanb` | Chiffres mathématiques en gras sans empattements | +| `mathsans` | Chiffres mathématiques sans empattements | +| `mlym` | Chiffres Malayalams | +| `modi` | Chiffres Modis | +| `mong` | Chiffres mongols | +| `mroo` | Chiffres Mros | +| `mtei` | Chiffres Meetei Mayeks | +| `mymr` | Chiffres Myanmars | +| `mymrshan` | Chiffres Myanmar Shans | +| `mymrtlng` | Chiffres Myanmar Tai Laings | +| `native` | Chiffres natifs | +| `newa` | Chiffres Newas | +| `nkoo` | Chiffres N'Kos | +| `olck` | Chiffres Ol Chikis | +| `orya` | Chiffres Oriyas | +| `osma` | Chiffres Osmanyas | +| `rohg` | Chiffres Hanifi Rohingyas | +| `roman` | Numération romaine majuscule (algorithmique) | +| `romanlow` | Numération romaine minuscule (algorithmique) | +| `saur` | Chiffres Saurashtras | +| `shrd` | Chiffres Sharadas | +| `sind` | Chiffres Khudawadis | +| `sinh` | Chiffres Sinhala Liths | +| `sora` | Chiffres Sora_Sompengs | +| `sund` | Chiffres soudanais | +| `takr` | Chiffres Takris | +| `talu` | Chiffres New Tai Lues | +| `taml` | Numération tamoule (algorithmique= | +| `tamldec` | Chiffres tamouls décimaux modernes | +| `telu` | Chiffres Telugus | +| `thai` | Chiffres thaïs | +| `tirh` | Chiffres Tirhutas | +| `tibt` | Chiffres tibétains | +| `traditio` | Numération traditionnelle (peut être algorithmique) | +| `vaii` | Chiffres Vais | +| `wara` | Chiffres Warang Citis | +| `wcho` | Chiffres Wanchos | + +## Exemples + +### Obtenir les systèmes de numération utilisés et pris en charge + +```js +let arEG = new Intl.Locale("ar-EG"); +console.log(arEG.numberingSystems); // affiche ["arab"] +``` + + +```js +let ja = new Intl.Locale("ja"); +console.log(ja.numberingSystems); // affiche ["latn"] +``` + +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +## Voir aussi + +- [`Intl.Locale`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale) +- [`Intl.Locale.numberingSystem`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/numberingSystem) +- [Détails du standard Unicode sur les systèmes de numération](https://github.com/unicode-org/cldr/blob/master/common/supplemental/numberingSystems.xml) diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/textinfo/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/textinfo/index.md new file mode 100644 index 0000000000..025b3e3770 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/textinfo/index.md @@ -0,0 +1,40 @@ +--- +title: Intl.Locale.prototype.textInfo +slug: Web/JavaScript/Reference/Global_Objects/Intl/Locale/textInfo +browser-compat: javascript.builtins.Intl.Locale.textInfo +--- +{{JSRef}} + +La propriété **`Intl.Locale.prototype.textInfo`** est un accesseur qui renvoie le sens d'écriture horizontal : `ltr` (pour gauche à droite) ou `rtl` (pour droite à gauche) pour la locale portée par l'instance de `Locale`. + +## Description + +Renvoie les informations de texte associées à la locale courante selon [les éléments de disposition UTS 35](https://www.unicode.org/reports/tr35/tr35-general.html#Layout_Elements). + +## Exemples + +### Obtenir les informations textuelles d'une locale + +```js +let ar = new Intl.Locale("ar"); +console.log(ar.textInfo); // affiche { direction: "rtl" } +console.log(ar.textInfo.direction); // affiche "rtl" +``` + +```js +let es = new Intl.Locale("es"); +console.log(es.textInfo); // affiche { direction: "ltr" } +console.log(es.textInfo.direction); // affiche "ltr" +``` + +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +## Voir aussi + +- [`Intl.Locale`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale) diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/timezones/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/timezones/index.md new file mode 100644 index 0000000000..d7ac97e2d2 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/timezones/index.md @@ -0,0 +1,47 @@ +--- +title: Intl.Locale.prototype.timeZones +slug: Web/JavaScript/Reference/Global_Objects/Intl/Locale/timeZones +browser-compat: javascript.builtins.Intl.Locale.timeZones +--- +{{JSRef}} + +La propriété **`Intl.Locale.prototype.timeZones`** est un accesseur qui renvoie un tableau des fuseaux horaires pris en charge pour la locale représentée par l'instance `Intl.Locale` courante. + +## Description + +Renvoie un tableau avec les fuseaux horaires pris en charge et associés à l'objet `Locale` courant. Les éléments du tableau sont représentés [au format IANA](https://en.wikipedia.org/wiki/Daylight_saving_time#IANA_time_zone_database). + +> **Note :** Si l'identifiant de langue Unicode ne contient pas le tiret indiquant la sous-balise de région, la valeur de retour sera `undefined`. + + +## Exemples + +### Obtenir les fuseaux horaires pris en charge et associés à une locale + +```js +let arEG = new Intl.Locale("ar-EG"); +console.log(arEG.timeZones); // affiche ["Africa/Cairo"] +``` + +```js +let jaJP = new Intl.Locale("ja-JP"); +console.log(jaJP.timeZones); // affiche ["Asia/Tokyo"] +``` + +```js +let ar = new Intl.Locale("ar"); +console.log(ar.timeZones); // affiche undefined +``` + +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +## Voir aussi + +- [`Intl.Locale`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale) +- [La base de données IANA pour les fuseaux horaires](https://en.wikipedia.org/wiki/Daylight_saving_time#IANA_time_zone_database) diff --git a/files/fr/web/javascript/reference/global_objects/intl/locale/weekinfo/index.md b/files/fr/web/javascript/reference/global_objects/intl/locale/weekinfo/index.md new file mode 100644 index 0000000000..869f9eae25 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/locale/weekinfo/index.md @@ -0,0 +1,46 @@ +--- +title: Intl.Locale.prototype.weekInfo +slug: Web/JavaScript/Reference/Global_Objects/Intl/Locale/weekInfo +browser-compat: javascript.builtins.Intl.Locale.weekInfo +--- +{{JSRef}} + +La propriété **`Intl.Locale.prototype.weekInfo`** est un accesseur qui renvoie un objet `weekInfo` contenant les propriétés `firstDay`, `weekend` et `minimalDays` pour la locale associée. + +## Description + +Renvoie les informations associées à l'instance `Locale` pour les informations sur la semaine selon [les éléments de semaine UTS 35](https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Patterns_Week_Elements). + + +## Exemples + +### Obtenir les informations sur la semaine + +```js +let he = new Intl.Locale("he"); +console.log(he.weekInfo); // affiche {firstDay: 7, weekend: [5, 6], minimalDays: 1} + +let af = new Intl.Locale("af"); +console.log(af.weekInfo); // affiche {firstDay: 7, weekend: [6, 7], minimalDays: 1} + +let enGB = new Intl.Locale("en-GB"); +console.log(enGB.weekInfo) // affiche {firstDay: 1, weekend: [6, 7], minimalDays: 4} + +let msBN = new Intl.Locale("en-GB"); +console.log(msBN.weekInfo) // affiche {firstDay: 7, weekend: [5, 7], minimalDays: 1} +// Le week-end à Brunei est sur vendredi et dimanche mais pas sur samedi +``` + +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +## Voir aussi + +- [`Intl.Locale`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale) + + diff --git a/files/fr/web/javascript/reference/global_objects/intl/numberformat/numberformat/index.md b/files/fr/web/javascript/reference/global_objects/intl/numberformat/numberformat/index.md new file mode 100644 index 0000000000..6f78d7e3da --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/numberformat/numberformat/index.md @@ -0,0 +1,237 @@ +--- +title: Constructeur Intl.NumberFormat() +slug: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat +browser-compat: javascript.builtins.Intl.NumberFormat.NumberFormat +--- +{{JSRef}} + +Le constructeur **`Intl.NumberFormat()`** permet de créer des objets [`Intl.NumberFormat`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat) qui formatent des valeurs numériques en texte selon une locale et des options. + +{{EmbedInteractiveExample("pages/js/intl-numberformat.html")}} + +## Syntaxe + +```js +new Intl.NumberFormat() +new Intl.NumberFormat(locales) +new Intl.NumberFormat(locales, options) +``` + +### Paramètres + +- `locales` {{optional_inline}} + + - : Une chaîne de caractères représentant une balise de langue BCP 47 ou un tableau de telles balises. Pour la forme générale et l'interprétation de cet argument, voir la page [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl#identification_et_choix_de_la_locale). Les clés d'extension Unicode suivantes sont autorisées : + + - `nu` + - : Le système de numération à utiliser. Les valeurs possibles sont : "`adlm`", "`ahom`", "`arab`", "`arabext`", "`bali`", "`beng`", "`bhks`", "`brah`", "`cakm`", "`cham`", "`deva`", "`diak`", "`fullwide`", "`gong`", "`gonm`", "`gujr`", "`guru`", "`hanidec`", "`hmng`", "`hmnp`", "`java`", "`kali`", "`khmr`", "`knda`", "`lana`", "`lanatham`", "`laoo`", "`latn`", "`lepc`", "`limb`", "`mathbold`", "`mathdbl`", "`mathmono`", "`mathsanb`", "`mathsans`", "`mlym`", "`modi`", "`mong`", "`mroo`", "`mtei`", "`mymr`", "`mymrshan`", "`mymrtlng`", "`newa`", "`nkoo`", "`olck`", "`orya`", "`osma`", "`rohg`", "`saur`", "`segment`", "`shrd`", "`sind`", "`sinh`", "`sora`", "`sund`", "`takr`", "`talu`", "`tamldec`", "`telu`", "`thai`", "`tibt`", "`tirh`", "`vaii`", "`wara`", "`wcho`". — voir [la liste des systèmes de numération standard Unicode](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/numberingSystem). + +- `options` {{optional_inline}} + + - : Un objet avec une ou plusieurs des propriétés suivantes : + + - `compactDisplay` + - : Seulement utilisée lorsque `notation` vaut "`compact`". Soit "`short`" (la valeur par défaut) ou "`long`". + - `currency` + - : La devise à utiliser pour le formatage des montants. Les valeurs possibles sont les codes de devises ISO 4217 comme "`EUR`" pour l'euro, ou "`USD`" pour les dollars américains par exemple (voir [la liste des devises et fonds](https://www.currency-iso.org/en/home/tables/table-a1.html)). Il n'y a pas de valeur par défaut, si le style vaut "`currency`", la propriété `currency` doit être fournie. + - `currencyDisplay` + + - : La façon d'afficher les devises pour le formatage des devises. Les valeurs possibles sont : + + - "`symbol`" pour utiliser le symbole localisé de la devise (par exemple €), il s'agit de la valeur par défaut, + - "`narrowSymbol`" pour utiliser un symbole et une notation concise (par exemple "$100" plutôt que "US$100"), + - "`code`" pour utiliser le code ISO de la devise, + - "`name`" pour utiliser le nom localisé de la devise (par exemple "`dollar`"), + + - `currencySign` + - : Dans de nombreuses locales, les formatages comptables utilisent des parenthèses autour du nombre plutôt qu'un signe moins pour indiquer une valeur négative. On peut activer ce comportement entre utilisant la valeur "`accounting`" pour l'option `currencySign`. La valeur par défaut est "`standard`". + - `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'information, voir la page [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl#négociation_de_la_locale). + - `notation` + + - : Le formatage qui devrait être utilisé pour le nombre. + + - "`standard`" pour l'affichage d'une valeur numérique simple, c'est la valeur par défaut, + - "`scientific`" pour la notation scientifique de la valeur numérique, + - "`engineering`" qui indique la puissance de dix lorsqu'elle est divisible par trois, + - "`compact`" qui utilise l'exposant, c'est la valeur par défaut lorsque la forme "`short`" est utilisée. + + - `numberingSystem` + - : Le système de numération. Les valeurs possibles sont : "`arab`", "`arabext`", " `bali`", "`beng`", "`deva`", "`fullwide`", " `gujr`", "`guru`", "`hanidec`", "`khmr`", "`knda`", "`laoo`", "`latn`", "`limb`", "`mlym`", " `mong`", "`mymr`", "`orya`", "`tamldec`", "`telu`", "`thai`", "`tibt`". + - `signDisplay` + + - : Indique comment afficher le signe du nombre. + + - "`auto`" le signe est uniquement affiché pour les nombres négatifs, c'est la valeur par défaut, + - "`never`" le signe n'est jamais affiché, + - "`always`" le signe est toujours affiché, + - "`exceptZero`" le signe est affiché sauf lorsque la valeur numérique est nulle. + + - `style` + + - : Le style de formatage à utiliser. + + - "`decimal`" pour les nombres simples, c'est la valeur par défaut, + - "`currency`" pour les montants en devises, + - "`percent`" pour les pourcentages, + - "`unit`" pour les mesures avec des unités. + + - `unit` + - : L'unité à utiliser lorsque `style` vaut `unit`. Les valeurs possibles sont des identifiants d'unités tels que définis [dans la section 6 de la partie 2 de UTS #35](https://unicode.org/reports/tr35/tr35-general.html#Unit_Elements). [Un sous-ensemble des unités](https://tc39.es/proposal-unified-intl-numberformat/section6/locales-currencies-tz_proposed_out.html#sec-issanctionedsimpleunitidentifier) de [la liste complète](https://github.com/unicode-org/cldr/blob/master/common/validity/unit.xml) a été sélectionné pour être utilisé avec ECMAScript. Des paires d'unités simples peuvent être concaténées avec "`-per-`" pour construire une unité composite. Il n'existe pas de valeur par défaut. Cette propriété doit être fournie lorsque la valeur de `style` vaut "`unit`". + - `unitDisplay` + + - : Le style de formatage pour les unités à utiliser lorsque `style` vaut `unit`. + + - "`long`" (par exemple `16 litres`) + - "`short`" (par exemple `16 l`), c'est la valeur par défaut + - "`narrow`" (par exemple `16l`) + + - `useGrouping` + - : Indique si des séparateurs de groupe sont à utiliser (pour séparer par exemple des milliers/lakh/crore). Les valeurs possibles sont "`true`" ou "`false`", la valeur par défaut est `true`. + + Les propriétés suivantes s'inscrivent dans deux groupes distincts : d'une part `minimumIntegerDigits`, `minimumFractionDigits`, `maximumFractionDigits` et d'autre part `minimumSignificantDigits` and `maximumSignificantDigits`. Si au moins une des propriétés du second groupe est définie, toute propriété du premier groupe sera ignorée. + + - `minimumIntegerDigits` + - : Le nombre minimal de chiffres à utiliser. Les valeurs possibles vont de 1 à 21 ; la valeur par défaut est 1. + - `minimumFractionDigits` + - : Le nombre minimal de chiffres décimaux (derrière la virgule) à utiliser. Les valeurs possibles vont de 0 à 20 ; la valeur par défaut pour les nombres normaux et les pourcentages est 0 ; la valeur par défaut pour la mise en forme des montants en devises correspond au nombre de chiffres fourni par [la liste ISO 4217 pour les devises](https://www.currency-iso.org/en/home/tables/table-a1.html) (et 2 si la liste ne fournit pas cette information). + - `maximumFractionDigits` + - : Le nombre maximal de chiffres décimaux (derrière la virgule) à utiliser. Les valeurs possibles vont de 0 à 20 ; la valeur par défaut pour les nombres normaux correspond au maximum entre `minimumFractionDigits` et 3 ; la valeur par défaut pour les montants en devises correspond au maximum entre `minimumFractionDigits` et au nombre de chiffres fourni par [la liste ISO 4217 pour les devises](https://www.currency-iso.org/en/home/tables/table-a1.html) (et 2 si la liste ne fournit pas cette information) ; la valeur par défaut pour le formatage des pourcentages correspond au maximum entre `minimumFractionDigits` et 0. + - `minimumSignificantDigits` + - : Le nombre minimal de chiffres significatifs à utiliser. Les valeurs possibles vont de 1 à 21 ; la valeur par défaut est 1. + - `maximumSignificantDigits` + - : Le nombre maximal de chiffres significatifs à utiliser. Les valeurs possibles vont de 1 à 21 ; la valeur par défaut 21. + +## Exemples + +### Utilisation simple + +Par défaut, sans indiquer de locale, une chaîne formatée avec la locale et les options par défaut est renvoyée. + +```js +let amount = 3500; + +console.log(new Intl.NumberFormat().format(amount)); +// → '3 500' si l'environnement est en français +``` + +### Formatage pour des nombres décimaux et des pourcentages + +```js +let amount = 3500; + +new Intl.NumberFormat('en-US', {style: 'decimal'}).format(amount); +// → '3,500' +new Intl.NumberFormat('fr', {style: 'percent'}).format(amount); +// → '350 000 %' +``` + +### Formatage avec des unités + +Si l'option `style` vaut `'unit'`, une propriété `unit` doit être fournie. Le paramètre optionnel `unitDisplay` contrôle le formatage de l'unité. + +```js +let amount = 3500; + +new Intl.NumberFormat('en-US', {style: 'unit', unit: 'liter'}).format(amount); +// → '3,500 L' + +new Intl.NumberFormat('fr', {style: 'unit', unit: 'liter', unitDisplay: 'long'}).format(amount); +// → '3 500 litres' +``` + +### Formatage de devises + +Si l'option `style` vaut `'currency'`, une propriété `currency` doit être fournie. Les paramètres optionnels `currencyDisplay` et `currencySign` contrôlent le formatage de la devise. + +```js +let amount = -3500; +new Intl.NumberFormat('en-US', {style: 'currency', currency: 'USD'}).format(amount); +// → '-$3,500.00' + +new Intl.NumberFormat('bn', { + style: 'currency', + currency: 'USD', + currencyDisplay: 'name' +}).format(amount); +// → '-3,500.00 US dollars' + +new Intl.NumberFormat('fr', { + style: 'currency', + currency: 'EUR', + currencySign: 'accounting' +}).format(amount); +// → "(3 500,00 €)" +``` + +### Notations scientifique, ingénieur et compacte + +Ces notations sont portées par l'option `notation` et peuvent être formatées ainsi : + +```js +new Intl.NumberFormat('en-US', { notation: "scientific" }).format(987654321); +// → 9.877E8 + +new Intl.NumberFormat('pt-PT', { notation: "scientific" }).format(987654321); +// → 9,877E8 + +new Intl.NumberFormat('en-GB', { notation: "engineering" }).format(987654321); +// → 987.654E6 + +new Intl.NumberFormat('de', { notation: "engineering" }).format(987654321); +// → 987,654E6 + +new Intl.NumberFormat('zh-CN', { notation: "compact" }).format(987654321); +// → 9.9亿 + +new Intl.NumberFormat('fr', { + notation: "compact", + compactDisplay: "long" +}).format(987654321); +// → 988 millions + +new Intl.NumberFormat('en-GB', { + notation: "compact", + compactDisplay: "short" +}).format(987654321); +// → 988M +``` + +### Affichage des signes + +Dans l'exemple qui suit, on affiche toujours le signe sauf si la valeur est zéro : + +```js +new Intl.NumberFormat("en-US", { + style: "percent", + signDisplay: "exceptZero" +}).format(0.55); +// → '+55%' +``` + +On notera que lorsque le style porte sur les devises et que le style de signe vaut "`accounting`", des parenthèses pourront être utilisées plutôt qu'un signe moins : + +```js +new Intl.NumberFormat('bn', { + style: 'currency', + currency: 'USD', + currencySign: 'accounting', + signDisplay: 'always' +}).format(-3500); + +// → '($3,500.00)' +``` + +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +## Voir aussi + +- [`Intl.NumberFormat`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat) +- [`Intl.supportedValuesOf()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/supportedValuesOf) +- [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl) diff --git a/files/fr/web/javascript/reference/global_objects/intl/pluralrules/pluralrules/index.md b/files/fr/web/javascript/reference/global_objects/intl/pluralrules/pluralrules/index.md new file mode 100644 index 0000000000..5603a171d3 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/pluralrules/pluralrules/index.md @@ -0,0 +1,105 @@ +--- +title: Constructeur Intl.PluralRules() +slug: Web/JavaScript/Reference/Global_Objects/Intl/PluralRules/PluralRules +browser-compat: javascript.builtins.Intl.PluralRules.PluralRules +--- +{{JSRef}} + +Le constructeur **`Intl.PluralRules()`** permet de créer des objets [`Intl.PluralRules`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/PluralRules). + +## Syntaxe + +```js +new Intl.PluralRules() +new Intl.PluralRules(locales) +new Intl.PluralRules(locales, options) +``` + +### Parameters + +- `locales` {{optional_inline}} + - : Une chaîne de caractères représentant une balise de langue BCP 47 ou un tableau de telles balises. Pour la forme générale et l'interprétation de cet argument, voir la page [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl#identification_et_choix_de_la_locale). +- `options` {{optional_inline}} + + - : Un objet avec une ou plusieurs des propriétés suivantes : + + - `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'information, voir la page [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl#négociation_de_la_locale). + - `type` + + - : Le type à utiliser. Les valeurs possibles sont : + + - "`cardinal`" pour les nombres cardinaux (qui indiquent une quantité de choses). C'est la valeur par défaut. + - "`ordinal`" pour les nombres ordinaux (qui indiquent un ordre ou un classement comme "1er", "2e", "3e"). + + Les propriétés suivantes appartiennent à deux groupes distincts : `minimumIntegerDigits`, `minimumFractionDigits`, et `maximumFractionDigits` pour le premier et `minimumSignificantDigits` et `maximumSignificantDigits` dans l'autre. Si au moins une des propriétés du second groupe est définie, le premier groupe est ignoré. + + - `minimumIntegerDigits` + - : Le nombre minimal de chiffres à utiliser. Les valeurs possibles vont de 1 à 21 ; la valeur par défaut est 1. + - `minimumFractionDigits` + - : Le nombre minimal de chiffres décimaux (derrière la virgule) à utiliser. Les valeurs possibles vont de 0 à 20 ; la valeur par défaut pour les nombres normaux et les pourcentages est 0 ; la valeur par défaut pour la mise en forme des montants en devises correspond au nombre de chiffres fourni par [la liste ISO 4217 pour les devises](https://www.currency-iso.org/en/home/tables/table-a1.html) (et 2 si la liste ne fournit pas cette information). + - `maximumFractionDigits` + - : Le nombre maximal de chiffres décimaux (derrière la virgule) à utiliser. Les valeurs possibles vont de 0 à 20 ; la valeur par défaut pour les nombres normaux correspond au maximum entre `minimumFractionDigits` et 3 ; la valeur par défaut pour les montants en devises correspond au maximum entre `minimumFractionDigits` et au nombre de chiffres fourni par [la liste ISO 4217 pour les devises](https://www.currency-iso.org/en/home/tables/table-a1.html) (et 2 si la liste ne fournit pas cette information) ; la valeur par défaut pour le formatage des pourcentages correspond au maximum entre `minimumFractionDigits` et 0. + - `minimumSignificantDigits` + - : Le nombre minimal de chiffres significatifs à utiliser. Les valeurs possibles vont de 1 à 21 ; la valeur par défaut est 1. + - `maximumSignificantDigits` + - : Le nombre maximal de chiffres significatifs à utiliser. Les valeurs possibles vont de 1 à 21 ; la valeur par défaut 21. + +## Exemples + +### Usage simple + +Utilisé simplement sans fournir de locale, une chaîne de caractères formatée dans la locale par défaut et avec les options par défaut est renvoyée. Cela permet de distinguer les formes du singulier et du pluriel. + +```js +var pr = new Intl.PluralRules(); + +pr.select(1); +// → 'one' si en anglais américain + +pr.select(2); +// → 'other' si en anglais américain +``` + +### Utiliser options + +Les résultats peuvent être personnalisés avec l'argument `options` qui possède une propriété `type` qu'on peut fixer à `ordinal`. Cela s'avère utile pour déterminer l'indicateur ordinal (par exemple en anglais où il y a des variations entre "1st", "2nd", "3rd", "4th", "42nd" et ainsi de suite). + +```js +var pr = new Intl.PluralRules('en-US', { type: 'ordinal' }); + +const suffixes = new Map([ + ['one', 'st'], + ['two', 'nd'], + ['few', 'rd'], + ['other', 'th'], +]); +const formatOrdinals = (n) => { + const rule = pr.select(n); + const suffix = suffixes.get(rule); + return `${n}${suffix}`; +}; + +formatOrdinals(0); // '0th' +formatOrdinals(1); // '1st' +formatOrdinals(2); // '2nd' +formatOrdinals(3); // '3rd' +formatOrdinals(4); // '4th' +formatOrdinals(11); // '11th' +formatOrdinals(21); // '21st' +formatOrdinals(42); // '42nd' +formatOrdinals(103); // '103rd' +``` + +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +## Voir aussi + +- [`Intl.PluralRules`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/PluralRules) +- [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl)
\ No newline at end of file diff --git a/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/relativetimeformat/index.md b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/relativetimeformat/index.md new file mode 100644 index 0000000000..b42ab63982 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/relativetimeformat/relativetimeformat/index.md @@ -0,0 +1,97 @@ +--- +title: Constructeur Intl.RelativeTimeFormat() +slug: Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat/RelativeTimeFormat +browser-compat: javascript.builtins.Intl.RelativeTimeFormat.RelativeTimeFormat +--- +{{JSRef}} + +Le constructeur **`Intl.RelativeTimeFormat()`** permet de créer des objets [`Intl.RelativeTimeFormat`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat) pour exprimer des valeurs temporelles relatives selon une locale et des paramètres donnés. + +## Syntaxe + +```js +new Intl.RelativeTimeFormat() +new Intl.RelativeTimeFormat(locales) +new Intl.RelativeTimeFormat(locales, options) +``` + +### Paramètres + +- `locales` {{optional_inline}} + - : Une chaîne de caractères qui est une balise de langue BCP 47 ou un tableau de telles chaînes. Pour plus de détails sur la forme et l'interprétation de ce paramètres, voir la page [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl#identification_et_choix_de_la_locale). +- `options` {{optional_inline}} + + - : Un objet avec une ou plusieurs propriétés parmi les suivantes : + + - `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'information, voir la page [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl#négociation_de_la_locale). + - `numeric` + + - : Le format du message de sortie. Les valeurs possibles sont : + + - "`always`" (la valeur par défaut, par exemple, `il y a 1 jour`), + - "`auto`" (par exemple, `hier`). La valeur "`auto`" permet de ne pas toujours avoir des valeurs numériques dans le message de sortie. + + - `style` + + - : La longueur du message internationalisé. Les valeurs possibles sont : + + - "`long`" (la valeur par défaut, par exemple, `dans 1 mois`) + - "`short`" (par exemple, `dans 3 m.`), + - "`narrow`" (par exemple, `dans 1 m.`). Le style `narrow` peut être similaire au style `short` pour certaines locales. + +## Exemples + +### Usage simple + +Dans l'exemple suivant, on crée un formateur de temps relatif utilisant la locale française. + +```js +// On crée un formateur de temps relatif dans la locale +// avec les valeurs par défaut passées explicitement. +const rtf = new Intl.RelativeTimeFormat("fr", { + localeMatcher: "best fit", // autres valeurs possibles : "lookup" + numeric: "always", // autres valeurs possibles : "auto" + style: "long", // autres valeurs possibles : "short" ou "narrow" +}); + +// On formate un temps relatif un jour dans le passé. +rtf.format(-1, "day"); +// > "il y a 1 jour" + +// On formate un temps relatif un jour dans le futur. +rtf.format(1, "day"); +// > "dans 1 jour" +``` + +### En utilisant l'option auto + +Si l'option `numeric:auto` est passée, le résultat sera la chaîne de caractères `hier` ou `demain` plutôt que `il y a 1 jour` ou `dans 1 jour`. Cela permet de ne pas toujours avoir de valeurs numériques dans la valeur produite. + +```js +// On crée un formateur en utilisant la locale française avec +// numeric: "auto" passée en option. +const rtf = new Intl.RelativeTimeFormat("fr", { numeric: "auto" }); + +// On formate un temps relatif un jour dans le passé. +rtf.format(-1, "day"); +// > "hier" + +// On formate un temps relatif un jour dans le futur. +rtf.format(1, "day"); +// > "demain" +``` + +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +## Voir aussi + +- [`Intl.RelativeTimeFormat`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat) +- [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl) +- [The Intl.RelativeTimeFormat API](https://developers.google.com/web/updates/2018/10/intl-relativetimeformat) diff --git a/files/fr/web/javascript/reference/global_objects/intl/supportedvaluesof/index.md b/files/fr/web/javascript/reference/global_objects/intl/supportedvaluesof/index.md new file mode 100644 index 0000000000..45fe42c98f --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/intl/supportedvaluesof/index.md @@ -0,0 +1,111 @@ +--- +title: Intl.supportedValuesOf() +slug: Web/JavaScript/Reference/Global_Objects/Intl/supportedValuesOf +browser-compat: javascript.builtins.Intl.supportedValuesOf +--- +{{JSRef}} {{SeeCompatTable}} + +La méthode **`Intl.supportedValuesOf()`** renvoie un tableau qui contient le calendrier, la collation, la devise, les systèmes de numérations ou les unités prises en charge par l'implémentation. + +Les doublons sont omis et le tableau est trié selon l'ordre lexicographique (plus précisément par [`Array.prototype.sort()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) avec `undefined` comme fonction de comparaison). + +Cette méthode peut être utilisée afin de tester les fonctionnalités prises en charge par une implémentation donnée afin de les surcharger par une prothèse d'implémentation si nécessaire. +Elle peut également être utilisée pour construire des interfaces utilisateur permettant aux personnes de choisir leurs préférences pour la localisation (par exemple lorsque l'interface est construite dynamiquement en WebGL ou côté serveur). + +{{EmbedInteractiveExample("pages/js/intl-supportedvaluesof.html")}} + +## Syntaxe + +```js +Intl.supportedValuesOf(cle) +``` + +### Paramètres + +- `cle` + - : Une clé qui indique la catégorie de valeurs à renvoyer. Il peut s'agir de : `"calendar"`, `"collation"`, `"currency"`,`"numberingSystem"`, `"timeZone"`, `"unit"`. + +### Valeur de retour + +Un tableau trié, contenant des chaînes de caractères uniques indiquant les valeurs prises en charge par l'implémentation pour la clé demandée. + +### Exceptions + +- `RangeError` + - : Une clé non prise en charge a été passée en paramètre. + +## Exemples + +### Test de fonctionnalité + +On peut vérifier que la méthode est prise en charge en la comparant à `undefined` : + +```js +if (typeof Intl.supportedValuesOf !== 'undefined') { + // la méthode est prise en charge +} +``` + +### Obtenir toutes les valeurs d'une clé donnée + +Pour obtenir les valeurs prises en charge pour les représentations calendaires, on pourra appeler la méthode avec la clé `"calendar"` et parcourir le tableau obtenu : + +```js +Intl.supportedValuesOf("calendar").forEach(function(calendar) { + // "buddhist", "chinese", "coptic", "dangi", ... +}); +``` +> **Note :** Le tableau renvoyé pour les calendriers contiendra toujours la valeur "gregory" (calendrier grégorien). + + +Les autres valeurs peuvent être obtenues de la même façon : + +```js +Intl.supportedValuesOf("collation").forEach(function(collation) { + // "big5han", "compat", "dict", "emoji", ... +}); + +Intl.supportedValuesOf("currency").forEach(function(currency) { + // "ADP", "AED", "AFA", "AFN", "ALK", "ALL", "AMD", ... +}); + +Intl.supportedValuesOf("numberingSystem").forEach(function(numberingSystem) { + // "adlm", "ahom", "arab", "arabext", "bali", ... +}); + +Intl.supportedValuesOf("timeZone").forEach(function(timeZone) { + // "Africa/Abidjan", "Africa/Accra", "Africa/Addis_Ababa", "Africa/Algiers", ... +}); + +Intl.supportedValuesOf("unit").forEach(function(unit) { + // "acre", "bit", "byte", "celsius", "centimeter", ... +}); +``` + +### Exception à l'utilisation d'une clé invalide + +```js +try { + Intl.supportedValuesOf("uneCleInvalide"); +} catch (err) { + // Error: RangeError: invalid key: "uneCleInvalide" +} +``` + +## Prothèse d'émulation (<i lang="en">polyfill</i>) + +[Prothèse pour `Intl.supportedValuesOf()` dans la proposition TC39](https://github.com/tc39/proposal-intl-enumeration/tree/master/polyfill) + + +## Spécifications + +{{Specifications}} + +## Compatibilité des navigateurs + +{{Compat}} + +## Voir aussi + +- [`Intl`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl) + |