recursal/MDN huggingface dataset:
Intl.DisplayNames.prototype.of()
================================

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

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

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, ou un code de région géographique sur trois chiffres UN M49.
* Si le type est `"script"`, le code sera un code de script ISO-15924 sur quatre lettres.
* 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. *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.

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

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.DisplayNames.prototype.of |

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

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

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

* `Intl.DisplayNames`
Intl.DisplayNames.supportedLocalesOf()
======================================

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

`options` Facultatif

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


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

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

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

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

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

* `Intl.DisplayNames`
Intl.DisplayNames() constructor
===============================

Le constructeur **`Intl.DisplayNames()`** crée des objets qui permettent de fournir des traductions constantes des noms de langues, régions et systèmes d'écriture.

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

Syntaxe
-------


```js
new Intl.DisplayNames([langues[, options]])
```

### Paramètres

`langues` Facultatif

Une chaine avec un code de langue BCP 47, ou un tableau de telles chaines. Pour comprendre la forme générale et l'interprétation de cet argument, voyez Intl page. Les clés d'extensions Unicode suivantes sont permises :

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


`options` Facultatif

Un objet avec certaines des des propriétés suivantes :

`localeMatcher`

L'algorithme de correspondance régional à utiliser. Les valeurs possibles sont `"lookup"` et `"best fit"` ; celle par défaut étant `"best fit"`. Pour plus d'informations à propos de cette option, voir Intl page.

`style`

Le style de mise en forme à utiliser, celui par défaut étant `"long"`.

* `"narrow"`
* `"short"`
* `"long"`

`type`

Le type à utiliser, celui par défaut étant `"language"`.

* `"language"`
* `"region"`
* `"script"`
* `"currency"`

`fallback`

La valeur par défaut à utiliser, celle par défaut étant `"code"`.

* `"code"`
* `"none"`


Exemples
--------

### Utilisation simple

Dans son utilisation simple, sans spécifier de langue, une chaine dans la langue locale par défaut et avec les options par défaut sera retournée.


```js
console.log(new Intl.DisplayNames().of("US"));
// Expected output: 'us'
```

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

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

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

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

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

* `Intl.DisplayNames`
Intl.Collator.supportedLocalesOf()
==================================

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

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

Syntaxe
-------


```js
Intl.Collator.supportedLocalesOf(locales [, options])
```

### Paramètres

`locales`

Une chaîne de caractères qui est une balise de langue BCP 47 ou bien un tableau de telles chaînes. Pour plus d'informations concernant la forme générale de l'argument `locales`, voir la page `Intl`.

`options`Facultatif

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

`localeMatcher`

L'algorithme utilisé pour la correspondance entre chaînes de caractères. Les valeurs possibles sont `"lookup"` et `"best fit"`. La valeur par défaut est `"best fit"`. Pour plus d'informations, voir la page `Intl`.


### Valeur de retour

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

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

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

Exemples
--------

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


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

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

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

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

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

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

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

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

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

Syntaxe
-------


```js
collator.resolvedOptions();
```

### Valeur de retour

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

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

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

`locale`

La balise de langue BCP 47 qui est réellement utilisée. Si des extensions Unicode étaient fournies avec la balise d'origine et sont supportées pour la locale utilisée, les paires de clés-valeurs seront incluses dans `locale`.

`usage`,`sensitivity`, `ignorePunctuation`

Les valeurs demandées pour ces propriétés via l'argument `options` ou celles utilisées par défaut.

`collation`

La valeur demandée pour l'extension Unicode `"co"` si elle est supportée par la locale utilisée, sinon `"default"`.

`numeric`, `caseFirst`

Les valeurs demandées pour ces propriétés via l'argument `options` ou l'utilisation des extensions Unicode `"kn"` et `"kf"` ou les valeurs par défaut. Si l'implémentation utilisée ne supporte pas ces propriétés, elles sont omises.

Exemples
--------


```js
var de = new Intl.Collator("de", { sensitivity: "base" });
var usedOptions = de.resolvedOptions();

usedOptions.locale; // "de"
usedOptions.usage; // "sort"
usedOptions.sensitivity; // "base"
usedOptions.ignorePunctuation; // false
usedOptions.collation; // "default"
usedOptions.numeric; // false
```

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

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

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

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

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

* `Intl.Collator`
Intl.Collator.prototype.compare
===============================

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

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

Syntaxe
-------


```js
collator.compare(chaine1, chaine2);
```

### Paramètres

`chaine1`, `chaine2`

Les chaînes de caractères à comparer.

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

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

Exemples
--------

### Utiliser `compare()` pour trier un tableau

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


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

### Utiliser `compare()` pour chercher dans un tableau

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


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

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

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl.collator.prototype.compare |

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

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

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

* `Intl.Collator`
* `String.prototype.localeCompare()`
Constructeur TypeError()
========================

Le constructeur **`TypeError()`** permet de créer un objet représentant une erreur qui se produit lorsqu'une opération n'a pu être réalisée, généralement (mais pas toujours) parce qu'une valeur n'était pas du type attendu.

Syntaxe
-------


```js
new TypeError();
new TypeError(message);
new TypeError(message, nomFichier);
new TypeError(message, nomFichier, numeroLigne);
```

### Paramètres

`message` Facultatif

Une description de l'erreur, compréhensible par un humain.

`nomFichier` Facultatif

Le nom du fichier qui contient le code qui a déclenché l'exception.

`numeroLigne` Facultatif

Le numéro de la ligne du code qui a déclenché l'exception.

Exemples
--------

### Intercepter une exception `TypeError`


```js
try {
  null.f();
} catch (e) {
  console.log(e instanceof TypeError); // true
  console.log(e.message); // "null has no properties"
  console.log(e.name); // "TypeError"
  console.log(e.fileName); // "Scratchpad/1"
  console.log(e.lineNumber); // 2
  console.log(e.columnNumber); // 2
  console.log(e.stack); // "@Scratchpad/2:2:3\n"
}
```

### Créer une exception `TypeError`


```js
try {
  throw new TypeError("Coucou", "unFichier.js", 10);
} catch (e) {
  console.log(e instanceof TypeError); // true
  console.log(e.message); // "Coucou"
  console.log(e.name); // "TypeError"
  console.log(e.fileName); // "unFichier.js"
  console.log(e.lineNumber); // 10
  console.log(e.columnNumber); // 0
  console.log(e.stack); // "@Scratchpad/2:2:9\n"
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-nativeerror-constructors |

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

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

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

* `Error`
WeakSet.prototype.delete()
==========================

La méthode **`delete()`** permet de retirer un élément donné d'un objet `WeakSet`.

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

Syntaxe
-------


```js
ws.delete(valeur);
```

### Paramètre

`valeur`

Ce paramètre est obligatoire. Il correspond à l'objet qu'on souhaite retirer de l'ensemble `WeakSet`.

### Valeur de retour

`true` si un élément de l'objet `WeakSet` a bien été retiré, `false` sinon (dans le cas où la clé n'a pas été trouvée ou si la clé n'est pas un objet).

Exemples
--------


```js
var ws = new WeakSet();
var obj = {};

ws.add(window);

ws.delete(obj); // Renvoie false. Aucun objet obj n'a été trouvé ni retiré.
ws.delete(window); // Renvoie true, l'objet window a pu être retiré.

ws.has(window); // Renvoie false, window n'appartient plus au WeakSet.
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakset.prototype.delete |

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

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

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

* `WeakSet`
* `WeakSet.prototype.clear()`
Constructeur WeakSet()
======================

Le **constructeur `WeakSet()`** permet de créer des objets `WeakSet` qui stockent, avec des références faibles, des *objets* dans un ensemble.

Syntaxe
-------


```js
new WeakSet();
new WeakSet(iterable);
```

### Paramètres

`iterable` Facultatif

Si un objet itérable est passé en argument, ses différents éléments seront ajoutés au nouvel objet `WeakSet` créé. `null` est considéré comme `undefined`.

Exemples
--------

### Utiliser `WeakSet()`


```js
const ws = new WeakSet();
const toto = {};
const truc = {};

ws.add(toto);
ws.add(truc);

ws.has(toto); // true
ws.has(truc); // true

ws.delete(toto); // retire toto de l'ensemble
ws.has(toto); // false, toto a été retiré
ws.has(truc); // true, truc est retenu
```


On notera que `toto !== truc`. Même si ces objets se ressemblent, *ce ne sont pas **les mêmes objets***. Aussi, ils sont tous les deux ajoutés à l'ensemble.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakset-constructor |

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

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

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

* Une prothèse d'émulation pour `WeakSet` avec la bibliothèque `core-js`
* `WeakSet`
WeakSet.prototype.add()
=======================

La méthode **`add()`** permet d'ajouter un nouvel objet à un objet `WeakSet`.

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

Syntaxe
-------


```js
ws.add(valeur);
```

### Paramètres

`valeur`

Ce paramètre est obligatoire. Il correspond à l'objet qu'on souhaite ajouter à l'ensemble `WeakSet`.

### Valeur de retour

L'objet `WeakSet`.

Exemples
--------


```js
var ws = new WeakSet();

ws.add(window); // on ajouter l'objet window à l'objet WeakSet

ws.has(window); // tru

// WeakSet ne peut contenir que des objets
ws.add(1);
// TypeError: Invalid value used in weak set -> Chrome
// TypeError: 1 is not a non-null obect -> Firefox
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakset.prototype.add |

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

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

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

* `WeakSet`
* `WeakSet.prototype.delete()`
* `WeakSet.prototype.has()`
WeakSet.prototype.has()
=======================

La méthode **`has()`** renvoie un booléen indiquant si un objet donné est contenu dans l'ensemble `WeakSet`.

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

Syntaxe
-------


```js
ws.has(valeur);
```

### Paramètres

`valeur`

Ce paramètre est obligatoire. Il représente l'objet dont on souhaite savoir s'il est, ou non, présent dans l'objet `WeakSet`.

### Valeur renvoyée

Booléen

La méthode renvoie `true` si l'objet `WeakSet` contient bien un élément avec la valeur donnée, `false` sinon.

Exemples
--------


```js
var ws = new WeakSet();
var obj = {};
ws.add(window);

mySet.has(window); // renvoie true
mySet.has(obj); // renvoie false
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakset.prototype.has |

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

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

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

* `WeakSet`
* `WeakSet.prototype.add()`
* `WeakSet.prototype.delete()`
Array.of()
==========

La methode **`Array.of()`** permet de créer une nouvelle instance d'objet `Array` à partir d'un nombre variable d'arguments, quels que soient leur nombre ou leur type.

La différence entre **`Array.of()`** et le constructeur **`Array`** se situe dans la gestion de d'arguments entiers : **`Array.of(7)`** crée un tableau avec un seul élément, 7, tandis que **`Array(7)`** produit un tableau avec 7 éléments vides (à ne pas confondre avec des éléments qui auraient explicitement la valeur `undefined`).


```js
Array.of(7); // [7]
Array.of(1, 2, 3); // [1, 2, 3]

Array(7); // un tableau avec 7 emplacements vides
Array(1, 2, 3); // [1, 2, 3]
```

Syntaxe
-------


```js
Array.of(element0[, element1[, ...[, elementN]]])
```

### Paramètres

*`element0`, `element1`, ..., `elementN`*

Les éléments avec lesquels on souhaite construire le nouveau tableau.

### Valeur de retour

Une nouvelle instance de `Array`.

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

Cette fonction fait partie du standard ECMAScript 2015. Pour plus d'informations, voir les pages sur la proposition pour `Array.of` et `Array.from` ainsi que la page sur le fragment d'émulation pour `Array.of`.


```js
Array.of(7); // [7]
Array.of(1, 2, 3); // [1, 2, 3]

Array(7); // [ , , , , , , ]
Array(1, 2, 3); // [1, 2, 3]
```

Exemples
--------


```js
Array.of(1); // [1]
Array.of(1, 2, 3); // [1, 2, 3]
Array.of(undefined); // [undefined]
```

Prothèse d'émulation (*polyfill*)
---------------------------------

Exécuter ce code avant tout autre code permettra de créer la méthode **`Array.of()`** si elle n'est pas prise en charge nativement.


```js
if (!Array.of) {
  Array.of = function () {
    return Array.prototype.slice.call(arguments);
  };
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.of |

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

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

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

* `Array`
* `Array.from`
* `TypedArray.of()`
Array.prototype[@@unscopables]
==============================

La propriété symbol **`@@unscopable`** contient les noms des propriétés qui ne faisait pas partie du standard ECMAScript avant ES2015 (ES6). Ces propriétés sont exclues lors de liaisons effectuée via l'instruction `with`.

Syntaxe
-------


```js
arr[Symbol.unscopables];
```

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

Les propriétés natives d'un objet `Array` qui sont exclues lorsqu'on utilise `with` sont `copyWithin`, `entries`, `fill`, `find`, `findIndex`, `includes`, `keys` et `values`.

Voir la page sur le symbole `Symbol.unscopables` pour manipuler `unscopables` sur des objets personnalisés.

| Attributs de `Array.prototype[@@unscopables]` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Oui |

Exemples
--------

Le code qui suit fonctionne bien pour ES5 et les versions antérieures. En revanche, pour ECMAScript 2015 (ES6) et les versions ultérieures où la méthode `Array.prototype.keys()` existe, lorsqu'on utilise un environnement créé avec `with`, `"keys"` serait désormais la méthode et non la variable. C'est là que le symbole natif `@@unscopables` `Array.prototype[@@unscopables]` intervient et empêche d'explorer ces méthodes avec `with`.


```js
var keys = [];

with (Array.prototype) {
  keys.push("something");
}

Object.keys(Array.prototype[Symbol.unscopables]);
// ["copyWithin", "entries", "fill", "find", "findIndex",
// "includes", "keys", "values"]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype-@@unscopables |

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

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

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

* `Symbol.unscopables`