TypedArray.prototype.slice() — Methode · JavaScript-Referenz

Signatur

TypedArray.prototype.slice(start, end)

Beschreibung

Die Methode slice() ist auf allen typisierten Arrays verfügbar, etwa Uint8Array, Int16Array, Float32Array oder BigInt64Array. Sie kopiert einen Teilbereich in ein neues typisiertes Array desselben Typs. Das Ergebnis hat einen eigenen ArrayBuffer. Änderungen an der Kopie wirken sich also nicht auf das Original aus, und umgekehrt gilt dasselbe.

Damit unterscheidet sich slice() grundlegend von subarray(). subarray() erzeugt nur eine neue Sicht auf denselben Speicher. Verwende slice(), wenn du Daten unabhängig weiterverarbeiten, verändern oder an einen Worker übertragen willst, ohne das Original anzutasten. Das ist z. B. beim Zerlegen von Binärprotokollen, beim Ausschneiden von Audio-Samples oder beim Kopieren von Pixeldaten nützlich.

Die Indizes verhalten sich wie bei Array.prototype.slice(). Negative Werte zählen vom Ende. Werte außerhalb des gültigen Bereichs werden auf 0 bzw. length begrenzt. Liegt start hinter end, erhältst du ein leeres typisiertes Array.

Parameter

Name	Typ	Default	Beschreibung
$start	number	0	Index (ab 0), bei dem die Kopie beginnt. Negative Werte zählen vom Ende (`-2` = vorletztes Element). Ist der Wert größer als `length`, entsteht ein leeres Array.
$end	number	length	Index, vor dem die Kopie endet. Dieses Element ist nicht mehr enthalten. Negative Werte zählen vom Ende. Werte größer als `length` werden auf `length` begrenzt.

Rückgabewert

Typ

TypedArray

Beschreibung

Ein neues typisiertes Array desselben Typs (z. B. Uint8Array) mit den kopierten Elementen und einem eigenen, unabhängigen ArrayBuffer.

Beispiele

Grundlegende Verwendung mit positiven und negativen Indizes

const bytes = new Uint8Array([10, 20, 30, 40, 50]);

console.log(bytes.slice(1, 3));  // Index 1 bis ausschließlich 3
console.log(bytes.slice(-2));    // die letzten zwei Elemente
console.log(bytes.slice());      // vollständige Kopie
console.log(bytes.slice(4, 2));  // start > end → leer

Uint8Array(2) [20, 30] Uint8Array(2) [40, 50] Uint8Array(5) [10, 20, 30, 40, 50] Uint8Array(0) []

slice() kopiert, subarray() teilt den Speicher

const original = new Int16Array([1, 2, 3, 4]);

const kopie = original.slice(0, 2);
const sicht = original.subarray(0, 2);

kopie[0] = 99;  // Original bleibt unverändert
sicht[1] = 77;  // ändert das Original!

console.log(original);
console.log(kopie.buffer === original.buffer);
console.log(sicht.buffer === original.buffer);

Int16Array(4) [1, 77, 3, 4] false true

Header und Nutzdaten aus einem Binärpaket herauslösen

// Paketformat: 4 Byte Header, danach die Nutzdaten
const paket = new Uint8Array([0xCA, 0xFE, 0x00, 0x03, 72, 105, 33]);

const header = paket.slice(0, 4);
const nutzdaten = paket.slice(4);

const laenge = (header[2] << 8) | header[3];
const text = new TextDecoder().decode(nutzdaten);

console.log(`Länge: ${laenge}, Text: ${text}`);

Länge: 3, Text: Hi!

Audio-Ausschnitt kopieren und unabhängig bearbeiten

const sampleRate = 8;
const samples = Float32Array.from({ length: 32 }, (_, i) => Math.sin(i / 4));

// Sekunde 1 bis 2 ausschneiden
const ausschnitt = samples.slice(sampleRate * 1, sampleRate * 2);

// Lautstärke halbieren, ohne das Original zu verändern
for (let i = 0; i < ausschnitt.length; i++) ausschnitt[i] *= 0.5;

console.log(ausschnitt.length);
console.log(samples[8] === ausschnitt[0] * 2);

8 true

// Wichtig · Fallstricke

Speicher und Leistung: slice() kopiert die Daten immer. Bei großen Puffern (Video, Audio, WebGL) kann das teuer werden. Wenn du nur lesen willst, ist subarray() ohne Kopie meist die bessere Wahl.
Kein Parameter für die Länge: Der zweite Parameter ist ein End-Index, keine Anzahl von Elementen. slice(2, 3) liefert genau ein Element.
Nicht mit ArrayBuffer.prototype.slice() verwechseln: Dort sind die Indizes Byte-Positionen, hier sind es Element-Positionen. Bei Float64Array entspricht ein Element 8 Byte.
Species: Das Ergebnis wird über Symbol.species erzeugt. Bei Unterklassen typisierter Arrays entsteht daher normalerweise eine Instanz der Unterklasse.
Abgelöster Puffer: Wurde der zugrunde liegende ArrayBuffer übertragen (z. B. per postMessage mit Transfer-Liste), wirft slice() einen TypeError.
Kompatibilität: Wird von allen modernen Browsern und von Node.js ab Version 4 unterstützt. Im Internet Explorer fehlt die Methode.

Siehe auch

TypedArray.prototype.subarray() Array.prototype.slice() ArrayBuffer.prototype.slice() TypedArray.prototype.set() TypedArray Uint8Array TypedArray.prototype[Symbol.iterator]()