1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
---
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="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2>
<div class="hidden">A tabela de compatibilidade nesta pagina é gerada por dados estruturados. Se você quiser contribuir com os dados, por favor veja The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos mande um pull request.</div>
<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>
|
