recursal/MDN huggingface dataset:
AggregateError
==============

Un objet **`AggregateError`** représente une erreur lorsque plusieurs erreurs doivent être agrégées en une seule. Ce type d'exception est levée lorsque plusieurs erreurs sont rapportées par une opération, par exemple avec `Promise.any()` lorsque l'ensemble des promesses qui lui sont passées échouent.

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

`AggregateError()`

Crée un nouvel objet `AggregateError`.

Propriétés des instances
------------------------

`AggregateError.prototype.message`

Le message d'erreur. La valeur par défaut est `""`.

`AggregateError.prototype.name`

Le nom de l'erreur. La valeur par défaut est `"AggregateError"`.

Exemples
--------

### Intercepter une erreur `AggregateError`


```js
Promise.any([Promise.reject(new Error("une erreur"))]).catch((e) => {
  console.log(e instanceof AggregateError); // true
  console.log(e.message); // "All Promises rejected"
  console.log(e.name); // "AggregateError"
  console.log(e.errors); // [ Error: "une erreur" ]
});
```

### Créer un objet `AggregateError`


```js
try {
  throw new AggregateError([new Error("une erreur")], "Coucou");
} catch (e) {
  console.log(e instanceof AggregateError); // true
  console.log(e.message); // "Coucou"
  console.log(e.name); // "AggregateError"
  console.log(e.errors); // [ Error: "une erreur" ]
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-aggregate-error-objects |

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

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

Voir
----

* `Error`
decodeURI()
===========

La méthode **`decodeURI()`** permet de décoder un Uniform Resource Identifier (URI) créé par la méthode `encodeURI()` ou une méthode similaire.

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

Syntaxe
-------


```js
decodeURI(encodedURI);
```

### Paramètres

`encodedURI`

Un URI complet, encodé.

### Valeur de retour

Une nouvelle chaîne de caractères dont certains caractères ont été décodés à partir de l'URI encodée passée en argument.

### Exceptions

Cette méthode lève une exception `URIError` ("*malformed URI sequence"*) lorsque la chaîne passée en argument contient des séquences de caractères invalides.

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

Cette méthode remplace chaque séquence d'échappement présente dans l'URI encodée avec le caractère correspondant. Les séquences d'échappement qui n'auraient pas pu être introduites par `encodeURI()` ne seront pas décodées. Le caractère « `#` » n'est pas décodé au sein des séquences d'échappement.

Exemples
--------

### Décoder une URL cyrillique


```js
decodeURI(
  "https://developer.mozilla.org/ru/docs/JavaScript\_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B",
);
// "https://developer.mozilla.org/ru/docs/JavaScript\_шеллы"
```

### Gérer les exceptions


```js
try {
  var a = decodeURI("%E0%A4%A");
} catch (e) {
  console.error(e);
}

// Cela produira "URIError: malformed URI sequence"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-decodeuri-encodeduri |

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

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

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

* `decodeURIComponent()`
* `encodeURI()`
* `encodeURIComponent()`
BigInt.prototype.valueOf()
==========================

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since September 2020.

* Learn more
* See full compatibility
* Report feedback
La méthode **`valueOf()`** renvoie la valeur primitive encapsulée dans un objet `BigInt`.

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

Syntaxe
-------


```js
bigIntObj.valueOf();
```

### Valeur de retour

Un grand entier (*big int*) représentant la valeur primitive de l'objet `BigInt` courant.

Exemples
--------

### Utiliser `valueOf()`


```js
typeof Object(1n); // object
typeof Object(1n).valueOf(); // bigint
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-bigint.prototype.valueof |

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

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

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

* `BigInt.prototype.toString()`
Constructeur BigInt()
=====================

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since September 2020.

* Learn more
* See full compatibility
* Report feedback
Le constructeur **`BigInt()`** renvoie une valeur de type `bigint` (grand entier).

Syntaxe
-------


```js
BigInt(valeur);
```

### Paramètres

`valeur`

La valeur numérique de l'objet à créer. Il peut s'agir d'une chaîne de caractères ou d'un entier.


**Note :** `BigInt()` ne s'utilise pas avec l'opérateur `new`.

Exemples
--------

### Créer un nouveau grand entier


```js
BigInt(123);
// 123n
```

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

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

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

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

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

* La classe `BigInt`
BigInt.prototype.toString()
===========================

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since September 2020.

* Learn more
* See full compatibility
* Report feedback
The **`toString()`** method returns a string representing the specified `BigInt` object. The trailing "n" is not part of the string.

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

Syntaxe
-------


```js
bigIntObj.toString([base]);
```

### Paramètres

`base`Facultatif

Ce paramètre optionnel est compris entre 2 et 36 et indique la base à utiliser pour représenter les valeurs numériques.

### Valeur de retour

Une chaîne de caractères représentant l'objet `BigInt` courant.

### Exceptions

`RangeError`

Si la base fournie comme argument `toString()` est inférieure à 2 ou supérieure à 36, cela déclenchera une exception `RangeError`.

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

L'objet `BigInt` surcharge la méthode `toString()` de `Object`. Il n'hérite pas ou n'utilise pas `Object.prototype.toString()`. Pour les objets `BigInt`, la méthode `toString()` renvoie une représentation textuelle de l'objet dans la base indiquée.

La méthode `toString()` analyse le premier argument qui lui est passé et tente de renvoyer une représentation textuelle dans cette base. Pour les bases supérieures à 10, ce seront les lettres de l'alphabet pour indiquer les chiffres supérieurs à 9. Pour les nombres hexadécimaux (base 16), les lettres `a` à `f` sont utilisées par exemple.

Si l'argument `base` n'est pas indiquée, ce sera la base 10 qui sera considérée par défaut.

Si `bigIntObj` est négatif, le signe est conservé, y compris lorsque la base est 2 (dans ce cas, la chaîne renvoyée sera la représentation binaire précédée par un signe `-` et **non** le complément à deux de `bigIntObj`).

Exemples
--------

### Utiliser `toString()`


```js
17n.toString(); // '17'
66n.toString(2); // '1000010'
254n.toString(16); // 'fe'
-10n.toString(2); // -1010'
-0xffn.toString(2); // '-11111111'
```

### Gestion du zéro négatif en `BigInt`

Il n'existe pas de zéro négatif pour `BigInt` car les entiers ne gèrent pas de concept de zéro négatif. `-0.0` est un concept relatif à la représentation flottante IEEE et n'est présent que pour le type `Number`.


```js
(-0n).toString(); // '0'
BigInt(-0).toString(); // '0'
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-bigint.prototype.tostring |

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

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

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

* `BigInt.prototype.toLocaleString()`
* `BigInt.prototype.valueOf()`
* `Number.prototype.toString()`
BigInt.asIntN()
===============

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since September 2020.

* Learn more
* See full compatibility
* Report feedback
La méthode statique **`BigInt.asIntN()`** permet d'écréter un nombre `BigInt` pour obtenir un entier signé entre 2^(largeur-1) et 2^(largeur-1)-1.

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

Syntaxe
-------


```js
var resultat = BigInt.asIntN(largeur, bigint);
```

### Paramètres

`largeur`

La quantité de bits disponible pour stocker l'entier.

`bigint`

L'entier qu'on souhaite stocker sur le nombre de bits indiqués.

### Valeur de retour

La valeur de `bigint` modulo 2^`largeur` comme entier signé.

Exemples
--------

La méthode `BigInt.asIntN()` peut être utile pour rester dans une arithmétique sur 64 bits :


```js
const max = 2n \*\* (64n - 1n) - 1n;

BigInt.asIntN(64, max);
// ↪ 9223372036854775807n

BigInt.asIntN(64, max + 1n);
// ↪ -9223372036854775807n
// négatif car dépassement sur le nombre de bits
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-bigint.asintn |

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

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

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

* `BigInt`
* `BigInt.asUintN()`
BigInt.asUintN()
================

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since September 2020.

* Learn more
* See full compatibility
* Report feedback
La méthode statique **`BigInt.asUintN()`** permet d'écréter un `BigInt` pour ramener sa valeur sur un entier non-signé entre 0 et 2^(largeur)-1.

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

Syntaxe
-------


```js
var résultat = BigInt.asUintN(largeur, bigint);
```

### Paramètres

`largeur`

Le nombre de bits disponible pour stocker l'entier.

`bigint`

L'entier qu'on souhaite stocker sur le nombre de bits indiqués.

### Valeur de retour

La valeur de `bigint` modulo 2^`largeur` comme un entier non signé.

Exemples
--------

La méthode `BigInt.asUintN()` peut s'avérer utile pour rester dans une arithmétique exprimée sur 64 bits .


```js
const max = 2n \*\* 64n - 1n;

BigInt.asUintN(64, max);
// ↪ 18446744073709551615n

BigInt.asUintN(64, max + 1n);
// ↪ 0n
// zéro en raison du dépassement
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-bigint.asuintn |

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

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

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

* `BigInt`
* `BigInt.asIntN()`
TypedArray.prototype.toLocaleString()
=====================================

La méthode **`toLocaleString()`** renvoie une chaîne de caractères qui représente les éléments du tableau typé. Les éléments sont convertis en chaînes de caractères et séparés par une chaîne de caractères qui est fonction de la locale (la virgule `,` par exemple). Cette méthode utilise le même algorithme que `Array.prototype.toLocaleString()` et vu que les éléments d'un tableau typé sont des nombres, elle utilise le même algorithme que `Number.prototype.toLocaleString()` pour chaque élément. Dans la suite de cet article, `TypedArray` fait référence à l'un des types de tableau typé listés ici.

Syntaxe
-------


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

### Paramètres

Les arguments `locales` et `options` permettent d'adapter le comportement de la fonction en laissant les applications indiquer la locale dont les conventions de formatage doivent être utilisées. Pour les implémentations qui ne prennent pas en charge les arguments `locales` et `options`, le format et la locale utilisés dépendent entièrement de l'implémentation.

Voir la page du constructeur `Intl.NumberFormat()` pour plus de détails sur ces paramètres et comment les utiliser.

### Valeur de retour

Une chaîne de caractères qui représente les éléments du tableau typé.

Exemples
--------

### Utiliser `toLocaleString()`


```js
let uint = new Uint32Array([2000, 500, 8123, 12, 4212]);

uint.toLocaleString();
// si on exécute sur un environnement utilisant la locale de-DE
// "2.000,500,8.123,12,4.212"

uint.toLocaleString("en-US");
// "2,000,500,8,123,12,4,212"

uint.toLocaleString("ja-JP", { style: "currency", currency: "JPY" });
// "￥2,000,￥500,￥8,123,￥12,￥4,212"
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.tolocalestring |

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

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

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

* `Array.prototype.toLocaleString()`
* `Number.prototype.toLocaleString()`
TypedArray.prototype.subarray()
===============================

La méthode `subarray()` permet de renvoyer un nouvel objet *TypedArray* basé sur le même `ArrayBuffer` et dont les éléments sont du même type que l'objet *TypedArray* courant. Le paramètre `début` est à considérer au sens large et le paramètre `end` est à considérer au sens strict. *TypedArray* est l'un des types de tableaux typés.

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

Syntaxe
-------


```js
typedarray.subarray([début[,fin]])
```

### Paramètres

`début`Facultatif

L'élément à partir duquel commencer le nouveau tableau typé. Cet élément initial sera inclus dans le nouveau tableau (sens large). Si la valeur n'est pas définie, tout le tableau sera inclus dans la nouvelle vue.

`fin`Facultatif

L'élément auquel finir le nouveau tableau typé. Cet élément ne fera pas partie du nouveau tableau (sens strict). Si ce paramètre n'est pas utilisé, tous les éléments contenus à partir de `début` jusqu'à la fin du tableau courant seront inclus dans la nouvelle vue.

### Valeur de retour

Un nouvel objet `TypedArray`.

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

L'intervalle défini par `début` et `fin` est redimensionné si besoin pour être un intervalle valide en regard du tableau courant. Si la longueur du nouveau tableau est négative, elle est ramenée à zéro. Si `début` ou `fin` a une valeur négative, on prendra en compte la position à partir de la fin du tableau et non à partir du début de celui-ci.

On notera que cette méthode permet de créer un nouvelle vue sur le tampon (*buffer*) existant, tous les changements apportés via le nouvel objet impacteront le tableau typé initial et vice versa.

Exemples
--------


```js
var buffer = new ArrayBuffer(8);
var uint8 = new Uint8Array(buffer);
uint8.set([1, 2, 3]);

console.log(uint8); // Uint8Array [ 1, 2, 3, 0, 0, 0, 0, 0 ]

var sub = uint8.subarray(0, 4);

console.log(sub); // Uint8Array [ 1, 2, 3, 0 ]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.subarray |

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

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

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

* Les tableaux typés JavaScript
* `TypedArray`
* `ArrayBuffer`
TypedArray.prototype.slice()
============================

La méthode **`slice()`** des instances de `TypedArray` renvoie une copie d'un fragment du tableau typé courant dans un nouveau tableau typé. La portion est prise entre les paramètres `début` (inclus) et `fin` (non-inclus) qui correspondent aux indices des éléments du tableau typé courant. Le tableau typé original ne sera pas modifié. Cette méthode utilise le même algorithme que `Array.prototype.slice()`

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

Syntaxe
-------


```js
slice()
slice(début)
slice(début, fin)
```

Paramètres
----------

`début` Facultatif

L'indice (compté à partir de zéro), converti en entier, à partir duquel commencer le fragment.

`fin` Facultatif

L'indice (compté à partir de zéro), converti en entier, jusqu'auquel extraire le fragment. Le fragment obtenu n'inclura pas l'élément situé à l'indice `fin`.

### Valeur de retour

Un nouveau tableau typé qui contient les éléments extraits.

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

Voir `Array.prototype.slice()` pour plus détails. Cette méthode n'est pas générique et peut uniquement être appelée sur les instances de tableaux typés.

Exemples
--------

### Renvoyer un fragment d'un tableau typé existant


```js
const uint8 = new Uint8Array([1, 2, 3]);
uint8.slice(1); // Uint8Array [ 2, 3 ]
uint8.slice(2); // Uint8Array [ 3 ]
uint8.slice(-2); // Uint8Array [ 2, 3 ]
uint8.slice(0, 1); // Uint8Array [ 1 ]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.slice |

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 (*polyfill*) pour `TypedArray.prototype.slice()` dans la bibliothèque `core-js`
* Le guide sur les tableaux typés en JavaScript
* `TypedArray`
* `Array.prototype.slice()`
* `String.prototype.slice()`
TypedArray.prototype.includes()
===============================

La méthode **`includes()`** détermine si un tableau typé possède un certain élément et renvoie `true` ou `false` selon le cas de figure. Cette méthode utilise le même algorithme que la méthode `Array.prototype.includes()`. Dans le reste de l'article *TypedArray* fait référence à un des types de tableau typé.

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

Syntaxe
-------


```js
typedarray.includes(élémentRecherché[, indiceDébut]);
```

### Paramètres

`élémentRecherché`

L'élément qu'on cherche au sein du tableau typé.

`indiceDébut`

Paramètre optionnel qui correspond à la position du tableau à partir de laquelle effectuer la recherche. La valeur par défaut est 0.

### Valeur de retour

Un booléen indiquant la présence de l'élément (`true` s'il y est, `false` sinon).

Exemples
--------


```js
var uint8 = new Uint8Array([1, 2, 3]);
uint8.includes(2); // true
uint8.includes(4); // false
uint8.includes(3, 3); // false

// Gestion de NaN (vrai uniquement pour Float32 et Float64)
new Uint8Array([NaN]).includes(NaN); // false car NaN est converti en 0 par le constructeur
new Float32Array([NaN]).includes(NaN); // true;
new Float64Array([NaN]).includes(NaN); // true;
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.includes |

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

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

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

* `Array.prototype.includes()`
* `String.prototype.includes()`
* `TypedArray.prototype.indexOf()`
TypedArray.prototype.sort()
===========================

La méthode **`sort()`** permet de trier numériquement les éléments d'un tableau typé, à même ce tableau. Cette méthode utilise le même algorithme que `Array.prototype.sort()` en triant les valeurs par ordre numérique plutôt que par ordre lexicographique\*.\* Par la suite, *TypedArray* désigne l'un des types de tableau typé here.

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

Syntaxe
-------


```js
typedarray.sort([fonctionComparaison]);
```

### Paramètres

`fonctionComparaison` Facultatif

Cette fonction définit l'ordre de tri à appliquer.

### Valeur de retour

Le tableau typé trié.

Exemples
--------

Pour plus d'exemples, voir la page sur la méthode `Array.prototype.sort()`.


```js
var nombres = new Uint8Array([40, 1, 5, 200]);
nombres.sort();
// Uint8Array [ 1, 5, 40, 200 ]
// Contrairement aux tableaux classiques (Array), une fonction
// de comparaison n'est pas nécessaire pour les nombres

var nombres2 = [40, 1, 5, 200];
nombres2.sort();
// Les éléments d'un tableau classique sont triés comme des chaînes
// [1, 200, 40, 5]

function comparaisonNombres(a, b) {
  return a - b;
}

nombres.sort(comparaisonNombres);
// [ 1, 5, 40, 200 ]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.sort |

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

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

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

* `Array.prototype.sort()`
TypedArray.of()
===============

La méthode **`TypedArray.of()`** crée un nouvel objet `TypedArray` à partir d'un nombre variable d'arguments. Cette méthode est similaire à `Array.of()`.

Syntaxe
-------


```js
TypedArray.of(élément0[, élément1[, ...[, élémentN]]])
```


où TypedArray est l'un de :

* `Int8Array`
* `Uint8Array`
* `Uint8ClampedArray`
* `Int16Array`
* `Uint16Array`
* `Int32Array`
* `Uint32Array`
* `Float32Array`
* `Float64Array`
* `BigInt64Array`
* `BigUint64Array`
### Paramètres

`élémentN`

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

### Valeur de retour

Une nouvelle instance de `TypedArray`.

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

Il existe de légères différences entre `Array.of()` et `TypedArray.of()` :

* Si la valeur de `this` passée à `TypedArray.of` n'est pas un constructeur, `TypedArray.of` lèvera une exception `TypeError`, tandis que `Array.of` créera un nouvel objet `Array`.
* `TypedArray.of` utilise `[[Put]]` tandis que `Array.of` utilise `[[DefineProperty]]`. Ainsi lorsque les arguments sont des objets `Proxy` la première méthode appellera `handler.set` pour créer les nouveaux éléments et la seconde appellera `handler.defineProperty`.
Exemples
--------


```js
Uint8Array.of(1); // Uint8Array [ 1 ]
Int8Array.of("1", "2", "3"); // Int8Array [ 1, 2, 3 ]
Float32Array.of(1, 2, 3); // Float32Array [ 1, 2, 3 ]
Int16Array.of(undefined); // Int16Array [ 0 ]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.of |

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

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

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

* `TypedArray.from()`
* `Array.of()`