recursal/MDN huggingface dataset:
Constructeur Intl.Locale()
==========================

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.

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

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` 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 (*polyfill*)
---------------------------------

Prothèse formatjs pour `Intl.Locale`

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

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

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

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

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

* `Intl.Collator`
* Spécification Unicode sur les identifiants de locale
Intl.Locale.prototype.toString()
================================

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

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

Syntaxe
-------


```js
locale.toString();
```

### Valeur de retour

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

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

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

Exemples
--------


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

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

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

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.baseName` (en-US)
Intl.Locale.prototype.calendars
===============================

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

| Specification |
| --- |
| Intl Locale Info Proposal # sec-Intl.Locale.prototype.getCalendars |

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

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

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

* `Intl.Locale`
* `Intl.Locale.calendar`
* Identifiants de calendrier Unicode
Intl.Locale.prototype.script
============================

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

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

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

Exemples
--------

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

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


```js
let scriptStr = new Intl.Locale("en-Latn-US");

console.log(scriptStr.script); // Affichera "Latn" dans la console
```

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

Le constructeur `Locale` (en-US) permet d'utiliser un objet de configuration dont les propriétés définiront les caractéristiques de la locale :


```js
let scriptObj = new Intl.Locale("fr-FR", { script: "Latn" });

console.log(scriptObj.script); // Affichera "Latn" dans la console
```

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

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

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 Unicode pour la composante script
Intl.Locale.prototype.numeric
=============================

La propriété **`Intl.Locale.prototype.numeric`** est une propriété fournie par un accesseur et qui indique si la locale possède une collation spécifique pour les caractères numériques (la collation étant la méthode qui permet d'ordonner des chaînes de caractères entre elles).

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

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

Exemples
--------

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

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


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

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

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


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

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

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

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.weekInfo
==============================

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.

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

| Specification |
| --- |
| Intl Locale Info Proposal # sec-Intl.Locale.prototype.getWeekInfo |

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

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

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

* `Intl.Locale`
Intl.Locale.prototype.caseFirst
===============================

La propriété **`Intl.Locale.prototype.caseFirst`** est une propriété (via un accesseur) qui renvoie si la casse est prise en compte par la locale pour ses règles de collation (celles qui permettent d'ordonner des chaînes de caractères entre elles).

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

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

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

| Valeur | Description |
| --- | --- |
| `upper` | Les majuscules devraient être triées avant les minuscules. |
| `lower` | Les minuscules devraient être triées avant les majuscules. |
| `false` | La casse n'a pas d'importance pour le tri des chaînes. |

Exemples
--------

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

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

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


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

### Définir `caseFirst` via l'objet de configuration

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


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

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

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

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 Unicode pour la collation selon la casse
Intl.Locale.prototype.region
============================

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

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

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

Exemples
--------

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

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


```js
let regionStr = new Intl.Locale("en-Latn-US");

console.log(regionStr.region);
// Affichera "US" dans la console
```

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

Le constructeur `Locale` (en-US) prend comme second argument un objet de paramétrage dont chacune des propriétés permet de définir une extension ou une composante de la locale.


```js
let regionObj = new Intl.Locale("fr-Latn", { region: "FR" });

console.log(regionObj.region);
// Affichera "FR" dans la console
```

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

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

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

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

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

* `Intl.Locale` (en-US)
* Tableau Unicode des régions
Intl.Locale.prototype.language
==============================

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

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

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

Exemples
--------

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

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


```js
let langStr = new Intl.Locale("en-Latn-US");

console.log(langStr.language); // Affichera "en" dans la console
```

### Surcharger la langue via l'objet de configuration

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


```js
let langObj = new Intl.Locale("en-Latn-US", { language: "es" });

console.log(langObj.language); // Affichera "es" dans la console
```

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

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

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

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

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

* `Locale` (en-US)
* Spécification des extensions Unicode
Intl.Locale.prototype.maximize()
================================

La méthode **`Intl.Locale.prototype.maximize()`** permet d'obtenir les valeurs les plus vraisemblantes pour la langue, le script et la région de la locale en fonction des valeurs existantes.

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

Syntaxe
-------


```js
locale.maximize();
```

### Valeur de retour

Une instance `Locale` (en-US) dont la propriété `baseName` renvoie le résultat de l'algorithme de vraisemblance des composantes lancé sur `locale.baseName` (en-US).

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

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

Exemples
--------


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

// Affiche "fr-Latn-FR". Les composantes "Latn" et "FR" ont été ajoutées
// car le français ne s'écrit qu'avec l'alphabet latin et est plus probablement parlé en France.
console.log(maLocMaximized.baseName);

// Affiche "fr-Latn-FR-u-ca-gregory-hc-h24".
// On notera que les extensions (après "-u") restent inchangées.
console.log(myLocMaximized.toString());
```

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

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

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

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

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

* `Intl.Locale` (en-US)
* `Locale.baseName` (en-US)
* Spécification Unicode sur la vraisemblance entre composantes
Intl.Locale.prototype.hourCycles
================================

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

| Specification |
| --- |
| Intl Locale Info Proposal # sec-Intl.Locale.prototype.getHourCycles |

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

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

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

* `Intl.Locale`
* `Intl.Locale.hourCycle`
* Spécification Unicode pour la clé d'extension HourCycle