---
title: Float32Array
slug: Web/JavaScript/Reference/Global_Objects/Float32Array
translation_of: Web/JavaScript/Reference/Global_Objects/Float32Array
---
<div>{{JSRef}}</div>

<p>A array tipada <strong><code>Float32Array</code></strong> representa uma array de 32-bits contendo floats (correspondendo ao tipo de dados <code>float</code> em C) na ordem dos bytes da plataforma. Se o controle sobre a ordem dos bytes for precisa, use {{jsxref("DataView")}}. Os conteúdos iniciam em <code>0</code>. Uma vez estabelecido, você pode referenciar os elementos na array usando os métodos do objeto ou usando a síntaxe padrão das arrays (Isto é, usando colchetes)</p>

<h2 id="Síntaxe">Síntaxe</h2>

<pre class="syntaxbox">new Float32Array(); // novo no ES2017
new Float32Array(length);
new Float32Array(typedArray);
new Float32Array(object);
new Float32Array(buffer [, byteOffset [, length]]);</pre>

<p>Para mais informações sobre a síntaxe de construção e os parâmetros, veja <em><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#Syntax">TypedArray</a></em>.</p>

<h2 id="Propriedades">Propriedades</h2>

<dl>
 <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Float32Array.BYTES_PER_ELEMENT")}}</dt>
 <dd>Retorna um número valor do tamanho do elemento. <code>4</code> no caso de uma <code>Float32Array</code>.</dd>
 <dt>Float32Array.length</dt>
 <dd>Método estático cujo o valor é <code>0</code>. Para o tamanho atual (número de elementos), veja {{jsxref("TypedArray.prototype.length", "Float32Array.prototype.length")}}.</dd>
 <dt>{{jsxref("TypedArray.name", "Float32Array.name")}}</dt>
 <dd>Retorna o valor em string do nome do constructor. No caso de <code>Float32Array</code> é  "Float32Array".</dd>
 <dt>{{jsxref("TypedArray.prototype", "Float32Array.prototype")}}</dt>
 <dd>Prototype para os objetos <em>TypedArray</em>.</dd>
</dl>

<h2 id="Métodos">Métodos</h2>

<dl>
 <dt>{{jsxref("TypedArray.from", "Float32Array.from()")}}</dt>
 <dd>Cria uma nova <code>Float32Array</code> de um array-like ou um objeto iterável. Veja também {{jsxref("Array.from()")}}.</dd>
 <dt>{{jsxref("TypedArray.of", "Float32Array.of()")}}</dt>
 <dd>Cria uma nova <code>Float32Array</code> with um número variável de argumentos. Veja também {{jsxref("Array.of()")}}.</dd>
</dl>

<h2 id="Float32Array_prototype"><code>Float32Array</code> prototype</h2>

<p>Todos os objetos <code>Float32Array</code> herdam de {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p>

<h3 id="Propriedades_2">Propriedades</h3>

<dl>
 <dt><code>Float32Array.prototype.constructor</code></dt>
 <dd>Retorna a função cujo criou o protótipo da instância. Este é o construtor padrão da Array <code>Float32Array</code>.</dd>
 <dt>{{jsxref("TypedArray.prototype.buffer", "Float32Array.prototype.buffer")}} {{readonlyInline}}</dt>
 <dd>Retorna os {{jsxref("ArrayBuffer")}} referenciado pela Array <code>Float32Array</code> fixada na hora de sua construção e é <strong>somente leitura</strong>.</dd>
 <dt>{{jsxref("TypedArray.prototype.byteLength", "Float32Array.prototype.byteLength")}} {{readonlyInline}}</dt>
 <dd>Retorna o tamanho (em bytes) da Array <code>Float32Array</code> do começo de seu {{jsxref("ArrayBuffer")}}. Fixado na hora de sua construção e é <strong>somente leitura</strong>.</dd>
 <dt>{{jsxref("TypedArray.prototype.byteOffset", "Float32Array.prototype.byteOffset")}} {{readonlyInline}}</dt>
 <dd>Retorna o deslocamento (em bytes) da Array <code>Float32Array</code> do começo de seu {{jsxref("ArrayBuffer")}}. Fixado na hora de sua construção e é <strong>somente leitura</strong>.</dd>
 <dt>{{jsxref("TypedArray.prototype.length", "Float32Array.prototype.length")}} {{readonlyInline}}</dt>
 <dd>Retorna o número de elementos na Array <code>Float32Array</code> do começo de seu {{jsxref("ArrayBuffer")}}. Fixado na hora de sua construção e é <strong>somente leitura</strong>.</dd>
</dl>

<h3 id="Métodos_2">Métodos</h3>

<dl>
 <dt>{{jsxref("TypedArray.copyWithin", "Float32Array.prototype.copyWithin()")}}</dt>
 <dd>Copia a sequência dos elementos dentro da Array. Veja também {{jsxref("Array.prototype.copyWithin()")}}.</dd>
 <dt>{{jsxref("TypedArray.entries", "Float32Array.prototype.entries()")}}</dt>
 <dd>Retorna um novo objeto <code>Array Iterator</code> que contém os pares chave/valor para cada índex na array. Veja também {{jsxref("Array.prototype.entries()")}}.</dd>
 <dt>{{jsxref("TypedArray.every", "Float32Array.prototype.every()")}}</dt>
 <dd>Testa quando todos os elementos na array passam no teste proveniente de uma função. Veja também {{jsxref("Array.prototype.every()")}}.</dd>
 <dt>{{jsxref("TypedArray.fill", "Float32Array.prototype.fill()")}}</dt>
 <dd>Preenche todos os elementos de uma array do índex inicial ao índex final com um valor estático. Veja também {{jsxref("Array.prototype.fill()")}}.</dd>
 <dt>{{jsxref("TypedArray.filter", "Float32Array.prototype.filter()")}}</dt>
 <dd>Cria uma nova array com todos os elementos dessa array para a função de filtragem que retornar <code>true</code>. Veja também {{jsxref("Array.prototype.filter()")}}.</dd>
 <dt>{{jsxref("TypedArray.find", "Float32Array.prototype.find()")}}</dt>
 <dd>Retorna o valor na array encontrado, se um elemento na array satizfaz o teste proveniente de uma função de teste ou <code>undefined</code> se não for encontrado. Veja também {{jsxref("Array.prototype.find()")}}.</dd>
 <dt>{{jsxref("TypedArray.findIndex", "Float32Array.prototype.findIndex()")}}</dt>
 <dd>Retorna o index encontrado na array,  se um elemento na array satizfaz o teste proveniente de uma função de teste ou -1 se não for encontrado. Veja também {{jsxref("Array.prototype.findIndex()")}}.</dd>
 <dt>{{jsxref("TypedArray.forEach", "Float32Array.prototype.forEach()")}}</dt>
 <dd>Chama uma função para cada elemento na array. Veja também {{jsxref("Array.prototype.forEach()")}}.</dd>
 <dt>{{jsxref("TypedArray.includes", "Float32Array.prototype.includes()")}} {{experimental_inline}}</dt>
 <dd>Determina quando a array tipada inclui um certo elemento, retornando <code>true</code> ou <code>false</code> como apropriado. Veja também {{jsxref("Array.prototype.includes()")}}.</dd>
 <dt>{{jsxref("TypedArray.indexOf", "Float32Array.prototype.indexOf()")}}</dt>
 <dd>Retorna o primeiro (menor) index de um elemento dentro de uma array igual ao valor expecificado, ou -1 se nenhum for encontrado. Veja também {{jsxref("Array.prototype.indexOf()")}}.</dd>
 <dt>{{jsxref("TypedArray.join", "Float32Array.prototype.join()")}}</dt>
 <dd>Junta todos os elementos de uma array em uma string. Veja também {{jsxref("Array.prototype.join()")}}.</dd>
 <dt>{{jsxref("TypedArray.keys", "Float32Array.prototype.keys()")}}</dt>
 <dd>Retorna um novo <code>Array Iterator</code> cujo contem as chaves para cada index na array. Veja também {{jsxref("Array.prototype.keys()")}}.</dd>
 <dt>{{jsxref("TypedArray.lastIndexOf", "Float32Array.prototype.lastIndexOf()")}}</dt>
 <dd>Retorna o último (maior) índex de um elemento dentro da array igual ao valor especificado, ou -1 se nenhum for encontrado. Veja também {{jsxref("Array.prototype.lastIndexOf()")}}.</dd>
 <dt>{{jsxref("TypedArray.map", "Float32Array.prototype.map()")}}</dt>
 <dd>Cria uma nova array com os resultados da função chamada em cada elemento nesta array. Veja também {{jsxref("Array.prototype.map()")}}.</dd>
 <dt>{{jsxref("TypedArray.move", "Float32Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt>
 <dd>Versão antiga não padrão de {{jsxref("TypedArray.copyWithin", "Float32Array.prototype.copyWithin()")}}.</dd>
 <dt>{{jsxref("TypedArray.reduce", "Float32Array.prototype.reduce()")}}</dt>
 <dd>Aplica uma função contra um acumulador e cada valor na array (da esquerda para a direita) com o intuito de reduzí-la a um único valor. Veja também {{jsxref("Array.prototype.reduce()")}}.</dd>
 <dt>{{jsxref("TypedArray.reduceRight", "Float32Array.prototype.reduceRight()")}}</dt>
 <dd>Aplica uma função contra um acumulador e cada valor na array (da direita para a esquerda) como o intuito de reduzí-la a um único valor. See also {{jsxref("Array.prototype.reduceRight()")}}.</dd>
 <dt>{{jsxref("TypedArray.reverse", "Float32Array.prototype.reverse()")}}</dt>
 <dd>Reverte a ordem se todos os elementos em uma array - o primeiro se torna o último, e o último de torna o primeiro. Veja também {{jsxref("Array.prototype.reverse()")}}.</dd>
 <dt>{{jsxref("TypedArray.set", "Float32Array.prototype.set()")}}</dt>
 <dd>Armazena múltiplos valores na array tipada, lendo os valores de entrada de uma array especificada.</dd>
 <dt>{{jsxref("TypedArray.slice", "Float32Array.prototype.slice()")}}</dt>
 <dd>Extrai uma seção de uma array e retorna uma nova array. Veja também {{jsxref("Array.prototype.slice()")}}.</dd>
 <dt>{{jsxref("TypedArray.some", "Float32Array.prototype.some()")}}</dt>
 <dd>Retorna true se pelo menos um elemento nesta array satisfazer a função de teste proveniente de uma função de teste. Veja também {{jsxref("Array.prototype.some()")}}.</dd>
 <dt>{{jsxref("TypedArray.sort", "Float32Array.prototype.sort()")}}</dt>
 <dd>Classifica os elementos de uma array no lugar e retorna a array. Veja também {{jsxref("Array.prototype.sort()")}}.</dd>
 <dt>{{jsxref("TypedArray.subarray", "Float32Array.prototype.subarray()")}}</dt>
 <dd>Retorna uma nova Array <code>Float32Array</code> a partir de um ponto inicial e um fim pelo índex do elemento.</dd>
 <dt>{{jsxref("TypedArray.values", "Float32Array.prototype.values()")}}</dt>
 <dd>Retorna um novo objeto <code>Array Iterator</code> que contém os valores para cada índex na Array. Veja também {{jsxref("Array.prototype.values()")}}.</dd>
 <dt>{{jsxref("TypedArray.toLocaleString", "Float32Array.prototype.toLocaleString()")}}</dt>
 <dd>Retorna uma string localizada representando a array e seus elementos. Veja também {{jsxref("Array.prototype.toLocaleString()")}}.</dd>
 <dt>{{jsxref("TypedArray.toString", "Float32Array.prototype.toString()")}}</dt>
 <dd>Retorna uma string representando a array e seus elementos. Veja também {{jsxref("Array.prototype.toString()")}}.</dd>
 <dt>{{jsxref("TypedArray.@@iterator", "Float32Array.prototype[@@iterator]()")}}</dt>
 <dd>Retorna um novo objeto <code>Array Iterator</code> que contém os valores para cada índex na Array.</dd>
</dl>

<h2 id="Exemplos">Exemplos</h2>

<p>Diferentes modos de criar uma Array <code>Float32Array</code>:</p>

<pre class="brush: js">// Pelo seu tamanho
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

// Por uma array
var arr = new Float32Array([21,31]);
console.log(arr[1]); // 31

// Por uma outra TypedArray
var x = new Float32Array([21, 31]);
var y = new Float32Array(x);
console.log(y[0]); // 21

// Por um ArrayBuffer
var buffer = new ArrayBuffer(16);
var z = new Float32Array(buffer, 0, 4);

// Por um iterável
var iterable = function*(){ yield* [1,2,3]; }();
var float32 = new Float32Array(iterable);
// Float32Array[1, 2, 3]
</pre>

<h2 id="Especificações">Especificações</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Especificação</th>
   <th scope="col">Status</th>
   <th scope="col">Comment</th>
  </tr>
  <tr>
   <td>{{SpecName('Typed Array')}}</td>
   <td>{{Spec2('Typed Array')}}</td>
   <td>Suplantada pelo ECMAScript 2015.</td>
  </tr>
  <tr>
   <td>{{SpecName('ES6', '#table-49', 'TypedArray constructors')}}</td>
   <td>{{Spec2('ES6')}}</td>
   <td>Definição inicial no padrão ECMA. Especificado que o <code>new</code> é requerido.</td>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}}</td>
   <td>{{Spec2('ESDraft')}}</td>
   <td>O ECMAScript 7 mudou o construtor da Array <code>Array32Float</code> para o uso da operação <code>ToIndex</code> e ajudar nos construtores sem argumentos.</td>
  </tr>
 </tbody>
</table>

<h2 id="Browser_compatibility">Compatibilidade com navegadores</h2>

<p>{{Compat("javascript.builtins.Float32Array")}}</p>

<h2 id="Notas_de_compatibilidade">Notas de compatibilidade</h2>

<p>Começando com o ECMAScript 2015, construtores da Array <code>Float32Array</code> requerem o uso do operador {{jsxref("Operators/new", "new")}}. Chamando o construtor da Array <code>Float32Array</code> como uma função, sem o <code>new</code>, irá gerar um erro {{jsxref("TypeError")}} de agora em diante.</p>

<pre class="brush: js example-bad">var dv = Float32Array([1, 2, 3]);

// TypeError: chamando o construtor da função interna Float32Array
// sem o new é proibido</pre>

<pre class="brush: js example-good">var dv = new Float32Array([1, 2, 3]);</pre>

<h2 id="Veja_também">Veja também</h2>

<ul>
 <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript arrays tipadas</a></li>
 <li>{{jsxref("ArrayBuffer")}}</li>
 <li>{{jsxref("DataView")}}</li>
</ul>