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
201
202
203
204
|
---
title: Float32Array
slug: Web/JavaScript/Reference/Global_Objects/Float32Array
tags:
- Constructor
- JavaScript
- TypedArray
- TypedArrays
translation_of: Web/JavaScript/Reference/Global_Objects/Float32Array
---
<div>{{JSRef}}</div>
<p>Das <strong><code>Float32Array</code></strong> getypte Array repräsentiert ein Array von 32 Bit Gleitkommazahlen (entspricht dem C Datengyp <code>float</code>) in der Plattform-Byte-Reihenfolge. Wenn Kontrolle über die Byte-Reihenfolge erforderlich ist, muss {{jsxref("DataView")}} stattdessen benutz werden. Die Inhalte werden mit <code>0</code> initialisiert. Wie erwartet, kann man Element in einem Array mit Objektmethoden referenzieren oder man benutzt die normale Arrayindex-Syntax (das ist die Klammernotation).</p>
<h2 id="Syntax">Syntax</h2>
<pre class="syntaxbox">new Float32Array(); // new in ES2017
new Float32Array(length);
new Float32Array(typedArray);
new Float32Array(object);
new Float32Array(buffer [, byteOffset [, length]]);</pre>
<p>Für mehr Informationen über die Konstruktorensyntax und die Parameter, siehe auf der Seite <em><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#Syntax">TypedArray</a></em>.</p>
<h2 id="Eigenschaften">Eigenschaften</h2>
<dl>
<dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Float32Array.BYTES_PER_ELEMENT")}}</dt>
<dd>Gibt die Größe der Elemente zurück. <code>4</code> im Falle eines <code>Float32Array</code>.</dd>
<dt>Float32Array.length</dt>
<dd>Statische Längeneigenschaft welche den Wert 0 hat. Für die aktuelle Länge (Anzahl der Elemente) siehe {{jsxref("TypedArray.prototype.length", "Float32Array.prototype.length")}}.</dd>
<dt>{{jsxref("TypedArray.name", "Float32Array.name")}}</dt>
<dd>Gibt den Stringwert des Konstruktornamens zurück. In Fall eines <code>Float32Array</code> Typs: <code>"Float32Array"</code>.</dd>
<dt>{{jsxref("TypedArray.prototype", "Float32Array.prototype")}}</dt>
<dd>Prototyp für das <em>TypedArray</em> Objekt.</dd>
</dl>
<h2 id="Methoden">Methoden</h2>
<dl>
<dt>{{jsxref("TypedArray.from", "Float32Array.from()")}}</dt>
<dd>Erstelle ein neues <code>Float32Array</code> von einem Array-Ähnlichen oder Iterable Objekt. Siehe auch {{jsxref("Array.from()")}}.</dd>
<dt>{{jsxref("TypedArray.of", "Float32Array.of()")}}</dt>
<dd>Erstellt ein neues <code>Float32Array</code> mit einer variablen Anzahl an Argumenten. Sie auch {{jsxref("Array.of()")}}.</dd>
</dl>
<h2 id="Float32Array_Prototyp"><code>Float32Array</code> Prototyp</h2>
<p>Alle <code>Float32Array</code> Objekte erben von {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p>
<h3 id="Eigenschaften_2">Eigenschaften</h3>
<dl>
<dt><code>Float32Array.prototype.constructor</code></dt>
<dd>Gibt die Funktion, die einen Instanzprototyp erstellt zurück. Diese ist auf den <code>Float32Array</code> Konstruktor voreingestellt.</dd>
<dt>{{jsxref("TypedArray.prototype.buffer", "Float32Array.prototype.buffer")}} {{readonlyInline}}</dt>
<dd>Gibt die {{jsxref("ArrayBuffer")}} Referenz zurück, welche nach der Erstellung eines <code>Float32Array</code> fest ist und nicht mehr geändert werden kann.</dd>
<dt>{{jsxref("TypedArray.prototype.byteLength", "Float32Array.prototype.byteLength")}} {{readonlyInline}}</dt>
<dd>Gibt die Länge (in Bytes) des <code>Float32Array</code> vom Anfang seines {{jsxref("ArrayBuffer")}} zurück. WIrd beim erstellen festgesetzt und kann nicht geändert werden.</dd>
<dt>{{jsxref("TypedArray.prototype.byteOffset", "Float32Array.prototype.byteOffset")}} {{readonlyInline}}</dt>
<dd>Gibt das Offset (in Bytes) des <code>Float32Array</code> vom Anfang seines {{jsxref("ArrayBuffer")}} zurück. WIrd beim erstellen festgesetzt und kann nicht geändert werden.</dd>
<dt>{{jsxref("TypedArray.prototype.length", "Float32Array.prototype.length")}} {{readonlyInline}}</dt>
<dd>Gibt Anzahl der Elemente des <code>Float32Array</code> zurück. WIrd beim erstellen festgesetzt und kann nicht geändert werden.</dd>
</dl>
<h3 id="Methoden_2">Methoden</h3>
<dl>
<dt>{{jsxref("TypedArray.copyWithin", "Float32Array.prototype.copyWithin()")}}</dt>
<dd>Kopiert eine Sequenz von Arrayelementen in das Array. Siehe auch {{jsxref("Array.prototype.copyWithin()")}}.</dd>
<dt>{{jsxref("TypedArray.entries", "Float32Array.prototype.entries()")}}</dt>
<dd>Gibt ein neues <code>Array Iterator</code> Objekt zurück, welches die Schlüssel/Wertepaare für jeden Index im Array enthält. Siehe auch {{jsxref("Array.prototype.entries()")}}.</dd>
<dt>{{jsxref("TypedArray.every", "Float32Array.prototype.every()")}}</dt>
<dd>Teste, ob alle Elemente einem, als Funktion übergebenen, Test erfüllen. Siehe auch Array.prototype.every()")}}.</dd>
<dt>{{jsxref("TypedArray.fill", "Float32Array.prototype.fill()")}}</dt>
<dd>Füllt alle Elemente eines Arrays vom Startindex bis zum Endindex mit einem statischen Wert. Siehe auch {{jsxref("Array.prototype.fill()")}}.</dd>
<dt>{{jsxref("TypedArray.filter", "Float32Array.prototype.filter()")}}</dt>
<dd>Erstellt ein neues Array mit allen Elementen des alten Arrays, für die eine übergebene Filterfunktion <code>true</code> zurückgibt. Siehe auch {{jsxref("Array.prototype.filter()")}}.</dd>
<dt>{{jsxref("TypedArray.find", "Float32Array.prototype.find()")}}</dt>
<dd>Gibt ein gefundenes Element des Arrays zurück, welches bei der übergebenen Testfunktion <code>true</code> zurückgibt oder <code>undefined</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.find()")}}.</dd>
<dt>{{jsxref("TypedArray.findIndex", "Float32Array.prototype.findIndex()")}}</dt>
<dd>Gibt den Index eines gefundenen Elements des Arrays zurück, welches bei der übergebenen Testfunktion <code>true</code> zurückgibt oder <code>-1</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.findIndex()")}}.</dd>
<dt>{{jsxref("TypedArray.forEach", "Float32Array.prototype.forEach()")}}</dt>
<dd>Ruft für jedes Element in einem Array eine Funktion auf. Siehe auch {{jsxref("Array.prototype.forEach()")}}.</dd>
<dt>{{jsxref("TypedArray.includes", "Float32Array.prototype.includes()")}} {{experimental_inline}}</dt>
<dd>Überprüft, ob ein getyptes Array ein bestimmtes Element enthält und gibt gegebenfalls <code>true</code> oder<code>false</code> zurück. Siehe auch {{jsxref("Array.prototype.includes()")}}.</dd>
<dt>{{jsxref("TypedArray.indexOf", "Float32Array.prototype.indexOf()")}}</dt>
<dd>Gibt den ersten Index eines Elementes zurück, welches gleiche eines spezifizierten Wertes ist oder <code>-1</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.indexOf()")}}.</dd>
<dt>{{jsxref("TypedArray.join", "Float32Array.prototype.join()")}}</dt>
<dd>Führt alle Elemente eines Arrays zu einem String zusammen. Siehe auch {{jsxref("Array.prototype.join()")}}.</dd>
<dt>{{jsxref("TypedArray.keys", "Float32Array.prototype.keys()")}}</dt>
<dd>Gibt ein neuen <code>Array Iterator</code> zurück, der alle Schlüssel für jeden Index im Array enthält. Siehe auch {{jsxref("Array.prototype.keys()")}}.</dd>
<dt>{{jsxref("TypedArray.lastIndexOf", "Float32Array.prototype.lastIndexOf()")}}</dt>
<dd>Gibt den letzen Index eines Elementes zurück, welches gleiche eines spezifizierten Wertes ist oder <code>-1</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.lastIndexOf()")}}.</dd>
<dt>{{jsxref("TypedArray.map", "Float32Array.prototype.map()")}}</dt>
<dd>Erstellt ein neues Array mit den Resultaten spezifizierten Funktion, die für jedes Element aufgerufen wird. Siehe auch {{jsxref("Array.prototype.map()")}}.</dd>
<dt>{{jsxref("TypedArray.move", "Float32Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt>
<dd>Ehemalige nicht Standardisierte Version von {{jsxref("TypedArray.copyWithin", "Float32Array.prototype.copyWithin()")}}.</dd>
<dt>{{jsxref("TypedArray.reduce", "Float32Array.prototype.reduce()")}}</dt>
<dd>Führt eine Funktion gegeben einen Akkumulator und jeden Wert des Array aus (von links nach rechts), um das Array auf einen Wert zu reduzieren. Siehe auch {{jsxref("Array.prototype.reduce()")}}.</dd>
<dt>{{jsxref("TypedArray.reduceRight", "Float32Array.prototype.reduceRight()")}}</dt>
<dd>Führt eine Funktion gegeben einen Akkumulator und jeden Wert des Array aus (von rechts nach links), um das Array auf einen Wert zu reduzieren. Siehe auch {{jsxref("Array.prototype.reduce()")}}.</dd>
<dt>{{jsxref("TypedArray.reverse", "Float32Array.prototype.reverse()")}}</dt>
<dd>Kehrt die Reihenfolge von jedem Element eines Arrays um — das Erste wird das Letzte und das Letzte wird das Erste. Siehe auch {{jsxref("Array.prototype.reverse()")}}.</dd>
<dt>{{jsxref("TypedArray.set", "Float32Array.prototype.set()")}}</dt>
<dd>Speichert mehrere Werte in einem getypten Array und ließt Eingabewerte aus einem spezifiziertem Array.</dd>
<dt>{{jsxref("TypedArray.slice", "Float32Array.prototype.slice()")}}</dt>
<dd>Extrahiert einen Bereich aus einem Array und gibt diesen in einem neuen Array zurück. Siehe auch {{jsxref("Array.prototype.slice()")}}.</dd>
<dt>{{jsxref("TypedArray.some", "Float32Array.prototype.some()")}}</dt>
<dd>Gibt <code>true</code> zurück, wenn nur ein Element in einem Array den als Funktion übergebenen Test erfüllt. Siehe auch {{jsxref("Array.prototype.some()")}}</dd>
<dt>{{jsxref("TypedArray.sort", "Float32Array.prototype.sort()")}}</dt>
<dd>Sortiert die Elemente eines Arrays in-Place und gibt das Array zurück. Siehe auch {{jsxref("Array.prototype.sort()")}}.</dd>
<dt>{{jsxref("TypedArray.subarray", "Float32Array.prototype.subarray()")}}</dt>
<dd>Gibt ein neues <code>Float32Array</code> vom gegebenen Start- und Endindex zurück.</dd>
<dt>{{jsxref("TypedArray.values", "Float32Array.prototype.values()")}}</dt>
<dd>Gibt ein neues <code>Array Iterator</code> Objekt zurück, welches die Werte von jedem Index im Array enthält. Siehe auch {{jsxref("Array.prototype.values()")}}.</dd>
<dt>{{jsxref("TypedArray.toLocaleString", "Float32Array.prototype.toLocaleString()")}}</dt>
<dd>Gibt einen Ortsabhängige Stringrepräsentation des Arrays und seiner Element zurück. Siehe auch {{jsxref("Array.prototype.toLocaleString()")}}.</dd>
<dt>{{jsxref("TypedArray.toString", "Float32Array.prototype.toString()")}}</dt>
<dd>Gibt einen Stringrepräsentation des Arrays und seiner Element zurück. Siehe auch {{jsxref("Array.prototype.toString()")}}.</dd>
<dt>{{jsxref("TypedArray.@@iterator", "Float32Array.prototype[@@iterator]()")}}</dt>
<dd>Gibt ein neues <code>Array Iterator</code> Objekt zurück, welches die zugehörigen Werte für jeden Index im Array enthalten.</dd>
</dl>
<h2 id="Beispiele">Beispiele</h2>
<p>Verschiedene Wege, um ein <code>Float32Array</code> zu erstellen:</p>
<pre class="brush: js">// From a length
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
// From an array
var arr = new Float32Array([21,31]);
console.log(arr[1]); // 31
// From another TypedArray
var x = new Float32Array([21, 31]);
var y = new Float32Array(x);
console.log(y[0]); // 21
// From an ArrayBuffer
var buffer = new ArrayBuffer(16);
var z = new Float32Array(buffer, 0, 4);
// From an iterable
var iterable = function*(){ yield* [1,2,3]; }();
var float32 = new Float32Array(iterable);
// Float32Array[1, 2, 3]
</pre>
<h2 id="Spezifikationen">Spezifikationen</h2>
<table class="standard-table">
<tbody>
<tr>
<th scope="col">Spezifikation</th>
<th scope="col">Status</th>
<th scope="col">Kommentar</th>
</tr>
<tr>
<td>{{SpecName('Typed Array')}}</td>
<td>{{Spec2('Typed Array')}}</td>
<td>Ersetzt in ECMAScript 2015.</td>
</tr>
<tr>
<td>{{SpecName('ES6', '#table-49', 'TypedArray constructors')}}</td>
<td>{{Spec2('ES6')}}</td>
<td>Initiale Definition in einem ECMA Standard. Spezifiziert, dass ein <code>new</code> benötigt wird.</td>
</tr>
<tr>
<td>{{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}}</td>
<td>{{Spec2('ESDraft')}}</td>
<td>ECMAScript 2017 ändert den <code>Float32Array</code> Konstruktor, um die <code>ToIndex</code> Operation zu benutzen und erlaubt einen Konstruktor ohne Parameter.</td>
</tr>
</tbody>
</table>
<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
<p>{{Compat("javascript.builtins.Float32Array")}}</p>
<h2 id="Kompatibilitätshinweise">Kompatibilitätshinweise</h2>
<p>Mit Beginn von ECMAScript 2015, müssen <code>Float32Array</code> Konstruktoren mit einem {{jsxref("Operators/new", "new")}} benutzt werden. Der Aufruf eines <code>Float32Array</code> Konstruktors als eine Funktion ohne <code>new</code>, Führt jetzt zu einem {{jsxref("TypeError")}}.</p>
<pre class="brush: js example-bad">var dv = Float32Array([1, 2, 3]);
// TypeError: calling a builtin Float32Array constructor
// without new is forbidden</pre>
<pre class="brush: js example-good">var dv = new Float32Array([1, 2, 3]);</pre>
<h2 id="Siehe_auch">Siehe auch</h2>
<ul>
<li><a href="/de/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript getypte Arrays</a></li>
<li>{{jsxref("ArrayBuffer")}}</li>
<li>{{jsxref("DataView")}}</li>
</ul>
|
