recursal/MDN huggingface dataset:
Intl.RelativeTimeFormat.prototype.formatToParts()
=================================================

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

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

Syntaxe
-------


```js
RelativeTimeFormat.formatToParts(valeur, unite);
```

### Paramètres

`valeur`

Une valeur numérique qu'on souhaite formater pour un message internationalisé exprimant un temps relatif.

`unite`

L'unité à utiliser pour le message internationalisé exprimant le temps relatif. Les valeurs possibles pour cet argument sont `"year"` (année), `"quarter"` (trimestre), `"month"` (mois), `"week"` (semaine), `"day"` (jour), `"hour"` (heure), `"minute"` (minute), `"second"` (secondes). Les formes plurielles sont également autorisées.

### Valeur de retour

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

Description
-----------

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

Exemples
--------


```js
const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });

// Format relative time using the day unit.
rtf.formatToParts(-1, "day");
// > [{ type: "literal", value: "yesterday"}]

rtf.formatToParts(100, "day");
// > [{ type: "literal", value: "in " },
      { type: "integer", value: "100", unit: "day" },
      { type: "literal", value: " days" }]
```

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

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

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

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

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

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

La méthode **`Intl.Segmenter.prototype.resolvedOptions()`** renvoie un nouvel objet dont les propriétés reflètent la locale et les options de granularité calculées lors de l'initialisation de cet objet `Intl.Segmenter`.

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

Syntaxe
-------


```js
resolvedOptions();
```

### Paramètres

Aucun.

### Valeur de retour

Un nouvel objet dont les propriétés reflètent les options de locale et granularité calculées lors de l'initialisation de l'objet `Intl.Segmenter` courant.

Description
-----------

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

`locale`

La balise de langue BCP 47 pour la locale effectivement utilisée. Si des valeurs d'extension Unicode avaient été incluses dans la balise de langue BCP 47 pour l'initialisation, les paires de clé/valeur ayant été demandées et qui sont prises en charge pour cette locale seront incluses dans `locale`.

`granularity`

La valeur fournie pour cette propriété avec l'argument `options` ou une valeur par défaut.

Exemples
--------

### Utilisation simple


```js
const spanishSegmenter = new Intl.Segmenter("es", { granularity: "sentence" });
const options = spanishSegmenter.resolvedOptions();
console.log(options.locale); // "es"
console.log(options.granularity); // "sentence"
```

### Granularité par défaut


```js
const spanishSegmenter = new Intl.Segmenter("es");
const options = spanishSegmenter.resolvedOptions();
console.log(options.locale); // "es"
console.log(options.granularity); // "grapheme"
```

### Locale de recours locale


```js
const banSegmenter = new Intl.Segmenter("ban");
const options = banSegmenter.resolvedOptions();
console.log(options.locale);
// "fr" sur un environnement d'exécution où la locale
// balinaise n'est pas prise en charge et où le
// français est la locale par défaut
console.log(options.granularity); // "grapheme"
```

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

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

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
Intl.Segmenter.prototype.segment()
==================================

La méthode **`Intl.Segmenter.prototype.segment()`** segmente une chaîne de caractères selon une locale et une granularité fournies par l'objet `Intl.Segmenter` courant.

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

Syntaxe
-------


```js
segment(input);
```

### Paramètres

`input`

Le texte à segmenter, sous la forme d'une chaîne de caractères.

### Valeur de retour

Un nouvel objet itérable `Segments` qui contient les segments de la chaîne fournie en entrée et dont le découpage suit la locale et la granularité fournies par le segmenteur.

Exemples
--------


```js
// On crée un segmenteur propre à une locale
const segmenter = new Intl.Segmenter("fr", { granularity: "word" });

// On l'utilise pour obtenir un itérateur sur les segments
// d'une chaîne de caractères
const input = "Moi ? N'est-ce pas ?";
const segments = segmenter.segment(input);

// Et on parcourt cet ensemble
for (const { segment, index, isWordLike } of segments) {
  console.log(
    "segment situé aux unités [%d, %d]: «%s»%s",
    index,
    index + segment.length,
    segment,
    isWordLike ? " (type mot)" : "",
  );
}
// Affiche dans la console
// segment situé aux unités [0, 3]: «Moi» (type mot)
// segment situé aux unités [3, 4]: « »
// segment situé aux unités [4, 5]: «?»
// segment situé aux unités [5, 6]: « »
// segment situé aux unités [6, 11]: «N'est» (type mot)
// segment situé aux unités [11, 12]: «-»
// segment situé aux unités [12, 14]: «ce» (type mot)
// segment situé aux unités [14, 15]: « »
// segment situé aux unités [15, 18]: «pas» (type mot)
// segment situé aux unités [18, 19]: « »
// segment situé aux unités [19, 20]: «?»
```

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

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl.segmenter.prototype.segment |

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

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

Le constructeur **`Intl.Segmenter()`** crée un objet `Intl.Segmenter` permettant la segmentation d'un texte selon la locale.

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

Syntaxe
-------


```js
new Intl.Segmenter();
new Intl.Segmenter(locales);
new Intl.Segmenter(locales, options);
```

### Paramètres

`locales` Facultatif

Une chaîne qui est une balise de langue BCP 47 ou un tableau de telles chaînes. Pour la forme générale et l'interprétation de cet argument, voir la page `Intl`.

`options` Facultatif

Un objet avec une ou plusieurs des propriétés suivantes :

`granularity` Facultatif

Une chaîne de caractères qui peut valoir :

`"grapheme"` (la valeur par défaut)

Découpe la chaîne en groupes de graphèmes (*grapheme cluster*) (ce qui correspond aux caractères perçus pour la personne qui lit), comme déterminé par la locale.

`"word"`

Découpe la chaîne en segments aux limites de mots, comme déterminé par la locale.

`"sentence"`

Découpe la chaîne en segments aux limites de phrases, comme déterminé par la locale.


`localeMatcher` Facultatif

L'algorithme de correspondance des locales à utiliser. Les valeurs possibles sont :

`"best fit"` (la valeur par défaut)

L'environnement d'exécution peut éventuellement choisir une locale plus adaptée que celle fournie par l'algorithme utilisé par `"lookup"`.

`"lookup"`

Utilise l'algorithme de recherche BCP 47 pour choisir la locale à partir de `locales`. Pour chaque locale contenue dans `locales`, l'environnement d'exécution renvoie la première locale prise en charge (en retirant éventuellement des sous-étiquettes de l'étiquette de locale fournie afin d'en sélectionner une prise en charge ; autrement dit, si on fournit `"de-CH"` pour `locales`, cet algorithme pourra fournir `"de"` en résultat si `"de"` est prise en charge mais que `"de-CH"` ne l'est pas).


### Valeur de retour

Une nouvelle instance de `Intl.Segments`.

Exemples
--------

### Utilisation simple

Dans l'exemple suivant, on compte les mots d'une chaîne en japonais (où le découpage de la chaîne à l'aide des méthodes de `String` aurait fourni un résultat incorrect).


```js
const text = "吾輩は猫である。名前はたぬき。";
const japaneseSegmenter = new Intl.Segmenter("ja-JP", { granularity: "word" });
console.log(
  [...japaneseSegmenter.segment(text)].filter((segment) => segment.isWordLike)
    .length,
);
// affiche 8 car le texte est segmenté en '吾輩'|'は'|'猫'|'で'|'ある'|'。'|'名前'|'は'|'たぬき'|'。'
```

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

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl-segmenter-constructor |

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

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

La méthode **`Intl.Segmenter.supportedLocalesOf()`** renvoie un tableau contenant les locales, parmi celles fournies en argument, qui sont prises en charge sans avoir à recourir à la locale par défaut de l'environnement d'exécution.

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

Syntaxe
-------


```js
supportedLocalesOf(locales);
supportedLocalesOf(locales, options);
```

### Paramètres

`locales`

Une chaîne qui est une balise de langue BCP 47 ou un tableau de telles chaînes. Pour la forme générale et l'interprétation de cet argument, voir la page `Intl`.

`options` Facultatif

Un objet avec la propriété suivante :

`localeMatcher`

L'algorithme de correspondance des locales à utiliser. Les valeurs possibles sont :

`"best fit"` (la valeur par défaut)

L'environnement d'exécution peut éventuellement choisir une locale plus adaptée que celle fournie par l'algorithme utilisé par `"lookup"`.

`"lookup"`

Utilise l'algorithme de recherche BCP 47 pour choisir la locale à partir de `locales`. Pour chaque locale contenue dans `locales`, l'environnement d'exécution renvoie la première locale prise en charge (en retirant éventuellement des sous-étiquettes de l'étiquette de locale fournie afin d'en sélectionner une prise en charge ; autrement dit, si on fournit `"de-CH"` pour `locales`, cet algorithme pourra fournir `"de"` en résultat si `"de"` est prise en charge mais que `"de-CH"` ne l'est pas).


### Valeur de retour

Un tableau de chaînes de caractères représentant le sous-ensemble de locales prises en charge, sans avoir à recourir à la locale par défaut de l'environnement d'exécution, pour la segmentation par rapport aux balises de langue fournies en argument.

Exemples
--------

### Utiliser `supportedLocalesOf()`

Soit un environnement d'exécution qui prend en charge l'indonésien et l'allemand mais pas le balinais pour la segmentation, `supportedLocalesOf` renvoie les balises de langue indonésienne et allemande inchangées, même si la collation `pinyin` n'est pas pertinente pour la segmentation indonésienne et qu'un dialecte allemand pour l'Indonésie a peu de chances d'être pris en charge. On notera que l'exemple utilise l'algorithme "`lookup`" et que "`best fit`" aurait pu décider que l'indonésien est une correspondance valable pour le balinais, car la plupart des personnes qui parlent balinais comprennent aussi l'indonésien. En utilisant l'algorithme `"best fit"`, on aurait donc pu avoir la balise balinaise dans les résultats.


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

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

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl.segmenter.supportedlocalesof |

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

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

Une instance **`Intl.Segments`** est une collection itérable des segments d'une chaîne de caractères. On obtient un tel objet en appelant la méthode `segment()` d'un objet `Intl.Segmenter`.

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

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

`Segments.prototype.containing()`

Renvoie un objet décrivant le segment de la chaîne de caractères originale qui contient le codet situé à l'indice passé en argument.

`Segments.prototype[@@iterator]()`

Renvoie un itérateur permettant de parcourir les segments.

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

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-segments-objects |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
Intl.Segments.prototype.containing()
====================================

La méthode **`Intl.Segments.containing()`** renvoie un objet décrivant le segment de la chaîne de caractères contenant le codet situé à l'indice passé en argument.

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

Syntaxe
-------


```js
containing(codeUnitIndex);
```

### Paramètres

`codeUnitIndex` Facultatif

Un nombre correspondant à l'indice du codet dans la chaîne de caractères à segmenter. Si cette valeur est absente, la valeur par défaut sera `0`.

### Valeur de retour

Un objet qui décrit le segment faisant partie de la chaîne de caractères originale, avec les propriétés suivantes (ou `undefined` si l'indice fourni est situé en dehors des limites de la chaîne) :

`segment`

Une chaîne de caractères contenant le segment de la chaîne de caractères originale.

`index`

L'indice du codet à partir duquel le segment en question commence au sein de la chaîne de caractères originale.

`input`

La chaîne de caractères originale.

`isWordLike`

Un booléen présent si `granularity` vaut `"word"` ; sinon, `undefined`. Si `granularity` vaut `"word"`, `isWordLike` vaudra `true` lorsque le segment est semblable à un mot (qu'il contient des lettres/nombres/idéogrammes/etc.) et `false` sinon.

Exemples
--------


```js
// ┃0 1 2 3 4 5┃6┃7┃8┃9 ← Indice des codets
// ┃A l l o n s┃-┃y┃!┃ ← Codets
const input = "Allons-y!";

const segmenter = new Intl.Segmenter("fr", { granularity: "word" });
const segments = segmenter.segment(input);
let current = undefined;

current = segments.containing();
// → { index: 0, segment: "Allons", isWordLike: true }

current = segments.containing(4);
// → { index: 0, segment: "Allons", isWordLike: true }

current = segments.containing(6);
// → { index: 6, segment: "-", isWordLike: false }

current = segments.containing(current.index + current.segment.length);
// → { index: 7, segment: "y", isWordLike: true }

current = segments.containing(current.index + current.segment.length);
// → { index: 8, segment: "!", isWordLike: false }

current = segments.containing(current.index + current.segment.length);
// → undefined
```

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

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-%segmentsprototype%.containing |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
Intl.Segments.prototype[@@iterator]()
=====================================

La méthode **`Intl.Segments.@@iterator`** fait partie de l'implémentation du protocole itérable pour `Intl.Segments` et renvoie un nouvel objet itérateur qui permet de parcourir les éléments d'un objet `Intl.Segmenter`. Chaque élément est renvoyé sous la forme d'un objet.

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

Syntaxe
-------


```js
segments[Symbol.iterator];
```


La fonction disponible sur cet itérateur est `.next()`, elle est décrite dans la page du protocole itérateur.

### Valeur de retour

Un nouvel objet itérateur.

Exemples
--------


```js
const segmenter = new Intl.Segmenter("fr", { granularity: "word" });
const input = "Moi ? N'est-ce pas ?";
const segments = segmenter.segment(input);
const iterator = segments[Symbol.iterator]();

let result = iterator.next();

while (!result.done) {
  console.log(result.value);
  result = iterator.next();
}

/\* Affiche dans la console
{segment: 'Moi', index: 0, input: "Moi ? N'est-ce pas ?", isWordLike: true}
{segment: ' ', index: 3, input: "Moi ? N'est-ce pas ?", isWordLike: false}
{segment: '?', index: 4, input: "Moi ? N'est-ce pas ?", isWordLike: false}
{segment: ' ', index: 5, input: "Moi ? N'est-ce pas ?", isWordLike: false}
{segment: "N'est", index: 6, input: "Moi ? N'est-ce pas ?", isWordLike: true}
{segment: '-', index: 11, input: "Moi ? N'est-ce pas ?", isWordLike: false}
{segment: 'ce', index: 12, input: "Moi ? N'est-ce pas ?", isWordLike: true}
{segment: ' ', index: 14, input: "Moi ? N'est-ce pas ?", isWordLike: false}
{segment: 'pas', index: 15, input: "Moi ? N'est-ce pas ?", isWordLike: true}
{segment: ' ', index: 18, input: "Moi ? N'est-ce pas ?", isWordLike: false}
{segment: '?', index: 19, input: "Moi ? N'est-ce pas ?", isWordLike: false}
\*/
```

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

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-%segmentsprototype%-@@iterator |

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

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

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

* Les protocoles d'itération
* `Array.prototype[@@iterator]()`
Intl.Locale.prototype.baseName
==============================

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

Description
-----------

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

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

Exemples
--------

### Exemple simple


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

### Exemple avec certaines options


```js
// Sets language to Japanese, region to Japan,

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

### Exemple avec options qui surchargent


```js
// Input string indicates language as Dutch and region as Belgium,

// but options object overrides the region and sets it to the Netherlands
let dutch = new Intl.Locale("nl-Latn-BE", { region: "NL" });

console.log(dutch.baseName); // Prints out "nl-Latn-NL"
```

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

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.Locale.prototype.baseName |

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

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

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

* `Intl.Locale` (en-US)
Intl.Locale.prototype.hourCycle
===============================

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

Description
-----------

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

| Clé | Description |
| --- | --- |
| `h12` | Système horaire sur les heures 1 à 12 (correspond à la notation "h" pour les motifs de recherche). L'horloge est sur douze heures et minuit commence à 12:00 AM. |
| `h23` | Système horaire sur les heures 0 à 23 (correspond à la notation "H" pour les motifs de recherche). L'horloge est sur vingt-quatre heures et minuit commence à 0:00. |
| `h11` | Système horaire sur les heures 0 à 11 (correspond à la notation "K" pour les motifs de recherche). L'horloge est sur douze heures et minuit commence à 0:00 AM. |
| `h24` | Système horaire sur les heures 1 à 24 (correspond à la notation "K" pour les motifs de recherche). L'horloge est sur vingt-quatre heures et minuit commence à 24:00. |

Exemples
--------

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

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


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

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

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


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

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

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.Locale.prototype.hourCycle |

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

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

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

* `Intl.Locale` (en-US)
* Spécification pour l'extension Unicode des cycles horaires