new Float32Array() — Methode · JavaScript-Referenz

Signatur

new Float32Array(lengthOrSourceOrBuffer, byteOffset, length)

Beschreibung

Der Konstruktor Float32Array() erzeugt ein typisiertes Array, dessen Elemente 32-Bit-Gleitkommazahlen (4 Bytes pro Element) in der Byte-Reihenfolge der Plattform sind. Solche Arrays sind die Standarddatenstruktur für WebGL/WebGPU (Vertex-Daten, Matrizen), die Web Audio API (Samples im Bereich -1…1) und numerische Berechnungen, bei denen Speicherbedarf und Durchsatz wichtiger sind als die volle Genauigkeit von Float64Array.

Der Konstruktor lässt sich auf mehrere Arten aufrufen:

new Float32Array() bzw. new Float32Array(length): legt ein neues, mit 0 initialisiertes Array der angegebenen Länge an.
new Float32Array(typedArray): kopiert die Werte eines anderen typisierten Arrays und wandelt sie dabei in Float32 um.
new Float32Array(object): übernimmt Werte aus einem iterierbaren oder array-ähnlichen Objekt (z. B. einem normalen Array oder Set).
new Float32Array(buffer, byteOffset, length): erzeugt eine Sicht auf einen vorhandenen ArrayBuffer oder SharedArrayBuffer – es wird nichts kopiert, Änderungen wirken sich direkt auf den Puffer aus.

Alle Werte werden beim Schreiben auf die nächstgelegene darstellbare 32-Bit-Gleitkommazahl gerundet. Dadurch entstehen Abweichungen wie 0.1 → 0.10000000149011612. Die Länge eines Float32Array ist nach der Erzeugung fest (außer bei längenverfolgenden Sichten auf größenveränderliche Puffer).

Parameter

Name	Typ	Default	Beschreibung
$length	number	0	Anzahl der Elemente bei Aufruf mit einer Zahl. Es werden `length * 4` Bytes reserviert und mit `0` gefüllt.
$typedArray	TypedArray		Beliebiges typisiertes Array (außer `BigInt64Array`/`BigUint64Array`), dessen Werte in ein neues Array kopiert und in Float32 umgewandelt werden.
$object	Iterable\|ArrayLike		Iterierbares oder array-ähnliches Objekt, dessen Werte mit `Number()`-Semantik übernommen werden.
$buffer	ArrayBuffer\|SharedArrayBuffer		Vorhandener Puffer, auf den eine Sicht ohne Kopie erzeugt wird.
$byteOffset	number	0	Byte-Position im `buffer`, an der die Sicht beginnt. Muss ein Vielfaches von `4` sein, sonst `RangeError`.
$length	number	bis zum Pufferende	Anzahl der Elemente (nicht Bytes) der Sicht, wenn ein `buffer` übergeben wird.

Rückgabewert

Typ

Float32Array

Beschreibung

Ein neues Float32Array-Objekt. Bei Übergabe eines Puffers teilt es sich den Speicher mit diesem.

Beispiele

Varianten der Erzeugung

const leer = new Float32Array(3);
const ausArray = new Float32Array([1.5, 2.25, 0.1]);
const ausSet = new Float32Array(new Set([4, 5]));

console.log(leer);          // mit Nullen gefüllt
console.log(ausArray[2]);   // Rundung auf 32 Bit
console.log(ausSet.length, ausArray.BYTES_PER_ELEMENT);

Float32Array(3) [0, 0, 0] 0.10000000149011612 2 4

Sicht auf einen ArrayBuffer (ohne Kopie)

const buffer = new ArrayBuffer(16); // Platz für 4 Floats
const alle = new Float32Array(buffer);
const hinten = new Float32Array(buffer, 8, 2); // ab Byte 8, 2 Elemente

hinten[0] = 3.5;
console.log(alle); // gemeinsamer Speicher
console.log(hinten.byteOffset, hinten.length);

Float32Array(4) [0, 0, 3.5, 0] 8 2

Vertex-Daten für WebGL vorbereiten

const canvas = document.createElement('canvas');
const gl = canvas.getContext('webgl');

// Dreieck: x, y pro Eckpunkt
const vertices = new Float32Array([
   0.0,  0.5,
  -0.5, -0.5,
   0.5, -0.5,
]);

const vbo = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW);
console.log(`${vertices.byteLength} Bytes hochgeladen`);

24 Bytes hochgeladen

Audio-Samples erzeugen (Sinuston)

const sampleRate = 44100;
const dauer = 0.01; // Sekunden
const samples = new Float32Array(Math.round(sampleRate * dauer));

for (let i = 0; i < samples.length; i++) {
  samples[i] = Math.sin(2 * Math.PI * 440 * (i / sampleRate));
}

console.log(samples.length, samples[0]);

441 0

// Wichtig · Fallstricke

Nur mit new: Ein Aufruf als Funktion (Float32Array([1])) wirft einen TypeError.
Genauigkeit: Float32 hat nur ca. 7 signifikante Dezimalstellen. Ganzzahlen über 2²⁴ (16 777 216) lassen sich nicht mehr exakt darstellen – für Geldbeträge oder IDs ungeeignet.
Ausrichtung: byteOffset muss durch 4 teilbar sein, und bei fehlendem length muss die restliche Pufferlänge ebenfalls ein Vielfaches von 4 sein – sonst RangeError.
Kopie vs. Sicht: Ein übergebenes TypedArray wird kopiert, ein ArrayBuffer dagegen geteilt. Für eine Sicht auf ein anderes typisiertes Array new Float32Array(ta.buffer, ta.byteOffset, …) verwenden.
Byte-Reihenfolge: Es gilt die Endianness der Plattform (praktisch immer Little-Endian). Für Netzwerk- oder Dateiformate mit fester Reihenfolge DataView.prototype.getFloat32() nutzen.
Werte außerhalb des Bereichs werden zu Infinity; NaN bleibt erhalten, nicht-numerische Werte werden zu NaN.
BigInt-Arrays können nicht als Quelle dienen (TypeError).
Seit ES2024 können Sichten auf größenveränderliche ArrayBuffer ohne length der Puffergröße automatisch folgen (moderne Browser, Node.js 20+).

Siehe auch

Float32Array Float64Array ArrayBuffer DataView TypedArray.from() Math.fround() Float16Array