Uint16Array
===========

Le tableau typé **`Uint16Array`** permet de représenter un tableau d'entiers non signés représentés sur 16 bits, où l'ordre des octets correspond à celui de la plateforme utilisée. Si on souhaite contrôler l'ordre des octets utilisé (le « boutisme »), on utilisera un objet `DataView` à la place. Les éléments du tableau sont initialisés à `0`. Une fois que le tableau est construit, on peut manipuler ses différents éléments grâce aux méthodes de l'objet ou grâce à la notation usuelle (avec les crochets).

Syntaxe
-------


```js
new Uint16Array(); // apparu avec ES2017
new Uint16Array(longueur);
new Uint16Array(tableauTypé);
new Uint16Array(objet);
new Uint16Array(tampon [, décalage [, longueur]]);
```


Pour plus d'informations sur la syntaxe du constructeur et le rôle des différents paramètres, voir la page *TypedArray*.

Propriétés
----------

`Uint16Array.BYTES_PER_ELEMENT`

Cette propriété renvoie un nombre correspondant à la quantité d'octets pour un élément du tableau. Dans le cas d'`Uint16Array`, ce sera `2`.

`Uint16Array.length`

La propriété de longueur statique qui vaut 3. Pour connaître le nombre d'élément, voir `Uint16Array.prototype.length`.

`Uint16Array.name`

Cette propriété renvoie la chaîne de caractères correspondant au nom du constructeur. Pour `Uint16Array` ce sera : "Uint16Array".

`Uint16Array.prototype` (en-US)

Le prototype des objets *TypedArray*.

Méthodes
--------

`Uint16Array.from()`

Cette méthode permet de créer un `Uint16Array` à partir d'un itérable ou d'un objet semblable à un tableau. Voir aussi `Array.from()`.

`Uint16Array.of()`

Cette méthode permet de créer un Uint16Array à partir d'un nombre variable d'arguments. Voir aussi `Array.of()`.

Prototype `Uint16Array`
-----------------------

Tous les objets `Uint16Array` héritent de `%TypedArray%.prototype` (en-US).

### Propriétés

`Uint16Array.prototype.constructor`

Cette propriété renvoie la fonction qui a créé l'instance du prototype. Par défaut, ce sera le constructeur `Uint16Array`.

`Uint16Array.prototype.buffer` Lecture seule 

Cette propriété renvoie l'objet `ArrayBuffer` référencé par l'objet `Uint16Array` Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**.

`Uint16Array.prototype.byteLength` Lecture seule 

Cette propriété renvoie la longueur, exprimée en octets, de l'objet `Uint16Array` à partir du début de l'objet `ArrayBuffer` correspondant. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**.

`Uint16Array.prototype.byteOffset` Lecture seule 

Cette propriété renvoie le décalage, en nombre d'octets, entre le début du tableau typé courant et du début du `ArrayBuffer` correspondant. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**.

`Uint16Array.prototype.length` Lecture seule 

Cette propriété renvoie le nombre d'éléments contenus dans le tableau `Uint16Array`. Elle est déterminée lors de la construction et est accessible uniquement en **lecture seule**.

### Méthodes

`Uint16Array.prototype.copyWithin()`

Copie une suite d'éléments d'un tableau dans le tableau. Voir également `Array.prototype.copyWithin()`.

`Uint16Array.prototype.entries()`

Renvoie un nouvel objet `Array Iterator` qui contient les paires clé/valeur pour chaque indice du tableau. Voir également `Array.prototype.entries()`.

`Uint16Array.prototype.every()`

Teste si l'ensemble des éléments du tableau remplissent une certaine condition donnée par une fonction de test. Voir également `Array.prototype.every()`.

`Uint16Array.prototype.fill()`

Remplit les éléments d'un tableau avec une certaine valeur pour les éléments compris entre un indice de début et un indice de fin. Voir également `Array.prototype.fill()`.

`Uint16Array.prototype.filter()`

Crée un nouveau tableau dont tous les éléments proviennent de ce tableau et respectent une condition fournie par une fonction de test. Voir également `Array.prototype.filter()`.

`Uint16Array.prototype.find()`

Renvoie une valeur trouvée dans le tableau s'il existe un élément du tableau qui satisfait une condition fournie par une fonction de test, s'il n'y a pas de tel élément `undefined` sera renvoyé. Voir également `Array.prototype.find()`.

`Uint16Array.prototype.findIndex()`

Renvoie l'indice d'un élément qui satisfait une condition fournie par une fonction de test, si aucun élément ne remplit la condition -1 sera renvoyé. Voir également `Array.prototype.findIndex()`.

`Uint16Array.prototype.forEach()`

Appelle une fonction pour chacun des élément du tableau. Voir également `Array.prototype.forEach()`.

`Uint16Array.prototype.includes()`

Détermine si le tableau typé contient un élément donné. Cette méthode renvoie `true` ou `false` selon le cas de figure. Voir également `Array.prototype.includes()`.

`Uint16Array.prototype.indexOf()`

Renvoie le premier indice (le plus petit) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également `Array.prototype.indexOf()`.

`Uint16Array.prototype.join()`

Fusionne l'ensemble des éléments du tableau en une chaîne de caractères. Voir également `Array.prototype.join()`.

`Uint16Array.prototype.keys()`

Renvoie un nouvel objet `Array Iterator` qui contient les clés de chaque indice du tableau. Voir également `Array.prototype.keys()`.

`Uint16Array.prototype.lastIndexOf()`

Renvoie le dernier indice (le plus élevé) d'un élément du tableau qui est égal à la valeur fournie. Si aucun élément ne correspond, la valeur -1 sera renvoyée. Voir également `Array.prototype.lastIndexOf()`.

`Uint16Array.prototype.map()`

Crée un nouveau tableau dont les éléments sont les images des éléments du tableau courant par une fonction donnée. Voir également `Array.prototype.map()`.

`Uint16Array.prototype.move()` 
Non-standard
 Non implémenté

Ancienne version, non-standard, de `Uint16Array.prototype.copyWithin()`.

`Uint16Array.prototype.reduce()`

Applique une fonction sur un accumulateur et chaque élément du tableau (de gauche à droite) afin de réduire le tableau en une seule valeur. Voir également `Array.prototype.reduce()`.

`Uint16Array.prototype.reduceRight()`

Applique une fonction sur un accumulateur et chaque élément du tableau (de droite à gauche) afin de réduire le tableau en une seule valeur. Voir également `Array.prototype.reduceRight()`.

`Uint16Array.prototype.reverse()`

Inverse l'ordre des éléments d'un tableau. Le premier élément du tableau devient le dernier et le dernier devient le premier (et ainsi de suite). Voir également `Array.prototype.reverse()`.

`Uint16Array.prototype.set()`

Enregistre plusieurs valeurs dans le tableau typé à partir de valeurs d'un autre tableau.

`Uint16Array.prototype.slice()`

Extrait un fragment d'un tableau et renvoie ce fragment. Voir également `Array.prototype.slice()`.

`Uint16Array.prototype.some()`

Renvoie `true` si au moins un des éléments remplit une condition donnée par une fonction de test. Voir également `Array.prototype.some()`.

`Uint16Array.prototype.sort()`

Trie les éléments du tableau et renvoie ce tableau. Voir également `Array.prototype.sort()`.

`Uint16Array.prototype.subarray()`

Renvoie un nouvel objet `Uint16Array` qui est le fragment du tableau courant, entre les indices de début et de fin donnés.

`Uint16Array.prototype.values()`

Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau. Voir également `Array.prototype.values()`.

`Uint16Array.prototype.toLocaleString()`

Renvoie une chaîne de caractères localisée qui représente le tableau et ses éléments. Voir également `Array.prototype.toLocaleString()`.

`Uint16Array.prototype.toString()`

Renvoie une chaîne de caractère qui représente le tableau et ses éléments. Voir également `Array.prototype.toString()`.

`Uint16Array.prototype[@@iterator]()`

Renvoie un nouvel objet `Array Iterator` qui contient les valeurs correspondantes à chaque indice du tableau.

Exemples
--------

Différentes façons de créer un objet `Uint16Array` :


```js
// Construction à partir d'une longueur
var uint16 = new Uint16Array(2);
uint16[0] = 42;
console.log(uint16[0]); // 42
console.log(uint16.length); // 2
console.log(uint16.BYTES\_PER\_ELEMENT); // 2

// Construction à partir d'un tableau
var arr = new Uint16Array([21, 31]);
console.log(arr[1]); // 31

// Construction à partir d'un tableau typé
var x = new Uint16Array([21, 31]);
var y = new Uint16Array(x);
console.log(y[0]); // 21

// Construction à partir d'un ArrayBuffer
var buffer = new ArrayBuffer(8);
var z = new Uint16Array(buffer, 0, 4);

// Construction à partir d'un itérable
var iterable = (function\* () {
  yield\* [1, 2, 3];
})();
var uint16 = new Uint16Array(iterable);
// Uint16Array[1, 2, 3]
```

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

| Specification |
| --- |
| ECMAScript Language Specification # table-49 |

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
* `ArrayBuffer`
* `DataView`