recursal/MDN huggingface dataset:
TypedArray.prototype.forEach()
==============================

La méthode **`forEach()`** permet d'exécuter une fonction donnée sur chaque élément du tableau. Cette méthode implémente le même algorithme que `Array.prototype.forEach()`.

Syntaxe
-------


```js
tableauTypé.forEach(callback[, thisArg])
```

### Paramètres

`callback`

La fonction à utiliser pour chaque élément du tableau typé. Elle prend trois arguments :

`valeurÉlément`

La valeur de l'élément traité actuellement.

`indiceÉlément`

L'indice de l'élément traité actuellement.

`tableau`

Le tableau parcouru par `forEach()`.


`thisArg`

Optionnel. La valeur utilisée pour `this` lors de l'appel à `callback()`.

### Valeur de retour

`undefined`.

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

La méthode `forEach()` exécute la fonction `callback()` une fois pour chaque élément présent dans le tableau typé, par ordre d'indice croissant. Cette fonction n'est pas appelée pour les indices sur lesquels les éléments ont été supprimés ou n'ont pas été définis. `callback()` est cependant appelée pour les éléments qui portent la valeur `undefined`.

`callback()` accepte **trois arguments** :

* la **valeur de l'élément**
* l'**indice de l'élément**
* le **le tableau typé traversé**

Si le paramètre `thisArg` est fourni à `forEach()`, il sera la valeur du `this` utilisé par chaque exécution de `callback()`. Dans le cas contraire, la valeur `undefined` sera utilisée par défaut. Pour déterminer la valeur de `this` véritablement visible par `callback()` durant son exécution, les règles habituelles pour `déterminer la valeur de this du point de vue d'une fonction` sont appliquées.

L'ensemble des éléments visités par `forEach()` est fixé avant le premier appel à `callback`. Ainsi, les éléments qui sont ajoutés au tableau typé après que l'exécution de `forEach()` soit lancée ne seront pas traités. Cependant, si la valeur d'un élément à traiter est modifiée pendant l'exécution de `forEach()`, la valeur passée à `callback()` sera celle de l'élément au moment où il est traité. Si un élément est supprimé avant d'être visité, il ne sera pas traité.

`forEach()` lance un appel à la fonction `callback()` pour chaque élément du tableau typé ; à la différence de `every()` et `some()` cette méthode renvoie toujours `undefined`.

Exemples
--------

### Exemple: Affichage du contenu d'un tableau typé

Le code ci-dessous affiche une ligne pour chaque élément du tableau typé :


```js
function affichageContenuTableau(élément, index, tableau) {
  console.log("a[" + index + "] = " + élément);
}

new Uint8Array([0, 1, 2, 3]).forEach(affichageContenuTableau);
// log :
// a[0] = 0
// a[1] = 1
// a[2] = 2
// a[3] = 3
```

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

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

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

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

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

* `TypedArray.prototype.map()`
* `TypedArray.prototype.every()`
* `TypedArray.prototype.some()`
* `Array.prototype.forEach()`
TypedArray.prototype.length
===========================

La propriété **`length`** est un accesseur qui permet de représenter la longueur, en nombre d'éléments, d'un tableau typé.

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

Syntaxe
-------


```js
typedarray.length;
```

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

La propriété `length` est un accesseur dont le mutateur correspondant vaut `undefined`, ce qui signifie qu'elle n'est accessible qu'en lecture. La valeur de la propriété est déterminée lors de la construction du *TypedArray* et ne peut pas être modifiée. Si le *TypedArray* n'utilise pas de `byteOffset` ou de `length`, le résultat correspondra à la longueur du `ArrayBuffer` correspondant. *TypedArray* est l'un des objets TypedArray.

Exemples
--------


```js
var tampon = new ArrayBuffer(8);

var uint8 = new Uint8Array(tampon);
uint8.length; // 8 (correspond à la longueur du tampon/buffer)

var uint8 = new Uint8Array(tampon, 1, 5);
uint8.length; // 5 (correspond à la longueur définie lors de la construction)

var uint8 = new Uint8Array(tampon, 2);
uint8.length; // 6 (correspond à la longueur en prenant en compte le décalage utilisé)
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-%typedarray%.prototype.length |

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

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

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

* Les tableaux typés en JavaScript
* `TypedArray`
TypedArray.prototype.indexOf()
==============================

La méthode **`indexOf()`** renvoie le premier indice (le plus petit) auquel on peut trouver un élément donné dans le tableau typé. Si l'élément n'est pas trouvé, la valeur de retour sera -1. L'algorithme utilisé pour cette méthode est le même que celui pour `Array.prototype.indexOf()`. Pour le reste de l'article *TypedArray* correspond à l'un des types de tableau typé.

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

Syntaxe
-------


```js
typedarray.indexOf(élémentRecherché[, indiceDébut = 0])
```

### Paramètres

`élémentRecherché`

L'élément qu'on souhaite situer dans le tableau typé.

`indiceDébut`

Paramètre optionnel représentant l'indice à partir duquel commencer la recherche de l'élément. Si l'indice est supérieur ou égal à la longueur du tableau, la méthode renverra -1 et le tableau typé ne sera pas parcouru. Si la valeur fournie est négative, la recherche commencera à partir de l'élément situé à l'indice `length-indiceDébut`. Note : même si la valeur fournie est négative, le parcours du tableau typé s'effectuera toujours du plus petit index vers le plus grand. Si la valeur calculée pour l'indice de début est inférieure à 0, l'ensemble du tableau typé sera parcouru. La valeur par défaut de ce paramètre est 0 (tout le tableau est parcouru).

### Valeur de retour

Le premier indice du tableau pour lequel l'élément a été trouvé, `-1` s'il n'a pas été trouvé.

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

`indexOf` compare `élémentRecherché` aux éléments du tableau typé en utilisant l'égalité stricte (celle utilisée par l'opérateur ===).

Exemples
--------


```js
var uint8 = new Uint8Array([2, 5, 9]);
uint8.indexOf(2); // 0
uint8.indexOf(7); // -1
uint8.indexOf(9, 2); // 2
uint8.indexOf(2, -1); // -1
uint8.indexOf(2, -3); // 0
```

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

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

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

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

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

* `TypedArray.prototype.lastIndexOf()`
* `Array.prototype.indexOf()`
TypedArray.prototype.reduceRight()
==================================

La méthode **`reduceRight()`** applique une fonction sur un accumulateur et chaque valeur du tableau typé (de la droite vers la gauche) afin de réduire le tableau en une seule valeur. Cette méthode utilise le même algorithme que `Array.prototype.reduceRight()`. Dans le reste de cet article *TypedArray* correspond à un des types de tableaux typés.

Syntaxe
-------


```js
typedarray.reduceRight(callback[, valeurInitiale])
```

### Paramètres

`callback`

La fonction à exécuter sur chaque valeur du tableau typé. Elle utilise quatre arguments :

`valeurPrécédente`

La valeur renvoyée précédemment par l'appel précédent à `callback`. Dans le cadre du premier élément, ce sera `valeurInitiale` si ce paramètre est fourni (voir ci-après).

`valeurCourante`

L'élément du tableau typé en cours de traitement

`index`

L'indice de l'élément du tableau typé en cours de traitement.

`array`

Le tableau typé pour lequel `reduceRight` a été appelée.


`valeurInitiale`

Paramètre optionnel qui correspond à l'objet à utiliser en tant que premier argument pour le premier appel à `callback`.

### Valeur de retour

La valeur obtenue à partir de la réduction du tableau typé.

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

La méthode `reduceRight` exécute la fonction `callback` une fois pour chaque élément présent dans le tableau typé (les éléments vides ou supprimés ne sont pas traités). La fonction `callback` utilise quatre arguments : la valeur initiale ou la valeur précédemment calculée, la valeur de l'élément courant, l'indice de l'élément courant et le tableau typé qui est parcouru.

L'appel à `reduceRight` utilisant la fonction `callback` ressemble à :


```js
typedarray.reduceRight(
  function (valeurPrécédente, valeurCourante, index, typedarray) {
    // ...
  },
);
```


Lors du premier appel à la fonction callback, `valeurPrécédente` et `valeurCourante` peuvent être un ou deux valeurs différentes. Si `valeurInitiale` est fournie, `valeurPrécédente` sera alors égale à `valeurInitiale` et `valeurCourante` sera égale à la première valeur du tableau. Si le paramètre `valeurInitiale` n'est pas utilisé, `valeurPrécédente` sera égale au premier élément du tableau typé et `valeurCourante` sera égale au second élément.

Si le tableau typé est vide et que le paramètre `valeurInitiale` n'a pas été fourni, une exception `TypeError` sera levée. SI le tableau typé ne possède qu'un seul élément et que `valeurInitiale` n'a pas été fourni (ou que `valeurInitiale` a été utilisée mais que le tableau typé est vide), la valeur unique sera renvoyée et `callback` ne sera pas appelée.

Exemples
--------


```js
var total = new Uint8Array([0, 1, 2, 3]).reduceRight(function (a, b) {
  return a + b;
});
// total == 6
```

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

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

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

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

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

* `TypedArray.prototype.reduce()`
* `Array.prototype.reduceRight()`
TypedArray.prototype.keys()
===========================

La méthode **`keys()`** renvoie un nouvel objet `Array Iterator` contenant les clés pour chaque indice du tableau typé.

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

Syntaxe
-------


```js
arr.keys();
```

### Valeur de retour

Un nouvel objet `Array Iterator`.

Exemples
--------

### Parcourir un tableau avec `for...of`


```js
var arr = new Uint8Array([10, 20, 30, 40, 50]);
var eArray = arr.keys();
// prérequis : le navigateur doit supporter les
// boucles for..of et les variables dont la portée
// est définie par let
for (let n of eArray) {
  console.log(n);
}
```

### Une autre méthode d'itération


```js
var arr = new Uint8Array([10, 20, 30, 40, 50]);
var eArr = arr.keys();
console.log(eArr.next().value); // 0
console.log(eArr.next().value); // 1
console.log(eArr.next().value); // 2
console.log(eArr.next().value); // 3
console.log(eArr.next().value); // 4
```

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

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

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`
* `TypedArray.prototype.entries()`
* `TypedArray.prototype.values()`
* `TypedArray.prototype[@@iterator]()`
* `for...of`
* Les protocoles d'itération
TypedArray.prototype.reverse()
==============================

La méthode **`reverse()`** inverse les éléments d'un tableau. Le premier élément du tableau typé devient le dernier, le dernier élément devient le premier et ainsi de suite. Cette méthode utilise le même algorithme que `Array.prototype.reverse()`*.* Dans le reste de cet article *TypedArray* correspond à un des types de tableaux typés.

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

Syntaxe
-------


```js
typedarray.reverse();
```

### Valeur de retour

Le tableau typé dont les éléments ont été inversés.

Exemples
--------


```js
var uint8 = new Uint8Array([1, 2, 3]);
uint8.reverse();

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

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

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

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

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

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

* `Array.prototype.reverse()`
TypedArray.prototype[@@iterator]()
==================================

La valeur initiale de la propriété @@iterator est le même objet fonction que la valeur initiale de `values`.

Syntaxe
-------


```js
typedarray[Symbol.iterator]();
```

### Valeur de retour

Une fonction d'itération sur le tableau typé, par défaut, c'est la fonction `values()`.

Exemples
--------

### Parcourir un tableau typé avec `for...of`


```js
var arr = new Uint8Array([10, 20, 30, 40, 50]);
// prérequis : le navigateur doit supporter les boucles
// for..of et les variables dont la portée est définie
// par let
for (let n of arr) {
  console.log(n);
}
```

### Autre méthode d'itération


```js
var arr = new Uint8Array([10, 20, 30, 40, 50]);
var eArr = arr[Symbol.iterator]();
console.log(eArr.next().value); // 10
console.log(eArr.next().value); // 20
console.log(eArr.next().value); // 30
console.log(eArr.next().value); // 40
console.log(eArr.next().value); // 50
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype-@@iterator |

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

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

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

* Les tableaux typés en JavaScript
* `TypedArray`
* `TypedArray.prototype.entries()`
* `TypedArray.prototype.keys()`
* `TypedArray.prototype.values()`
TypedArray.prototype.every()
============================

La méthode **`every()`** teste si tous les éléments du tableau typé satisfont une condition implémentée par la fonction de test fournie. Cette méthode utilise le même algorithme `Array.prototype.every()`. Pour le reste de cet article, *TypedArray* correspond à un des types de tableaux typés.

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

Syntaxe
-------


```js
typedarray.every(callback[, thisArg])>
```

### Paramètres

`callback`

La fonction utilisée pour tester chaque élément du tableau. Elle utilise trois arguments :

`valeurCourante`

L'élément du tableau typé qui est en cours de traitement.

`index`

L'indice de l'élément du tableau typé en cours de traitement.

`array`

Le tableau typé sur lequel on a appelé la méthode `every`.


`thisArg`

Paramètre optionnel, la valeur à utiliser en tant que `this` lors de l'exécution de `callback`.

### Valeur de retour

`true` si la fonction de rappel obtient une valeur équivalente à vrai (*truthy*) pour chaque élément du tableau typé, `false` sinon.

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

La méthode `every` exécute la fonction `callback` fournie pour chaque élément du tableau typé jusqu'à ce que `callback` renvoie une valeur fausse (une valeur qui vaut `false` lorsqu'elle est convertie en un booléen). Si un tel élément est trouvé, la méthode `every` renvoie immédiatement `false`. Dans le cas contraire, si `callback` renvoie une valeur vraie pour tous les éléments, la méthode `every` renverra `true`.

`callback` est appelé avec trois arguments : la valeur de l'élément, l'indice de cet élément et le tableau qui est parcouru.

Si le paramètre `thisArg` est utilisé, il sera passé à la fonction `callback` en tant que valeur `this`. Sinon, la valeur `undefined` sera utilisée comme valeur `this`. La valeur `this` définitivement prise en compte par la fonction `callback` est déterminée selon les règles usuelles de détermination de `this`.

`every` ne modifie pas le tableau typé sur lequel elle a été appelée.

Exemples
--------

### Tester la taille des éléments d'un tableau typé

Dans l'exemple suivant, on teste si tous les éléments du tableau typé sont supérieurs à 10 :


```js
function estGrand(element, index, array) {
  return element >= 10;
}
new Uint8Array([12, 5, 8, 130, 44]).every(estGrand); // false
new Uint8Array([12, 54, 18, 130, 44]).every(estGrand); // true
```

### Tester les éléments d'un tableau typé avec les fonctions fléchées

Les fonctions fléchées permettent d'utiliser une syntaxe plus concise pour parvenir au même résultat :


```js
new Uint8Array([12, 5, 8, 130, 44]).every((elem) => elem >= 10); // false
new Uint8Array([12, 54, 18, 130, 44]).every((elem) => elem >= 10); // true
```

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

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

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

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

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

* `TypedArray.prototype.some()`
* `Array.prototype.every()`
get TypedArray[@@species]
=========================

La propriété d'accesseur **`TypedArray[@@species]`** renvoie le constructeur du tableau typé.

Syntaxe
-------


```js
TypedArray[Symbol.species];
```


où TypedArray vaut :

* `Int8Array`
* `Uint8Array`
* `Uint8ClampedArray`
* `Int16Array`
* `Uint16Array`
* `Int32Array`
* `Uint32Array`
* `Float32Array`
* `Float64Array`
Description
-----------

L'accesseur `species` renvoie le constructeur par défaut pour les tableaux typés. Les constructeurs des sous-classes peuvent surcharger ce symbole pour modifier l'affectation du constructeur.

Exemples
--------

La propriété `species` renvoie le constructeur par défaut qui est l'un des constructeurs de tableau typé (selon le type de tableau typé de l'objet) :


```js
Int8Array[Symbol.species]; // function Int8Array()
Uint8Array[Symbol.species]; // function Uint8Array()
Float32Array[Symbol.species]; // function Float32Array()
```


Pour un objet construit sur mesure (par exemple une tableau `MonTableauTypé`), le symbole `species` de `MonTableauTypé` sera le constructeur `MonTableauTypé`. Mais on peut vouloir surcharger ce comportement pour renvoyer le constructeur du type parent :


```js
class MonTableauTypé extends Uint8Array {
  // On surcharge species pour MonTableauTypé
  // pour récupérer le constructeur Uint8Array
  static get [Symbol.species]() {
    return Uint8Array;
  }
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-%typedarray%-@@species |

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

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

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

* `TypedArray`
* `Symbol.species`
TypedArray.prototype.at()
=========================

La méthode **`at()`** prend comme argument un entier et renvoie l'élément du tableau typé situé à cette position. Il est possible d'utiliser des entiers positifs et négatifs. Si l'argument est négatif, la position est relative à la fin du tableau.

L'accès aux éléments d'un tableau typé en utilisant les crochets ne permet que d'utiliser des indices positifs : `typedarray[0]` renverra le premier élément, `typedarray[typedarray.length-1]` renverra le dernier. Avec `typedarray.at(-1)`, on peut avoir une écriture plus concise pour accéder au dernier élément. Voir les exemples ci-après.

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

Syntaxe
-------


```js
at(indice);
```

### Paramètres

`indice`

L'indice (c'est-à-dire la position) de l'élément du tableau typé qu'on souhaite récupérer. Il est possible d'utiliser des valeurs négatives pour récupérer un élément en comptant depuis la fin du tableau.

### Valeur de retour

L'élément du tableau typé situé à l'indice indiqué. Si aucune valeur ne peut être trouvé à l'indice donné, c'est `undefined` qui est renvoyé.

Exemples
--------

### Renvoyer la dernière valeur d'un tableau typé

L'exemple qui suit fournit une fonction qui renvoie le dernier élément trouvé dans le tableau typé donné.


```js
const uint8 = new Uint8Array([1, 2, 4, 7, 11, 18]);

// Une fonction qui renvoie le dernier élément
function returnLast(arr) {
  return arr.at(-1);
}

const lastItem = returnLast(uint8);
console.log(lastItem); // Affiche 18 dans la console
```

### Comparaison de méthodes

On compare ici différentes façons d'accéder à l'avant-dernier élément d'un tableau typé (`TypedArray`). Bien que toutes les méthodes présentées ici soient valides et équivalentes, on pourra noter la concision et la lisibilité de la méthode `at()`.


```js
// Le tableau typé de départ
const uint8 = new Uint8Array([1, 2, 4, 7, 11, 18]);

// En utilisant la propriété length
const avecLength = uint8[uint8.length - 2];
console.log(avecLength); // Affiche 11 dans la console

// En utilisant la méthode slice()
// qui renvoie un tableau
const avecSlice = uint8.slice(-2, -1);
console.log(avecSlice[0]); // Affiche 11 dans la console

// En utilisant la méthode at()
const avecAt = uint8.at(-2);
console.log(avecAt); // Affiche 11 dans la console
```

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

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

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

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

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

* `TypedArray.prototype.find()` qui renvoie une valeur selon un test donné.
* `TypedArray.prototype.includes()` qui teste si une valeur existe dans un tableau typé.
* `TypedArray.prototype.indexOf()` qui renvoie l'indice d'un élément donné dans le tableau typé.
* Prothèses d'émulation (*polyfills*)
    + Prothèse présentée dans la proposition TC39 pour at().
    + `core-js`
Math.log1p()
============

La fonction **`Math.log1p()`** renvoie le logarithme népérien (en base `e`) d'un nombre +1, donné par la formule :



∀
x
>
-
1
,

Math.log1p
(
x
)

=
ln
(
1
+
x
)

\forall x > -1, \mathtt{\operatorname{Math.log1p}(x)} = \ln(1 + x)

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

Syntaxe
-------


```js
Math.log1p(x);
```

### Paramètres

`x`

Un nombre.

### Valeur de retour

La valeur du logarithme naturel de 1 plus l'argument (`log(1 + x`)). Si l'argument est inférieur à `-1`, `NaN` est renvoyée.

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

Si `x` est strictement inférieur à -1, la valeur renvoyée est `NaN`.

`log1p` étant une méthode statique de `Math`, il faut utiliser `Math.log1p()` et non pas la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).

Exemple
-------

### Utiliser `Math.log1p()`


```js
Math.log1p(1); // 0.6931471805599453
Math.log1p(0); // 0
Math.log1p(-1); // -Infinity
Math.log1p(-2); // NaN
```

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

Si cette fonction n'est pas disponible, elle peut être définie grâce au code suivant :


```js
Math.log1p =
  Math.log1p ||
  function (x) {
    return Math.log(1 + x);
  };
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.log1p |

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

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

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

* `Math.exp()`
* `Math.log()`
* `Math.log10()`
* `Math.log2()`
* `Math.pow()`