Float32Array
============

Le tableau typé **`Float32Array`** représente un tableau de nombres flottants représentés sur 32 bits (ce qui correspond au type C `float`), l'ordre des octets utilisés étant celui de la plate-forme. Si on souhaite maîtriser le boutisme (*endianness*) utilisé, on pourra utiliser une `DataView`. Les éléments du tableau sont initialisés à `0`. Une fois que le tableau est établi, on peut référencer des éléments dans le tableau en utilisant les méthodes de l'objet ou la syntaxe usuelle des crochets.

Syntaxe
-------


```js
new Float32Array(); // Apparu avec ES2017
new Float32Array(longueur);
new Float32Array(tableauTypé);
new Float32Array(objet);
new Float32Array(buffer [, décalageOctets [, longueur]]);
```


Pour plus d'informations sur la syntaxe de ce constructeur et les paramètres utilisés, voir la page `TypedArray`.

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

`Float32Array.BYTES_PER_ELEMENT`

Renvoie le nombre d'octets par élément. `4` dans le cas de `Float32Array`.

Float32Array.length

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

`Float32Array.name`

Renvoie la chaîne de caractères correspondant au nom du constructeur, dans le cas de `Float32Array`, ce sera : "Float32Array".

`Float32Array.prototype` (en-US)

Le prototype des objets *TypedArray*.

Méthodes
--------

`Float32Array.from()`

Crée un nouvel objet `Float32Array` à partir d'un objet semblable à un tableau ou d'un objet itérable. Voir également la page `Array.from()`.

`Float32Array.of()`

Crée un nouvel objet `Float32Array` à partir d'un nombre variable d'arguments. Voir également la page `Array.of()`.

Prototype `Float32Array`
------------------------

Chacun des objets `Float32Array` hérite de `%TypedArray%.prototype` (en-US).

### Propriétés

`Float32Array.prototype.constructor`

Renvoie la fonction qui a crée le prototype de l'instance. Par défaut, ce sera le constructeur `Float32Array`.

`Float32Array.prototype.buffer` Lecture seule 

Renvoie l'objet `ArrayBuffer` référencé par l'objet `Float32Array`. Cette propriété est fixée lors de la construction et n'est donc disponible qu'en **lecture seule**.

`Float32Array.prototype.byteLength` Lecture seule 

Renvoie la longueur, exprimée en octets, de l'objet `Float32Array` à partir du début de l'`ArrayBuffer` correspondant. Cette propriété est fixée lors de la construction et n'est donc disponible qu'en **lecture seule**.

`Float32Array.prototype.byteOffset` Lecture seule 

Renvoie le décalage, exprimé en octets, de l'objet `Float32Array` par rapport au début de l'`ArrayBuffer` correspondant. Cette propriété est fixée lors de la construction et n'est donc disponible qu'en **lecture seule**.

`Float32Array.prototype.length` Lecture seule 

Renvoie le nombre d'éléments contenus dans l'objet `Float32Array`. Cette propriété est fixée lors de la construction et n'est donc disponible qu'en **lecture seule**.

### Méthodes

`Float32Array.prototype.copyWithin()`

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

`Float32Array.prototype.entries()`

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

`Float32Array.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()`.

`Float32Array.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()`.

`Float32Array.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()`.

`Float32Array.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()`.

`Float32Array.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()`.

`Float32Array.prototype.forEach()`

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

`Float32Array.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()`.

`Float32Array.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()`.

`Float32Array.prototype.join()`

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

`Float32Array.prototype.keys()`

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

`Float32Array.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()`.

`Float32Array.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()`.

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

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

`Float32Array.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()`.

`Float32Array.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()`.

`Float32Array.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()`.

`Float32Array.prototype.set()`

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

`Float32Array.prototype.slice()`

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

`Float32Array.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()`.

`Float32Array.prototype.sort()`

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

`Float32Array.prototype.subarray()`

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

`Float32Array.prototype.values()`

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

`Float32Array.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()`.

`Float32Array.prototype.toString()`

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

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


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

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

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

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

// Construction à partir d'un itérable
var iterable = (function\* () {
  yield\* [1, 2, 3];
})();
var float32 = new Float32Array(iterable);
// Float32Array[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.

Notes de compatibilité
----------------------

À partir d'ECMAScript 2015 (ES6), `Float32Array` doit être utilisée avec `new`. Appeler un constructeur `Float32Array` comme une fonction, sans `new`, provoquera une exception `TypeError`.


```js
var dv = Float32Array([1, 2, 3]);
// TypeError: calling a builtin Float32Array constructor
// without new is forbidden
```



```js
var dv = new Float32Array([1, 2, 3]);
```

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

* Les tableaux typés en JavaScript
* `ArrayBuffer`
* `DataView`