recursal/MDN huggingface dataset:
Intl.Segmenter
==============

L'objet **`Intl.Segmenter`** permet de segmenter un texte en tenant compte de la locale. On peut ainsi obtenir les éléments utiles (graphèmes, mots ou phrases) d'une chaîne de caractères.

Exemple interactif
------------------

Constructeur
------------

`Intl.Segmenter()`

Crée un nouvel objet `Intl.Segmenter`.

Méthodes statiques
------------------

`Intl.Segmenter.supportedLocalesOf()`

Renvoie un tableau contenant les locales prises en charge, parmi celles fournies en argument, sans avoir à recourir à la locale par défaut de l'environnement par défaut.

Méthodes des instances
----------------------

`Intl.Segmenter.prototype.resolvedOptions()`

Renvoie un nouvel objet dont les propriétés reflètent la locale et la granularité calculées lors de l'initialisation de cet objet `Intl.Segmenter`.

`Intl.Segmenter.prototype.segment()`

Renvoie une nouvelle instance `Segments` itérable qui représente les segments de la chaîne de caractères selon la locale et la granularité portées par cette instance `Intl.Segmenter`.

Exemples
--------

### Utilisation simple et différence avec `String.prototype.split()`

En utilisant `String.prototype.split(" ")` pour segmenter un texte en mots, on n'obtient pas le bon résultat si la locale du texte n'utilise pas d'espace entre les mots (ce qui est le cas pour le japonais, le chinois, le thaïlandais, le laotien, le khmer, le birman, etc.).


```js
const str = "吾輩は猫である。名前はたぬき。";
console.table(str.split(" "));
// ['吾輩は猫である。名前はたぬき。']
// Les deux phrases ne sont pas segmentées correctement.
```



```js
const str = "吾輩は猫である。名前はたぬき。";
const segmenterJa = new Intl.Segmenter("ja-JP", { granularity: "word" });

const segments = segmenterJa.segment(str);
console.table(Array.from(segments));
// [{segment: '吾輩', index: 0, input: '吾輩は猫である。名前はたぬき。', isWordLike: true},
// etc.
// ]
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Internationalization API Specification # segmenter-objects |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
Intl.Collator
=============

L'objet **`Intl.Collator`** permet de comparer des chaînes de caractères en tenant compte de la locale.

Exemple interactif
------------------

Constructeur
------------

`Intl.Collator()`

Crée un nouvel objet `Collator`.

Méthodes statiques
------------------

`Intl.Collator.supportedLocalesOf()`

Renvoie un tableau qui contient les locales, parmi celles fournies en arguments, qui sont prises en charge sans avoir à recourir à la locale par défaut de l'environnement d'exécution.

Méthodes des instances
----------------------

`Intl.Collator.prototype.compare`

Une fonction d'accesseur qui compare deux chaînes de caractères selon l'ordre de tri de l'objet `Intl.Collator` courant.

`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.

Exemples
--------

### Utiliser `Collator`

L'exemple qui suit illustre les différents résultats qu'on peut obtenir en comparant deux chaînes de caractères :


```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
```


Les résultats indiqués ici 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 `Collator.prototype.compare()` (en-US) 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'utilisatrice ou l'utilisateur (et éventuellement des locales pour des cas de replis) en utilisant l'argument `locales` :


```js
// 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 `Collator.prototype.compare()` (en-US) peuvent être adaptés grâce à l'argument `options` :


```js
// 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
--------------

| Specification |
| --- |
| ECMAScript Internationalization API Specification # collator-objects |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Intl`
Intl.PluralRules
================

L'objet **`Intl.PluralRules`** permet de mettre en forme des chaînes de caractères en fonction des règles de nombre (pluriel) d'une locale donnée.

Constructeur
------------

`Intl.PluralRules()`

Crée un nouvel objet `Intl.PluralRules`.

Méthodes statiques
------------------

`Intl.PluralRules.supportedLocalesOf()`

Renvoie un tableau qui contient les locales, parmi celles fournies en arguments, qui sont prises en charge sans avoir à recourir à la locale par défaut de l'environnement d'exécution.

Méthodes des instances
----------------------

`Intl.PluralRules.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.

`Intl.PluralRules.prototype.select()`

Renvoie une chaîne de caractères indiquant la règle de nombre qui s'applique pour le formatage en fonction de la locale.

`Intl.PluralRules.prototype.selectRange()`

Cette méthode prend deux valeurs en arguments et renvoie une chaîne de caractères indiquant la règle de nombre à utiliser pour le formatage en fonction de la locale.

Exemples
--------

### 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'utilisatrice et de l'utilisateur dans votre application, assurez-vous d'indiquer cette langue (et éventuellement une langue de secours) grâce à l'argument `locales` :


```js
// 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'
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Internationalization API Specification # pluralrules-objects |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Intl`
* Une prothèse d'émulation pour `Intl.ListFormat` avec la bibliothèque FormatJS
Intl.getCanonicalLocales()
==========================

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.

Exemple interactif
------------------

Syntaxe
-------


```js
Intl.getCanonicalLocales(locales);
```

### Paramètres

`locales`

Une liste de chaînes (`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
--------


```js
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
--------------

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl.getcanonicallocales |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Intl.NumberFormat.supportedLocalesOf()` (en-US)
* `Intl.DateTimeFormat.supportedLocalesOf()` (en-US)
* `Intl.Collator.supportedLocalesOf()` (en-US)
Intl.RelativeTimeFormat
=======================

L'objet **`Intl.RelativeTimeFormat`** permet de mettre en forme des données temporelles relatives en respectant le format des locales.

Exemple interactif
------------------

Constructeur
------------

`Intl.RelativeTimeFormat()`

Crée un nouvel objet `Intl.RelativeTimeFormat`.

Méthodes statiques
------------------

`Intl.RelativeTimeFormat.supportedLocalesOf()`

Renvoie un tableau qui contient les locales, parmi celles fournies en arguments, qui sont prises en charge sans avoir à recourir à la locale par défaut de l'environnement d'exécution.

Méthodes des instances
----------------------

`Intl.RelativeTimeFormat.prototype.format()`

Formate une valeur et une unité en fonction des options de locale et de formatage fournies par l'objet `Intl.RelativeTimeFormat` courant.

`Intl.RelativeTimeFormat.prototype.formatToParts()`

Renvoie un tableau d'objets représentant le temps relatif sous forme de fragments qui peuvent être utilisés afin de réaliser un formatage tenant compte de la locale sur mesure.

`Intl.RelativeTimeFormat.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.

Exemples
--------

### Utiliser `format()`

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


```js
// 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 `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é.


```js
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
--------------

| Specification |
| --- |
| ECMAScript Internationalization API Specification # relativetimeformat-objects |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Intl`
* La documentation Google / v8 de l'API `Intl.RelativeTimeFormat`
* Une prothèse d'émulation pour `Intl.RelativeTimeFormat` avec la bibliothèque FormatJS
Intl.Locale
===========

**Expérimental:** **Cette fonction est expérimentale**  
Puisque cette fonction est toujours en développement dans certains navigateurs, veuillez consulter le tableau de compatibilité pour les préfixes à utiliser selon les navigateurs.  
Il convient de noter qu'une fonctionnalité expérimentale peut voir sa syntaxe ou son comportement modifié dans le futur en fonction des évolutions de la spécification.

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

Exemple interactif
------------------

Syntaxe
-------


```js
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

`Intl.Locale.prototype` (en-US)

Le prototype pour le constructeur `Locale`.

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Internationalization API Specification # locale-objects |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* La prothèse d'émulation (*polyfill*) pour `Intl.Locale`
* La spécification Unicode pour les identifiants de locale
Intl.ListFormat
===============

L'objet **`Intl.ListFormat`** permet de formater des listes de façon différente selon la locale utilisée.

Exemple interactif
------------------

Constructeur
------------

`Intl.ListFormat()`

Crée un nouvel objet `Intl.ListFormat`.

Méthodes statiques
------------------

`Intl.ListFormat.supportedLocalesOf()`

Renvoie un tableau qui contient les locales, parmi celles fournies en arguments, qui sont prises en charge sans avoir à recourir à la locale par défaut de l'environnement d'exécution.

Méthodes des instances
----------------------

`Intl.ListFormat.prototype.format()`

Renvoie une chaîne de caractères, formatée selon la locale, qui représente les éléments de la liste.

`Intl.ListFormat.prototype.formatToParts()`

Renvoie un tableau d'objets qui sont chacun des fragments pouvant être utilisés pour formater la liste de valeurs en tenant compte de la locale.

Exemples
--------

### Utiliser `format()`

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


```js
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.


```js
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
--------------

| Specification |
| --- |
| ECMAScript Internationalization API Specification # listformat-objects |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Intl`
* Une prothèse d'émulation pour `Intl.ListFormat` avec la bibliothèque FormatJS
Intl.RelativeTimeFormat.prototype.format()
==========================================

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 `RelativeTimeFormat`.Exemple interactif
------------------

Syntaxe
-------


```js
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 `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.


```js
// 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.


```js
// 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
--------------

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.RelativeTimeFormat.prototype.format |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
Intl.RelativeTimeFormat.supportedLocalesOf()
============================================

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.

Exemple interactif
------------------

Syntaxe
-------


```js
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 `Intl`.

`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 `Intl`.


### 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.


```js
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
--------------

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.RelativeTimeFormat.supportedLocalesOf |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Intl.RelativeTimeFormat`
Intl.RelativeTimeFormat.prototype.resolvedOptions()
===================================================

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 `RelativeTimeFormat`.

Exemple interactif
------------------

Syntaxe
-------


```js
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 `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
--------


```js
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
--------------

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl.relativetimeformat.prototype.resolvedoptions |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Intl.RelativeTimeFormat`