---
title: Float64Array
slug: Web/JavaScript/Reference/Global_Objects/Float64Array
tags:
  - Constructor
  - JavaScript
  - TypedArray
  - TypedArrays
translation_of: Web/JavaScript/Reference/Global_Objects/Float64Array
---
<div>{{JSRef}}</div>

<p>Das <strong><code>Float64Array</code></strong> getypte Array repräsentiert ein Array von 64 Bit Gleitkommazahlen (entspricht dem C Datentyp <code>double</code>) in der Plattform-Byte-Reihenfolge. Wenn Kontrolle über die Byte-Reihenfolge erforderlich ist, muss stattdessen {{jsxref("DataView")}} benutz werden. Die Inhalte werden mit <code>0</code> initialisiert. Wie erwartet, kann man Elemente in einem Array mit Objektmethoden referenzieren oder man benutzt die normale Array-Index-Syntax (das ist die Klammernotation).</p>

<h2 id="Syntax">Syntax</h2>

<pre class="syntaxbox">new Float64Array(); // new in ES2017
new Float64Array(length);
new Float64Array(typedArray);
new Float64Array(object);
new Float64Array(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", "Float64Array.BYTES_PER_ELEMENT")}}</dt>
 <dd>Gibt die Größe der Elemente zurück. <code>8</code> im Falle eines <code>Float64Array</code>.</dd>
 <dt>Float64Array.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", "Float64Array.prototype.length")}}.</dd>
 <dt>{{jsxref("TypedArray.name", "Float64Array.name")}}</dt>
 <dd>Gibt den Stringwert des Konstruktornamens zurück. In Fall eines <code>Float64Array</code> Typs: <code>"Float64Array"</code>.</dd>
 <dt>{{jsxref("TypedArray.prototype", "Float64Array.prototype")}}</dt>
 <dd>Prototyp für das <em>TypedArray</em> Objekt</dd>
</dl>

<h2 id="Methoden">Methoden</h2>

<dl>
 <dt>{{jsxref("TypedArray.from", "Float64Array.from()")}}</dt>
 <dd>Erstellt ein neues <code>Float64Array</code> von einem Array-ähnlichen oder iterierbaren Objekt. Siehe auch {{jsxref("Array.from()")}}.</dd>
 <dt>{{jsxref("TypedArray.of", "Float64Array.of()")}}</dt>
 <dd>Erstellt ein neues <code>Float64Array</code> mit einer variablen Anzahl an Argumenten. Sie auch {{jsxref("Array.of()")}}.</dd>
</dl>

<h2 id="Float64Array_Prototyp"><code>Float64Array</code> Prototyp</h2>

<p>Alle <code>Float64Array</code> Objekte erben von {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p>

<h3 id="Eigenschaften_2">Eigenschaften</h3>

<dl>
 <dt><code>Float64Array.prototype.constructor</code></dt>
 <dd>Gibt die Funktion, die einen Instanzprototyp erstellt, zurück. Diese ist auf den <code>Float64Array</code> Konstruktor voreingestellt.</dd>
 <dt>{{jsxref("TypedArray.prototype.buffer", "Float64Array.prototype.buffer")}} {{readonlyInline}}</dt>
 <dd>Gibt die {{jsxref("ArrayBuffer")}} Referenz zurück, welche nach der Erstellung eines <code>Float64Array</code> fest ist und nicht mehr geändert werden kann.</dd>
 <dt>{{jsxref("TypedArray.prototype.byteLength", "Float64Array.prototype.byteLength")}} {{readonlyInline}}</dt>
 <dd>Gibt die Länge (in Bytes) des <code>Float64Array</code> vom Anfang seines {{jsxref("ArrayBuffer")}} zurück. Wird beim Erstellen festgesetzt und kann nicht geändert werden.</dd>
 <dt>{{jsxref("TypedArray.prototype.byteOffset", "Float64Array.prototype.byteOffset")}} {{readonlyInline}}</dt>
 <dd>Gibt das Offset (in Bytes) des <code>Float64Array</code> vom Anfang seines {{jsxref("ArrayBuffer")}} zurück. Wird beim Erstellen festgesetzt und kann nicht geändert werden.</dd>
 <dt>{{jsxref("TypedArray.prototype.length", "Float64Array.prototype.length")}} {{readonlyInline}}</dt>
 <dd>Gibt die Anzahl der Elemente des <code>Float64Array</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", "Float64Array.prototype.copyWithin()")}}</dt>
 <dd>Kopiert eine Sequenz von Arrayelementen in das Array. Siehe auch {{jsxref("Array.prototype.copyWithin()")}}.</dd>
 <dt>{{jsxref("TypedArray.entries", "Float64Array.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", "Float64Array.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", "Float64Array.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", "Float64Array.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", "Float64Array.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", "Float64Array.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", "Float64Array.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", "Float64Array.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", "Float64Array.prototype.indexOf()")}}</dt>
 <dd>Gibt den ersten Index eines Elementes zurück, welches kongruent eines spezifizierten Wertes ist oder <code>-1</code> wenn es keins gibt. Siehe auch {{jsxref("Array.prototype.indexOf()")}}.</dd>
 <dt>{{jsxref("TypedArray.join", "Float64Array.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", "Float64Array.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", "Float64Array.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", "Float64Array.prototype.map()")}}</dt>
 <dd>Erstellt ein neues Array mit den Resultaten einer für jedes Element aufgerufenen Funtion. Siehe auch {{jsxref("Array.prototype.map()")}}.</dd>
 <dt>{{jsxref("TypedArray.move", "Float64Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt>
 <dd>Ehemalige, nicht standardisierte Version von {{jsxref("TypedArray.copyWithin", "Float64Array.prototype.copyWithin()")}}.</dd>
 <dt>{{jsxref("TypedArray.reduce", "Float64Array.prototype.reduce()")}}</dt>
 <dd>Führt eine Funktion gegen 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", "Float64Array.prototype.reduceRight()")}}</dt>
 <dd>Führt eine Funktion gegen 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", "Float64Array.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", "Float64Array.prototype.set()")}}</dt>
 <dd>Speichert mehrere Werte in einem getypten Array und liest Eingabewerte aus einem spezifiziertem Array.</dd>
 <dt>{{jsxref("TypedArray.slice", "Float64Array.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", "Float64Array.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", "Float64Array.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", "Float64Array.prototype.subarray()")}}</dt>
 <dd>Gibt ein neues <code>Float64Array</code> vom gegebenen Start- und Endindex zurück.</dd>
 <dt>{{jsxref("TypedArray.values", "Float64Array.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", "Float64Array.prototype.toLocaleString()")}}</dt>
 <dd>Gibt eine ortsabhängige Stringrepräsentation des Arrays und seiner Element zurück. Siehe auch {{jsxref("Array.prototype.toLocaleString()")}}.</dd>
 <dt>{{jsxref("TypedArray.toString", "Float64Array.prototype.toString()")}}</dt>
 <dd>Gibt eine Stringrepräsentation des Arrays und seiner Element zurück. Siehe auch {{jsxref("Array.prototype.toString()")}}.</dd>
 <dt>{{jsxref("TypedArray.@@iterator", "Float64Array.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>Float64Array</code> zu erstellen:</p>

<pre class="brush: js">// From a length
var float64 = new Float64Array(2);
float64[0] = 42;
console.log(float64[0]); // 42
console.log(float64.length); // 2
console.log(float64.BYTES_PER_ELEMENT); // 8

// From an array
var arr = new Float64Array([21,31]);
console.log(arr[1]); // 31

// From another TypedArray
var x = new Float64Array([21, 31]);
var y = new Float64Array(x);
console.log(y[0]); // 21

// From an ArrayBuffer
var buffer = new ArrayBuffer(32);
var z = new Float64Array(buffer, 0, 4);

// From an iterable
var iterable = function*(){ yield* [1,2,3]; }();
var float64 = new Float64Array(iterable);
// Float64Array[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('ES2015', '#table-49', 'TypedArray constructors')}}</td>
   <td>{{Spec2('ES2015')}}</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>Float64Array</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.Float64Array")}}</p>

<h2 id="Kompatibilitätshinweise">Kompatibilitätshinweise</h2>

<p>Mit Beginn von ECMAScript 2015, müssen <code>Float64Array</code> Konstruktoren mit einem {{jsxref("Operators/new", "new")}} benutzt werden. Der Aufruf eines <code>Float64Array</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 = Float64Array([1, 2, 3]);
// TypeError: calling a builtin Float64Array constructor
// without new is forbidden</pre>

<pre class="brush: js example-good">var dv = new Float64Array([1, 2, 3]);</pre>

<h2 id="See_also">See also</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>