Signatur
Beschreibung
Float64Array ist ein typisiertes Array (TypedArray), das eine Folge von 64-Bit-Gleitkommazahlen (entsprechend dem C-Typ double bzw. dem IEEE-754-Standard für doppelte Genauigkeit) im Speicher ablegt. Jedes Element belegt exakt 8 Byte. Die Byte-Reihenfolge richtet sich nach der Plattform (in der Praxis fast immer Little-Endian auf x86/x64-Systemen).
Float64Array eignet sich überall dort, wo maximale Gleitkomma-Präzision benötigt wird – zum Beispiel für wissenschaftliche Berechnungen, Signalverarbeitung, 3-D-Grafik mit hoher Genauigkeit oder die Verarbeitung von Koordinaten-Datensätzen. Gegenüber normalen JavaScript-Arrays bietet es einen deutlich geringeren Speicher-Overhead und ermöglicht durch den festen Typ effizientere CPU-nahe Operationen.
Wie alle TypedArrays teilt Float64Array einen zugrunde liegenden ArrayBuffer. Mehrere TypedArray-Views können denselben Buffer referenzieren, was Zero-Copy-Datenübergaben – etwa an WebGL, Web Audio oder Worker.postMessage() – ermöglicht. Die Klasse erbt alle Methoden von %TypedArray%.prototype (z. B. map, filter, reduce, set, subarray).
Beim Schreiben von Werten, die außerhalb des darstellbaren Bereichs liegen, speichert Float64Array Infinity, -Infinity oder NaN, wie es der IEEE-754-Standard vorschreibt. Integer-Werte bis 253−1 werden verlustfrei gespeichert; für noch größere ganze Zahlen ist BigInt64Array die bessere Wahl.
Parameter
| Name | Typ | Default | Beschreibung |
|---|---|---|---|
| $length | number | Anzahl der Elemente (nicht Bytes). Erstellt einen neuen, mit Nullen initialisierten Buffer der Größe length × 8 Byte. |
|
| $typedArray | TypedArray | Ein anderes typisiertes Array, dessen Werte kopiert und in float64 konvertiert werden. |
|
| $object | Array|Iterable | Ein Array-ähnliches oder iterierbares Objekt; dessen Elemente werden in float64 konvertiert und kopiert. |
|
| $buffer | ArrayBuffer|SharedArrayBuffer | Ein existierender Puffer, der als Backing-Store verwendet wird. Optionale Parameter byteOffset und length steuern den sichtbaren Ausschnitt. |
|
| $byteOffset | number | 0 | Byte-Offset innerhalb des übergebenen buffer, ab dem die View beginnt. Muss ein Vielfaches von 8 sein. |
| $length | number | Anzahl der Elemente der View innerhalb des übergebenen buffer (ab byteOffset). |
Rückgabewert
Float64Array-Instanz, die auf einen ArrayBuffer zeigt und die angeforderten 64-Bit-Gleitkommazahlen enthält.Beispiele
Grundlegende Verwendung: Erstellen und Befüllen
// Array mit 4 Elementen, alle initial 0
const arr = new Float64Array(4);
arr[0] = 3.141592653589793;
arr[1] = 2.718281828459045;
arr[2] = 1.4142135623730951;
arr[3] = -Infinity;
console.log(arr[0]); // 3.141592653589793
console.log(arr.byteLength); // 32 (4 × 8 Byte)
console.log(arr.length); // 4
console.log([...arr]);Aus bestehendem Array erstellen und mit TypedArray-Methoden arbeiten
const rohdaten = [1.1, 2.2, 3.3, 4.4, 5.5];
const f64 = new Float64Array(rohdaten);
// Summe per reduce
const summe = f64.reduce((acc, val) => acc + val, 0);
console.log('Summe:', summe);
// Jeden Wert quadrieren
const quadriert = f64.map(x => x ** 2);
console.log('Quadriert:', [...quadriert]);
// Subarray-View (kein Kopieren)
const mitte = f64.subarray(1, 4);
console.log('Mitte:', [...mitte]);Geteilter ArrayBuffer zwischen mehreren Views
// Einen Buffer für 3 float64-Werte anlegen
const buffer = new ArrayBuffer(24); // 3 × 8 Byte
const view1 = new Float64Array(buffer);
const view2 = new Float64Array(buffer, 8, 2); // ab Byte 8, 2 Elemente
view1[0] = 100.0;
view1[1] = 200.0;
view1[2] = 300.0;
// view2 zeigt auf dieselben Bytes wie view1[1] und view1[2]
console.log([...view2]); // [ 200, 300 ]
// Schreiben über view2 ändert auch view1
view2[0] = 999.9;
console.log(view1[1]); // 999.9// Wichtig · Fallstricke
Byte-Reihenfolge: Float64Array verwendet stets die native Byte-Reihenfolge der Plattform. Für portable Binärdaten (z. B. Netzwerkprotokolle) sollte stattdessen DataView mit expliziten getFloat64/setFloat64-Aufrufen verwendet werden, die Little- oder Big-Endian erzwingen können.
Präzision: Float64Array entspricht dem normalen JavaScript-Typ number (IEEE 754 double). Im Gegensatz dazu rundet Float32Array auf 32 Bit – das spart Speicher, reduziert aber die Genauigkeit erheblich.
Kein Sparse Array: Nicht zugewiesene Elemente sind immer 0, nicht undefined. TypedArrays können weder Löcher noch nicht-numerische Schlüssel enthalten.
Transfer zu Web Workern: Ein zugrunde liegender ArrayBuffer kann per postMessage transferiert (nicht kopiert) werden, was ihn im ursprünglichen Kontext unzugänglich macht (detached). Zugriff danach wirft einen TypeError.