---
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>