TypedArray
Baseline Widely available *
This feature is well established and works across many devices and browser versions. It’s been available across browsers since July 2015.
* Some parts of this feature may have varying levels of support.
Ein TypedArray-Objekt beschreibt eine array-ähnliche Ansicht eines zugrunde liegenden binären Datenpuffers. Es gibt keine globale Eigenschaft namens TypedArray
und keinen direkt sichtbaren TypedArray
-Konstruktor. Stattdessen existieren eine Reihe verschiedener globaler Eigenschaften, deren Werte getypte Array-Konstruktoren für spezifische Elementtypen sind, die unten aufgeführt sind. Auf den folgenden Seiten finden Sie gemeinsame Eigenschaften und Methoden, die mit jedem Typarray verwendet werden können, das Elemente jeglichen Typs enthält.
Probieren Sie es aus
// Create a TypedArray with a size in bytes
const typedArray1 = new Int8Array(8);
typedArray1[0] = 32;
const typedArray2 = new Int8Array(typedArray1);
typedArray2[1] = 42;
console.log(typedArray1);
// Expected output: Int8Array [32, 0, 0, 0, 0, 0, 0, 0]
console.log(typedArray2);
// Expected output: Int8Array [32, 42, 0, 0, 0, 0, 0, 0]
Beschreibung
Der TypedArray
-Konstruktor (oft als %TypedArray%
bezeichnet, um seine "intrinsische Natur" anzuzeigen, da er keinem globalen, in einem JavaScript-Programm sichtbaren Objekt entspricht) dient als gemeinsame Oberklasse aller TypedArray
-Unterklassen. Sehen Sie %TypedArray%
als eine "abstrakte Klasse", die eine gemeinsame Schnittstelle von Dienstprogrammmethoden für alle Typarray-Unterklassen bereitstellt. Dieser Konstruktor ist nicht direkt zugänglich: Es gibt keine globale TypedArray
-Eigenschaft. Er ist nur über Object.getPrototypeOf(Int8Array)
und ähnliches zugänglich.
Beim Erstellen einer Instanz einer TypedArray
-Unterklasse (z.B. Int8Array
) wird intern im Speicher ein Array-Puffer erstellt oder, wenn ein ArrayBuffer
-Objekt als Konstruktorargument angegeben wird, wird stattdessen dieser ArrayBuffer
verwendet. Die Pufferadresse wird als interne Eigenschaft der Instanz gespeichert und alle Methoden von %TypedArray%.prototype
setzen und holen Werte basierend auf dieser Array-Pufferadresse.
TypedArray-Objekte
Typ | Wertebereich | Größe in Bytes | Web-IDL-Typ |
---|---|---|---|
Int8Array |
-128 bis 127 | 1 | byte |
Uint8Array |
0 bis 255 | 1 | octet |
Uint8ClampedArray |
0 bis 255 | 1 | octet |
Int16Array |
-32768 bis 32767 | 2 | short |
Uint16Array |
0 bis 65535 | 2 | unsigned short |
Int32Array |
-2147483648 bis 2147483647 | 4 | long |
Uint32Array |
0 bis 4294967295 | 4 | unsigned long |
Float16Array |
-65504 bis 65504 |
2 | N/A |
Float32Array |
-3.4e38 bis 3.4e38 |
4 | unrestricted float |
Float64Array |
-1.8e308 bis 1.8e308 |
8 | unrestricted double |
BigInt64Array |
-263 bis 263 - 1 | 8 | bigint |
BigUint64Array |
0 bis 264 - 1 | 8 | bigint |
Wertkodierung und Normalisierung
Alle typisierten Arrays arbeiten auf ArrayBuffer
s, wobei Sie die genaue Byte-Darstellung jedes Elements beobachten können, daher ist es von Bedeutung, wie die Zahlen im binären Format kodiert werden.
- Unsigned Integer-Arrays (
Uint8Array
,Uint16Array
,Uint32Array
undBigUint64Array
) speichern die Zahl direkt im Binärformat. - Signed Integer-Arrays (
Int8Array
,Int16Array
,Int32Array
undBigInt64Array
) speichern die Zahl unter Verwendung des Zweierkomplements. - Gleitkomma-Arrays (
Float16Array
,Float32Array
, undFloat64Array
) speichern die Zahl im IEEE 754-Gleitkommaformat. DieNumber
-Referenz enthält weitere Informationen über das genaue Format. JavaScript-Zahlen verwenden standardmäßig das Gleitkommaformat mit doppelter Genauigkeit, das mitFloat64Array
identisch ist.Float32Array
verwendet 23 (anstatt 52) Bits für die Mantisse und 8 (anstatt 11) Bits für den Exponenten.Float16Array
benutzt 10 Bits für die Mantisse und 5 Bits für den Exponenten. Beachten Sie, dass die Spezifikation erfordert, dass alleNaN
-Werte denselben Bitcode verwenden, aber das genaue Bitmuster ist implementationsabhängig. Uint8ClampedArray
ist ein Sonderfall. Es speichert die Zahl im Binärformat wieUint8Array
, aber wenn Sie eine Zahl außerhalb des Bereichs speichern, klammert es die Zahl auf den Bereich von 0 bis 255, anstatt die bedeutendsten Bits zu kürzen.
Alle Typarrays außer Int8Array
, Uint8Array
und Uint8ClampedArray
speichern jedes Element mit mehreren Bytes. Diese Bytes können entweder von den bedeutendsten zu den wenigsten bedeutenden (Big-Endian) oder von den wenigsten bedeutenden zu den bedeutendsten (Little-Endian) geordnet werden. Weitere Erklärungen finden Sie unter Endianness. Typarrays nutzen immer die native Byte-Reihenfolge der Plattform. Wenn Sie die Endianness beim Schreiben und Lesen von Buffern angeben möchten, sollten Sie stattdessen einen DataView
verwenden.
Beim Schreiben in diesen Typarrays werden Werte, die außerhalb des darstellbaren Bereichs liegen, normalisiert.
- Alle Integer-Arrays (außer
Uint8ClampedArray
) verwenden festbreite Zahlenumwandlung, die zuerst den Dezimalteil der Zahl abschneidet und dann die unteren Bits nimmt. Uint8ClampedArray
klemmt zuerst die Zahl auf den Bereich 0 bis 255 (Werte größer als 255 werden zu 255 und Werte kleiner als 0 werden zu 0). Es rundet dann das Ergebnis (anstatt es abzurunden) auf die nächste ganze Zahl mit Halb-zur-gerade-Rundung; das bedeutet, wenn die Zahl genau zwischen zwei ganzen Zahlen liegt, wird sie auf die nächste gerade Zahl gerundet. Beispielsweise wird0.5
zu0
,1.5
zu2
und2.5
ebenfalls zu2
.Float16Array
undFloat32Array
führen ein "Round to Even" durch, um 64-Bit-Gleitpunktzahlen in 32-Bit und 16-Bit zu konvertieren. Dies ist derselbe Algorithmus, wie er durchMath.fround()
undMath.f16round()
bereitgestellt wird.
Verhalten beim Anzeigen eines anpassbaren Puffers
Wenn ein TypedArray
als Ansicht eines anpassbaren Puffers erstellt wird, hat das Anpassen der Größe des zugrunde liegenden Puffers unterschiedliche Auswirkungen auf die Größe des TypedArray
, abhängig davon, ob das TypedArray
als Längen-Tracking konstruiert ist.
Wenn ein Typarray ohne spezifische Größe erstellt wird, indem der dritte Parameter weggelassen oder undefined
übergeben wird, wird das Typarray längenverfolgend und passt sich automatisch an den zugrunde liegenden buffer
an, sobald dieser angepasst wird:
const buffer = new ArrayBuffer(8, { maxByteLength: 16 });
const float32 = new Float32Array(buffer);
console.log(float32.byteLength); // 8
console.log(float32.length); // 2
buffer.resize(12);
console.log(float32.byteLength); // 12
console.log(float32.length); // 3
Wenn ein Typarray mit einer spezifischen Größe mit dem dritten length
-Parameter erstellt wird, wird es nicht neu dimensioniert, um den buffer
zu enthalten, wenn dieser wächst:
const buffer = new ArrayBuffer(8, { maxByteLength: 16 });
const float32 = new Float32Array(buffer, 0, 2);
console.log(float32.byteLength); // 8
console.log(float32.length); // 2
console.log(float32[0]); // 0, the initial value
buffer.resize(12);
console.log(float32.byteLength); // 8
console.log(float32.length); // 2
console.log(float32[0]); // 0, the initial value
Wenn ein buffer
verkleinert wird, kann das betrachtende Typarray außer Reichweite geraten, in welchem Fall die beobachtete Größe des Typarrays auf 0 abnimmt. Dies ist der einzige Fall, in dem sich die Länge eines nicht längenverfolgenden Typarrays ändern kann.
const buffer = new ArrayBuffer(8, { maxByteLength: 16 });
const float32 = new Float32Array(buffer, 0, 2);
buffer.resize(7);
console.log(float32.byteLength); // 0
console.log(float32.length); // 0
console.log(float32[0]); // undefined
Wenn Sie den buffer
dann wieder vergrößern, um das Typarray wieder in den Geltungsbereich zu bringen, wird die Größe des Typarrays auf seinen ursprünglichen Wert wiederhergestellt.
buffer.resize(8);
console.log(float32.byteLength); // 8
console.log(float32.length); // 2
console.log(float32[0]); // 0 - back in bounds again!
Dasselbe kann auch für längenverfolgende Typarrays passieren, wenn der Puffer über den byteOffset
hinaus verkleinert wird.
const buffer = new ArrayBuffer(8, { maxByteLength: 16 });
const float32 = new Float32Array(buffer, 4);
// float32 is length-tracking, but it only extends from the 4th byte
// to the end of the buffer, so if the buffer is resized to be shorter
// than 4 bytes, the typed array will become out of bounds
buffer.resize(3);
console.log(float32.byteLength); // 0
Konstruktor
Dieses Objekt kann nicht direkt instanziiert werden — der Versuch, es mit new
zu konstruieren, wirft eine TypeError
.
new (Object.getPrototypeOf(Int8Array))();
// TypeError: Abstract class TypedArray not directly constructable
Stattdessen erstellen Sie eine Instanz eines Typarrays eines bestimmten Typs, wie ein Int8Array
oder ein BigInt64Array
. Diese Objekte haben alle eine gemeinsame Syntax für ihre Konstruktoren:
new TypedArray()
new TypedArray(length)
new TypedArray(typedArray)
new TypedArray(object)
new TypedArray(buffer)
new TypedArray(buffer, byteOffset)
new TypedArray(buffer, byteOffset, length)
Wobei TypedArray
ein Konstruktor für einen der konkreten Typen ist.
Parameter
typedArray
-
Wenn mit einer Instanz einer
TypedArray
-Unterklasse aufgerufen, wird dertypedArray
in ein neues Typarray kopiert. Für einen nicht-BigInt-TypedArray
-Konstruktor kann dertypedArray
-Parameter nur einer der nicht-BigInt-Typen sein (wieInt32Array
). Ähnlich kann für einen BigIntTypedArray
-Konstruktor (BigInt64Array
oderBigUint64Array
) dertypedArray
-Parameter nur einer der BigInt-Typen sein. Jeder Wert intypedArray
wird in den entsprechenden Typ des Konstruktors konvertiert, bevor er in das neue Array kopiert wird. Die Länge des neuen Typarrays wird dieselbe sein wie die Länge destypedArray
-Arguments. object
-
Wenn mit einem Objekt aufgerufen, das keine
TypedArray
-Instanz ist, wird ein neues Typarray auf die gleiche Weise erstellt wie dieTypedArray.from()
-Methode. length
Optional-
Wenn mit einem Nicht-Objekt aufgerufen, wird der Parameter als Zahl behandelt, die die Länge des Typarrays angibt. Ein interner Array-Puffer wird im Speicher erstellt, mit der Größe
length
multipliziert mitBYTES_PER_ELEMENT
Bytes, gefüllt mit Nullen. Das Weglassen aller Parameter ist gleichbedeutend mit der Verwendung von0
alslength
. buffer
,byteOffset
Optional,length
Optional-
Wenn mit einer
ArrayBuffer
- oderSharedArrayBuffer
-Instanz und optional einembyteOffset
- und einemlength
-Argument aufgerufen wird, wird eine neue Typarray-Ansicht erstellt, die den angegebenen Puffer anzeigt. DiebyteOffset
(in Bytes) undlength
(in der Anzahl der Elemente, jedes mitBYTES_PER_ELEMENT
Bytes) Parameter spezifizieren den Speicherbereich, der von der Typarrayansicht sichtbar gemacht wird. Wenn beide weggelassen werden, wird der gesamtebuffer
angezeigt; wenn nurlength
weggelassen wird, wird der Rest vonbuffer
abbyteOffset
angezeigt. Wennlength
weggelassen wird, wird das Typarray längenverfolgend.
Ausnahmen
Alle TypeArray
-Unterklassenkonstruktoren funktionieren auf die gleiche Weise. Sie würden alle die folgenden Ausnahmen werfen:
TypeError
-
Wird in einem der folgenden Fälle ausgelöst:
- Ein
typedArray
wird übergeben, ist jedoch ein bigint-Typ, während der aktuelle Konstruktor dies nicht ist, oder umgekehrt. - Ein
typedArray
wird übergeben, aber der Puffer, den es anzeigen soll, ist getrennt, oder ein getrenntesbuffer
wird direkt übergeben.
- Ein
RangeError
-
Wird in einem der folgenden Fälle ausgelöst:
- Die Länge des neuen Typarrays ist zu groß.
- Die Länge von
buffer
(wenn derlength
-Parameter nicht angegeben ist) oderbyteOffset
ist kein ganzzahliges Vielfaches der neuen Typarray-Elementgröße. byteOffset
ist kein gültiger Array-Index (eine ganze Zahl zwischen 0 und 253 - 1).- Wenn eine Ansicht von einem Puffer erstellt wird, liegen die Grenzen außerhalb des Puffers. Mit anderen Worten,
byteOffset + length * TypedArray.BYTES_PER_ELEMENT > buffer.byteLength
.
Statische Eigenschaften
Diese Eigenschaften sind auf dem TypedArray
-Konstruktorobjekt definiert und werden daher von allen TypedArray
-Unterklassenkonstruktoren geteilt.
TypedArray[Symbol.species]
-
Die Konstruktorfunktion, die zum Erstellen abgeleiteter Objekte verwendet wird.
Alle TypedArray
-Unterklassen haben auch die folgenden statischen Eigenschaften:
TypedArray.BYTES_PER_ELEMENT
-
Gibt einen Zahlenwert der Elementgröße für die verschiedenen
TypedArray
-Objekte zurück.
Statische Methoden
Diese Methoden sind auf dem TypedArray
-Konstruktorobjekt definiert und werden daher von allen TypedArray
-Unterklassenkonstruktoren geteilt.
TypedArray.from()
-
Erstellt ein neues
TypedArray
aus einem array-ähnlichen oder iterierbaren Objekt. Siehe auchArray.from()
. TypedArray.of()
-
Erstellt ein neues
TypedArray
mit einer variablen Anzahl von Argumenten. Siehe auchArray.of()
.
Instanzeigenschaften
Diese Eigenschaften sind auf TypedArray.prototype
definiert und werden von allen TypedArray
-Unterklasseninstanzen geteilt.
TypedArray.prototype.buffer
-
Gibt den
ArrayBuffer
zurück, der vom Typarray referenziert wird. TypedArray.prototype.byteLength
-
Gibt die Länge (in Bytes) des Typarrays zurück.
TypedArray.prototype.byteOffset
-
Gibt den Versatz (in Bytes) des Typarrays vom Anfang seines
ArrayBuffer
zurück. TypedArray.prototype.constructor
-
Die Konstruktorfunktion, die das Instanzobjekt erstellt hat.
TypedArray.prototype.constructor
ist die versteckteTypedArray
-Konstruktorfunktion, aber jede Typarray-Unterklasse definiert auch ihre eigeneconstructor
-Eigenschaft. TypedArray.prototype.length
-
Gibt die Anzahl der Elemente zurück, die im Typarray gehalten werden.
TypedArray.prototype[Symbol.toStringTag]
-
Der Anfangswert der
TypedArray.prototype[Symbol.toStringTag]
-Eigenschaft ist ein Getter, der dieselbe Zeichenfolge wie der Name des Typarray-Konstruktors zurückgibt. Er gibtundefined
zurück, wenn derthis
-Wert nicht eine der Typarray-Unterklassen ist. Diese Eigenschaft wird inObject.prototype.toString()
verwendet. DaTypedArray
jedoch auch seine eigenetoString()
-Methode hat, wird diese Eigenschaft nicht verwendet, es sei denn, Sie rufenObject.prototype.toString.call()
mit einem Typarray alsthisArg
auf.
Alle TypedArray
-Unterklassen haben auch die folgenden Instanzeigenschaften:
TypedArray.prototype.BYTES_PER_ELEMENT
-
Gibt einen Zahlenwert der Elementgröße für die verschiedenen
TypedArray
-Objekte zurück.
Instanzmethoden
Diese Methoden sind auf dem TypedArray
-Prototypobjekt definiert und werden daher von allen TypedArray
-Unterklasseninstanzen geteilt.
TypedArray.prototype.at()
-
Nimmt einen ganzzahligen Wert und gibt das Element an diesem Index zurück. Diese Methode ermöglicht negative Ganzzahlen, die rückwärts vom letzten Element zählen.
TypedArray.prototype.copyWithin()
-
Kopiert eine Sequenz von Array-Elementen innerhalb des Arrays. Siehe auch
Array.prototype.copyWithin()
. TypedArray.prototype.entries()
-
Gibt ein neues Array-Iterator-Objekt zurück, das die Schlüssel/Wert-Paare für jeden Index im Array enthält. Siehe auch
Array.prototype.entries()
. TypedArray.prototype.every()
-
Testet, ob alle Elemente im Array den Test bestehen, der von einer Funktion bereitgestellt wird. Siehe auch
Array.prototype.every()
. TypedArray.prototype.fill()
-
Füllt alle Elemente eines Arrays von einem Startindex bis zu einem Endindex mit einem statischen Wert. Siehe auch
Array.prototype.fill()
. TypedArray.prototype.filter()
-
Erstellt ein neues Array mit allen Elementen dieses Arrays, für die die bereitgestellte Filterfunktion
true
zurückgibt. Siehe auchArray.prototype.filter()
. TypedArray.prototype.find()
-
Gibt das erste
Element
im Array zurück, das eine bereitgestellte Testfunktion erfüllt, oderundefined
, wenn kein geeignetes Element gefunden wird. Siehe auchArray.prototype.find()
. TypedArray.prototype.findIndex()
-
Gibt den ersten Indexwert im Array zurück, der ein Element hat, das eine bereitgestellte Testfunktion erfüllt, oder
-1
, wenn kein geeignetes Element gefunden wurde. Siehe auchArray.prototype.findIndex()
. TypedArray.prototype.findLast()
-
Gibt den Wert des letzten Elements im Array zurück, das eine bereitgestellte Testfunktion erfüllt, oder
undefined
, wenn kein geeignetes Element gefunden wird. Siehe auchArray.prototype.findLast()
. TypedArray.prototype.findLastIndex()
-
Gibt den Index des letzten Elements im Array zurück, das eine bereitgestellte Testfunktion erfüllt, oder
-1
, wenn kein geeignetes Element gefunden wurde. Siehe auchArray.prototype.findLastIndex()
. TypedArray.prototype.forEach()
-
Ruft eine Funktion für jedes Element im Array auf. Siehe auch
Array.prototype.forEach()
. TypedArray.prototype.includes()
-
Bestimmt, ob ein Typarray ein bestimmtes Element enthält, und gibt
true
oderfalse
entsprechend zurück. Siehe auchArray.prototype.includes()
. TypedArray.prototype.indexOf()
-
Gibt den ersten (kleinsten) Index eines Elements innerhalb des Arrays zurück, der dem angegebenen Wert entspricht, oder
-1
, wenn keiner gefunden wird. Siehe auchArray.prototype.indexOf()
. TypedArray.prototype.join()
-
Fügt alle Elemente eines Arrays zu einer Zeichenfolge zusammen. Siehe auch
Array.prototype.join()
. TypedArray.prototype.keys()
-
Gibt einen neuen Array-Iterator zurück, der die Schlüssel für jeden Index im Array enthält. Siehe auch
Array.prototype.keys()
. TypedArray.prototype.lastIndexOf()
-
Gibt den letzten (größten) Index eines Elements innerhalb des Arrays zurück, der dem angegebenen Wert entspricht, oder
-1
, wenn keiner gefunden wird. Siehe auchArray.prototype.lastIndexOf()
. TypedArray.prototype.map()
-
Erstellt ein neues Array mit den Ergebnissen des Aufrufs einer bereitgestellten Funktion für jedes Element in diesem Array. Siehe auch
Array.prototype.map()
. TypedArray.prototype.reduce()
-
Wendet eine Funktion auf einen Akkumulator und jeden Wert des Arrays (von links nach rechts) an, um ihn auf einen einzigen Wert zu reduzieren. Siehe auch
Array.prototype.reduce()
. TypedArray.prototype.reduceRight()
-
Wendet eine Funktion auf einen Akkumulator und jeden Wert des Arrays (von rechts nach links) an, um ihn auf einen einzigen Wert zu reduzieren. Siehe auch
Array.prototype.reduceRight()
. TypedArray.prototype.reverse()
-
Kehrt die Reihenfolge der Elemente eines Arrays um — das erste wird das letzte und das letzte wird das erste. Siehe auch
Array.prototype.reverse()
. TypedArray.prototype.set()
-
Speichert mehrere Werte im Typarray und liest Eingabewerte aus einem angegebenen Array.
TypedArray.prototype.slice()
-
Extrahiert einen Abschnitt eines Arrays und gibt ein neues Array zurück. Siehe auch
Array.prototype.slice()
. TypedArray.prototype.some()
-
Gibt
true
zurück, wenn mindestens ein Element in diesem Array die bereitgestellte Testfunktion erfüllt. Siehe auchArray.prototype.some()
. TypedArray.prototype.sort()
-
Sortiert die Elemente eines Arrays vor Ort und gibt das Array zurück. Siehe auch
Array.prototype.sort()
. TypedArray.prototype.subarray()
-
Gibt ein neues
TypedArray
von dem angegebenen Start- und Endelementindex zurück. TypedArray.prototype.toLocaleString()
-
Gibt eine lokalisierte Zeichenfolge zurück, die das Array und seine Elemente darstellt. Siehe auch
Array.prototype.toLocaleString()
. TypedArray.prototype.toReversed()
-
Gibt ein neues Array mit den in umgekehrter Reihenfolge befindlichen Elementen zurück, ohne das Originalarray zu ändern.
TypedArray.prototype.toSorted()
-
Gibt ein neues Array zurück, dessen Elemente in aufsteigender Reihenfolge sortiert sind, ohne das Originalarray zu ändern.
TypedArray.prototype.toString()
-
Gibt eine Zeichenfolge zurück, die das Array und seine Elemente darstellt. Siehe auch
Array.prototype.toString()
. TypedArray.prototype.values()
-
Gibt ein neues Array-Iterator-Objekt zurück, das die Werte für jeden Index im Array enthält. Siehe auch
Array.prototype.values()
. TypedArray.prototype.with()
-
Gibt ein neues Array zurück, bei dem das Element an dem angegebenen Index durch den angegebenen Wert ersetzt wird, ohne das Originalarray zu ändern.
TypedArray.prototype[Symbol.iterator]()
-
Gibt ein neues Array-Iterator-Objekt zurück, das die Werte für jeden Index im Array enthält.
Beispiele
Zugriff auf Eigenschaften
Sie können auf Elemente im Array mit der Standard-Array-Index-Syntax (d.h. durch Klammernnotation) zugreifen. Beim Abrufen oder Setzen von indizierten Eigenschaften auf Typarrays wird jedoch nicht in der Prototypenkette nach dieser Eigenschaft gesucht, auch wenn die Indizes außerhalb des Bereichs liegen. Indizierte Eigenschaften konsultieren den ArrayBuffer
und schauen niemals auf Objekteigenschaften. Sie können immer noch benannte Eigenschaften verwenden, wie bei allen Objekten.
// Setting and getting using standard array syntax
const int16 = new Int16Array(2);
int16[0] = 42;
console.log(int16[0]); // 42
// Indexed properties on prototypes are not consulted (Fx 25)
Int8Array.prototype[20] = "foo";
new Int8Array(32)[20]; // 0
// even when out of bound
Int8Array.prototype[20] = "foo";
new Int8Array(8)[20]; // undefined
// or with negative integers
Int8Array.prototype[-1] = "foo";
new Int8Array(8)[-1]; // undefined
// Named properties are allowed, though (Fx 30)
Int8Array.prototype.foo = "bar";
new Int8Array(32).foo; // "bar"
Kann nicht eingefroren werden
TypedArray
s, die nicht leer sind, können nicht eingefroren werden, da ihr zugrunde liegender ArrayBuffer
durch eine andere TypedArray
-Ansicht des Puffers verändert werden könnte. Dies würde bedeuten, dass das Objekt niemals wirklich eingefroren wird.
const i8 = Int8Array.of(1, 2, 3);
Object.freeze(i8);
// TypeError: Cannot freeze array buffer views with elements
ByteOffset muss ausgerichtet sein
Beim Erstellen eines TypedArray
als Ansicht auf einen ArrayBuffer
muss das byteOffset
-Argument auf die Elementgröße ausgerichtet sein; mit anderen Worten, der Versatz muss ein Vielfaches von BYTES_PER_ELEMENT
sein.
const i32 = new Int32Array(new ArrayBuffer(4), 1);
// RangeError: start offset of Int32Array should be a multiple of 4
const i32 = new Int32Array(new ArrayBuffer(4), 0);
ByteLength muss ausgerichtet sein
Wie der byteOffset
-Parameter muss auch die byteLength
-Eigenschaft eines ArrayBuffer
, der an einen TypedArray
-Konstruktor übergeben wird, ein Vielfaches des BYTES_PER_ELEMENT
-Konstruktors sein.
const i32 = new Int32Array(new ArrayBuffer(3));
// RangeError: byte length of Int32Array should be a multiple of 4
const i32 = new Int32Array(new ArrayBuffer(4));
Spezifikationen
Specification |
---|
ECMAScript® 2025 Language Specification # sec-typedarray-objects |
Browser-Kompatibilität
Report problems with this compatibility data on GitHubdesktop | mobile | server | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
TypedArray | ||||||||||||||
[Symbol.iterator] | ||||||||||||||
[Symbol.species] | ||||||||||||||
BYTES_PER_ELEMENT | ||||||||||||||
at | ||||||||||||||
buffer | ||||||||||||||
byteLength | ||||||||||||||
byteOffset | ||||||||||||||
Constructor without parameters | ||||||||||||||
copyWithin | ||||||||||||||
entries | ||||||||||||||
every | ||||||||||||||
fill | ||||||||||||||
filter | ||||||||||||||
find | ||||||||||||||
findIndex | ||||||||||||||
findLast | ||||||||||||||
findLastIndex | ||||||||||||||
forEach | ||||||||||||||
from | ||||||||||||||
includes | ||||||||||||||
indexOf | ||||||||||||||
Indexed properties not consulting prototype | ||||||||||||||
Iterable in constructor | ||||||||||||||
join | ||||||||||||||
keys | ||||||||||||||
lastIndexOf | ||||||||||||||
length | ||||||||||||||
map | ||||||||||||||
name | ||||||||||||||
Named properties | ||||||||||||||
of | ||||||||||||||
reduce | ||||||||||||||
reduceRight | ||||||||||||||
reverse | ||||||||||||||
set | ||||||||||||||
slice | ||||||||||||||
some | ||||||||||||||
sort | ||||||||||||||
subarray | ||||||||||||||
toLocaleString | ||||||||||||||
toReversed | ||||||||||||||
toSorted | ||||||||||||||
toString | ||||||||||||||
values | ||||||||||||||
with |
Legend
Tip: you can click/tap on a cell for more information.
- Full support
- Full support
- No support
- No support
- See implementation notes.
- Uses a non-standard name.
- Has more compatibility info.