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

La méthode **`lastIndexOf()`** renvoie le dernier indice (le plus grand) pour lequel un élément donné est trouvé. Si l'élément cherché n'est pas trouvé, la valeur de retour sera -1. Le tableau typé est parcouru dans l'ordre des indices décroissants (de la fin vers le début) à partir de `indexDépart`. Cette méthode utilise le même algorithme que `Array.prototype.lastIndexOf()`. Dans le reste de l'article, *TypedArray* correspond à l'un des types de tableaux typés.

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

Syntaxe
-------


```js
typedarray.lastIndexOf(élémentRecherché[, indiceDépart = typedarray.length])
```

### Paramètres

`élémentRecherché`

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

`indiceDépart`

Paramètre optionnel qui représente l'indice à partir duquel parcourir le tableau dans le sens inverse. La valeur par défaut correspond à la longueur du tableau (c'est-à-dire que tout le tableau sera parcouru). Si l'indice est supérieur ou égal à la longueur du tableau typé, tout le tableau typé sera parcouru. Si la valeur est négative, le parcours commencera à `length+indiceDépart` (le sens de parcours ne change pas). Si l'indice calculé est négatif, la valeur de retour sera -1 et le tableau ne sera pas parcouru.

### Valeur de retour

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

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

`lastIndexOf` compare `élémentRecherché` avec les é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, 2]);
uint8.lastIndexOf(2); // 3
uint8.lastIndexOf(7); // -1
uint8.lastIndexOf(2, 3); // 3
uint8.lastIndexOf(2, 2); // 0
uint8.lastIndexOf(2, -2); // 0
uint8.lastIndexOf(2, -1); // 3
```

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

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

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

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

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

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

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

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

Syntaxe
-------


```js
typedarray.reduce(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 `reduce` 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
-----------

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

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]).reduce(function (a, b) {
  return a + b;
});
// total == 6
```

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

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

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

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

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

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

La propriété **`buffer`** est un accesseur représentant l'`ArrayBuffer` représenté par le *TypedArray* lors de la construction de l'objet.

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

Syntaxe
-------


```js
typedArray.buffer;
```

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

La propriété `buffer` est un accesseur dont le mutateur correspondant vaut `undefined`. Cela signifie que cette propriété n'est accessible qu'en lecture seule. La valeur de la propriété est déterminée lors de la construction du *TypedArray* et ne peut pas être modifiée. *TypedArray* est un des objets TypedArray.

Exemples
--------


```js
var buffer = new ArrayBuffer(8);
var uint16 = new Uint16Array(buffer);
uint16.buffer; // ArrayBuffer { byteLength: 8 }
```

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

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

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

La propriété **`byteOffset`** est un accesseur qui représente le décalage, exprimé en octets, entre le début du tableau typé par rapport au début du `ArrayBuffer` correspondant.

Syntaxe
-------


```js
typedarray.byteOffset;
```

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

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

Exemples
--------


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

var uint8 = new Uint8Array(tampon);
uint8.byteOffset; // 0 (aucun décalage n'a été défini)

var uint8 = new Uint8Array(tampon, 3);
uint8.byteOffset; // 3 (correspond au décalage défini lors de la construction du Uint8Array)
```

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

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

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()
==============================

La méthode **`entries()`** renvoie un nouvel objet `Array Iterator` qui contient les paires clé/valeur pour chaque indice du tableau.

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

Syntaxe
-------


```js
arr.entries();
```

### Valeur de retour

Un nouvel objet `Array Iterator`.

Exemples
--------

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


```js
var arr = new Uint8Array([10, 20, 30, 40, 50]);
var eArray = arr.entries();
// prérequis nécessaire : 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.entries();
console.log(eArr.next().value); // [0, 10]
console.log(eArr.next().value); // [1, 20]
console.log(eArr.next().value); // [2, 30]
console.log(eArr.next().value); // [3, 40]
console.log(eArr.next().value); // [4, 50]
```

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

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

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.keys()`
* `TypedArray.prototype.values()`
* `TypedArray.prototype[@@iterator]()`
TypedArray.prototype.toString()
===============================

La méthode **`toString()`** renvoie une chaîne de caractères qui représente le tableau typé et ses éléments. Cette méthode utilise le même algorithme que `Array.prototype.toString()`*.* Dans la suite de cet article, *TypedArray* fait référence à l'un des types de tableau typé listés ici.

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

Syntaxe
-------


```js
typedarray.toString();
```

### Valeur de retour

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

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

Les objets `TypedArray` surchargent la méthode `toString` de `Object`. Pour les objets `TypedArray`, la méthode `toString` fusionne le tableau et renovoie une chaîne de caractères contenant les éléments du tableau, chacun séparés par une virgule. Par exemple :


```js
var numbers = new Uint8Array([2, 5, 8, 1, 4]);
numbers.toString(); // "2,5,8,1,4"
```


JavaScript appelle automatiquement la méthode `toString()` lorsqu'un tableau typé doit être manipulé sous une forme textuelle (par exemple lorsqu'il est utilisé avec une chaîne de caractères dans une concaténation).

### Compatibilité

Si un navigateur ne prend pas encore en charge la méthode `TypedArray.prototype.toString()`, le moteur JavaScript utilisera la méthode `toString` rattachée à `Object` :


```js
var numbers = new Uint8Array([2, 5, 8, 1, 4]);
numbers.toString(); // "[object Uint8Array]"
```

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

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

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

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

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

* `TypedArray.prototype.join()`
TypedArray.prototype.set()
==========================

La méthode **`set()`** permet d'enregistrer plusieurs valeurs dans le tableau typé à partir d'un tableau donné.

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

Syntaxe
-------


```js
typedArr.set(tableau [, décalage])
typedArr.set(tableauTypé [, décalage])
```

### Paramètres

`tableau`

Le tableau à partir duquel on copie les valeurs. Toutes les valeurs du tableau source seront copiées dans le tableau cible sauf si la longueur du tableau cible est trop courte en fonction du décalage défini et de la longueur du tableau source : dans ce cas, un exception sera renvoyée.

`tableauTypé`

Si le tableau source est un tableau typé, il se peut que les deux tableaux partagent le même `ArrayBuffer` ; le moteur effectuera alors une copie intelligente entre le tableau source et le tableau ciblé.

`décalage` Facultatif

Le décalage, exprimé en nombre d'éléments, à partir duquel copier les valeurs du tableau source dans le tableau cible. Si le paramètre n'est pas utilisé, la valeur par défaut sera 0 (ce qui correspond au cas où les éléments seront copiés au début du tableau).

### Valeur de retour

`undefined`.

### Exceptions

`RangeError`

Cette exception est renvoyée lorsque le `décalage` est tel que des valeurs seraient enregistrées en dehors du tableau typé.

Exemples
--------


```js
var buffer = new ArrayBuffer(8);
var uint8 = new Uint8Array(buffer);

uint8.set([1, 2, 3], 3);

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

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

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

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`
* `ArrayBuffer`
TypedArray.prototype.fill()
===========================

La méthode **`fill()`** remplit les éléments d'un tableau typé contenu entre un indice de début et un indice de fin avec une valeur statique. Cette méthode utilise le même algorithme que `Array.prototype.fill()`. Dans le reste de cet article, *TypedArray* correspond à l'un des types de tableaux typés.

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

Syntaxe
-------


```js
typedarray.fill(valeur[, début = 0[, fin = this.length]])
```

### Paramètres

`valeur`

La valeur avec laquelle on souhaite remplir le tableau.

`début`

Paramètre optionnel qui représente l'indice à partir duquel remplir le tableau. La valeur par défaut est 0.

`fin`

Paramètre optionnel qui représente l'indice jusqu'auquel remplir le tableau. La valeur par défaut est la longueur du tableau (`this.length`).

### Valeur de retour

Le tableau typé, modifié par la fonction.

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

L'intervalle d'éléments à modifier est [`début`, `fin`).

La méthode **`fill`** utilise jusqu'à trois arguments : `valeur`, `début` et `fin`. `début` et `fin` sont optionnels, leurs valeurs par défaut respectives sont `0` et la valeur de la propriété `length` de l'objet `this`.

Si `début` est négatif, on le traite comme `length+début` où `length` représente la longueur du tableau. Si `fin` est négative, on le traite comme `length+fin`.

Exemples
--------


```js
new Uint8Array([1, 2, 3]).fill(4); // Uint8Array [4, 4, 4]
new Uint8Array([1, 2, 3]).fill(4, 1); // Uint8Array [1, 4, 4]
new Uint8Array([1, 2, 3]).fill(4, 1, 2); // Uint8Array [1, 4, 3]
new Uint8Array([1, 2, 3]).fill(4, 1, 1); // Uint8Array [1, 2, 3]
new Uint8Array([1, 2, 3]).fill(4, -3, -2); // Uint8Array [4, 2, 3]
```

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

Il n'existe pas d'objet global avec le nom *TypedArray*, la prothèse doit donc être appliquée uniquement si nécessaire, aussi `Array.prototype.fill()` pourra éventuellement être utilisé (voire la prothèse de cette dernière).


```js
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.fill
if (!Uint8Array.prototype.fill) {
  Uint8Array.prototype.fill = Array.prototype.fill;
}
```

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

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

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

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

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

* `Array.prototype.fill()`
TypedArray.prototype.values()
=============================

La méthode **`values()`** renvoie un nouvel objet `Array Iterator` qui contient les valeurs pour chaque indice du tableau.

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

Syntaxe
-------


```js
typedArr.values();
```

### Valeur de retour

Un nouvel objet `Array Iterator`.

Exemples
--------

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


```js
var arr = new Uint8Array([10, 20, 30, 40, 50]);
var eArray = arr.values();
// 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.values();
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.values |

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[@@iterator]()`
TypedArray.prototype.join()
===========================

La méthode **`join()`** fusionne l'ensemble des éléments d'un tableau en une chaîne de caractères. Cette méthode utilise le même algorithme que `Array.prototype.join()`. Dans le reste de cet article *TypedArray* fait référence à l'un des types de tableaux typés.

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

Syntaxe
-------


```js
typedarray.join([(séparateur = ",")]);
```

### Paramètres

`séparateur`

Paramètre optionnel qui définit la chaîne de caractères à utiliser pour séparer chaque élément. Si nécessaire, le séparateur sera converti en une chaîne de caractère. La valeur par défaut du paramètre est une virgule (",").

### Valeur de retour

Une chaîne de caractères formée par la concaténation des différents éléments du tableau typé.

Exemples
--------


```js
var uint8 = new Uint8Array([1, 2, 3]);
uint8.join(); // '1,2,3'
uint8.join(" / "); // '1 / 2 / 3'
uint8.join(""); // '123'
```

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

Il n'existe pas d'objet global *TypedArray*, il faut donc ajouter une prothèse correspondant à chaque type de tableau typé.


```js
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.join
if (!Uint8Array.prototype.join) {
  Object.defineProperty(Uint8Array.prototype, "join", {
    value: Array.prototype.join,
  });
}
```


Mieux vaut ne pas ajouter de prothèses pour `TypedArray.prototype` si le moteur JavaScript ne prend pas en charge `Object.defineProperty()` car on ne peut pas les rendre non-énumérables.

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

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

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

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

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

* `TypedArray`
* `Array.prototype.join()`
TypedArray.prototype.byteLength
===============================

La propriété **`byteLength`** est un accesseur qui représente la longueur, exprimée en octets, du tableau typé à partir du début de l'`ArrayBuffer` correspondant.

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

Syntaxe
-------


```js
typedarray.byteLength;
```

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

La propriété `byteLength` 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 l'objet *TypedArray* n'utilise pas de `byteOffset` ou une `length`, ce sera la propriété `length` de l'`ArrayBuffer` référencé par le tableau qui sera renvoyée. *TypedArray* est l'un des objets TypedArray.

Exemples
--------


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

var uint8 = new Uint8Array(tampon);
uint8.byteLength; // 8 (correspond au byteLength du tampon correspondant)

var uint8 = new Uint8Array(tampon, 1, 5);
uint8.byteLength; // 5 (correspond à la longueur spécifiée dans le constructeur)

var uint8 = new Uint8Array(tampon, 2);
uint8.byteLength; // 6 (en raison du décalage utilisé pour la construction du Uint8Array)
```

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

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

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.BYTES\_PER\_ELEMENT
==============================

La propriété **`TypedArray.BYTES_PER_ELEMENT`** représente la taille, exprimée en octets, de chaque élément du tableau typé.

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

| Attributs de `TypedArray.BYTES_PER_ELEMENT` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Non |

Syntaxe
-------


```js
TypedArray.BYTES\_PER\_ELEMENT;
```

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

La taille des éléments d'un tableau typé varie en fonction du type de `TypedArray` utilisé. Le nombre d'octets utilisé pour un élément sera différent en fonction du type de tableau. La propriété `BYTES_PER_ELEMENT` permet de savoir le nombre d'octets contenus dans chaque élément du tableau typé courant.

Exemples
--------


```js
Int8Array.BYTES\_PER\_ELEMENT; // 1
Uint8Array.BYTES\_PER\_ELEMENT; // 1
Uint8ClampedArray.BYTES\_PER\_ELEMENT; // 1
Int16Array.BYTES\_PER\_ELEMENT; // 2
Uint16Array.BYTES\_PER\_ELEMENT; // 2
Int32Array.BYTES\_PER\_ELEMENT; // 4
Uint32Array.BYTES\_PER\_ELEMENT; // 4
Float32Array.BYTES\_PER\_ELEMENT; // 4
Float64Array.BYTES\_PER\_ELEMENT; // 8
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-typedarray.bytes\_per\_element |

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.copyWithin()
=================================

La méthode **`copyWithin()`** permet de copier des éléments d'un tableau dans le tableau typé à partir de la position `cible`. Les éléments copiés sont ceux contenus entre les index `début` et `fin`. L'argument `fin` est optionnel, sa valeur par défaut correspondra à la longueur du tableau dont on souhaite copier les éléments. Cette méthode utilise le même algorithme que `Array.prototype.copyWithin`*.* *TypedArray* est l'un des types de tableaux typés.

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

Syntaxe
-------


```js
typedarray.copyWithin(cible, début[, fin = this.length])
```

### Paramètres

`cible`

La position, dans le tableau typé, à partir de laquelle on souhaite copier les éléments.

`début`

La position du tableau contenant les éléments à copier à partir de laquelle copier les éléments.

`fin Facultatif`

Paramètre optionnel. La position jusqu'à laquelle prendre les éléments à copier.

### Valeur de retour

Le tableau typé, modifié par la fonction.

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

Voir la page `Array.prototype.copyWithin` pour plus d'informations.

Cette méthode remplace la méthode expérimentale `TypedArray.prototype.move()`.

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 ]
uint8.copyWithin(3, 0, 3);
console.log(uint8); // Uint8Array [ 1, 2, 3, 1, 2, 3, 0, 0 ]
```

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

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

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

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

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

* `TypedArray`