Array.prototype.pop() entfernt das letzte Element eines Arrays in-place und gibt es zurück. Das Array wird also direkt mutiert; length sinkt um 1. Bei einem leeren Array liefert pop undefined zurück — ohne Fehler, ohne Warnung. Zusammen mit push ergibt sich eine LIFO-Stack-Struktur. In immutable Code-Stilen (React-State, funktionaler Stil) ist pop falsch — slice(0, -1) ist die nicht-mutierende Alternative. Mit ES2023 toSpliced gibt es zusätzlich eine generische immutable Splice-Operation.

01 · Signatur & Grundform

Signatur & Grundform

JavaScript signatur.js 
arr.pop(): T | undefined   // letztes Element oder undefined
JavaScript grundform.js 
const arr = [1, 2, 3];
const letztes = arr.pop();

console.log(letztes);        // 3
console.log(arr);            // [1, 2] — mutiert
console.log(arr.length);     // 2
Output 
3
[ 1, 2 ]
2
02 · Leeres Array

Auf leerem Array

pop() auf einem leeren Array liefert undefined und mutiert nichts.

JavaScript leer.js 
const leer = [];
const x = leer.pop();
console.log(x);              // undefined
console.log(leer);           // []
console.log(leer.length);    // 0 — bleibt 0, kein Negativ
Output 
undefined
[]
0

Wer zwischen „leer" und „letztes Element war undefined" unterscheiden muss: vorher arr.length > 0 prüfen.

03 · LIFO-Stack mit push/pop

LIFO-Stack-Pattern

Mit push und pop lässt sich ein klassischer Stack abbilden — Last-In, First-Out.

JavaScript stack.js 
const stack = [];

stack.push('A');
stack.push('B');
stack.push('C');
console.log(stack);          // ['A', 'B', 'C']

console.log(stack.pop());    // 'C' — zuletzt rein, zuerst raus
console.log(stack.pop());    // 'B'
console.log(stack);          // ['A']
Output 
[ 'A', 'B', 'C' ]
C
B
[ 'A' ]

Praktischer Use-Case: Browser-Historie, Undo-Stack, Tree-DFS, Parser-Operator-Stack.

04 · In Schleifen

In Schleifen — Array leeren und verarbeiten

pop ist die effiziente Form, ein Array Element für Element abzuarbeiten und gleichzeitig zu leeren.

JavaScript leeren.js 
const aufgaben = ['A', 'B', 'C'];

while (aufgaben.length > 0) {
    const job = aufgaben.pop();
    console.log('Verarbeite:', job);
}

console.log('Array leer?', aufgaben.length === 0);
Output 
Verarbeite: C
Verarbeite: B
Verarbeite: A
Array leer? true

Vorteil gegenüber shift: pop ist O(1) — kein Reindexing. Bei großen Arrays daher der schnellere Weg, wenn die Verarbeitungs-Reihenfolge egal ist.

05 · Immutable-Alternative

Immutable: slice(0, -1)

Wer das letzte Element entfernen will, ohne das Original zu mutieren, nutzt slice mit negativem End-Index.

JavaScript immutable.js 
const original = [1, 2, 3];

// Ohne Mutation
const gekuerzt = original.slice(0, -1);
console.log(original);       // [1, 2, 3] — unverändert
console.log(gekuerzt);       // [1, 2]

// Letztes Element + gekürztes Array gleichzeitig
const letztes = original.at(-1);
const rest = original.slice(0, -1);
console.log(letztes, rest);
Output 
[ 1, 2, 3 ]
[ 1, 2 ]
3 [ 1, 2 ]

.at(-1) (ES2022) liefert das letzte Element ohne Index-Rechnerei.

06 · toSpliced (ES2023)

toSpliced als generische immutable Variante

Für komplexere Entfernungen liefert toSpliced (ES2023) das immutable Pendant zu splice.

JavaScript tospliced.js 
const original = [1, 2, 3, 4];

// Letztes Element entfernen, ohne Mutation
const gekuerzt = original.toSpliced(-1, 1);
console.log(original);       // [1, 2, 3, 4] — unverändert
console.log(gekuerzt);       // [1, 2, 3]

// Letztes Element ersetzen (immutable)
const ersetzt = original.toSpliced(-1, 1, 99);
console.log(ersetzt);        // [1, 2, 3, 99]
Output 
[ 1, 2, 3, 4 ]
[ 1, 2, 3 ]
[ 1, 2, 3, 99 ]

Browser-Support: Chrome 110+, Firefox 115+, Safari 16+, Node 20+ — Baseline 2024.

07 · pop auf Array-Like

pop auf Array-Like

Mit call lässt sich pop auf array-like Objekte mit writable length anwenden.

JavaScript arraylike.js 
const arrayLike = { 0: 'a', 1: 'b', 2: 'c', length: 3 };

const x = Array.prototype.pop.call(arrayLike);
console.log(x);              // 'c'
console.log(arrayLike);      // { '0': 'a', '1': 'b', length: 2 }
Output 
c
{ '0': 'a', '1': 'b', length: 2 }

Selten gebraucht; dient meist Polyfill- oder Library-Code, der mit Custom-Array-Likes arbeitet.

08 · Performance

Performance

pop ist O(1) — eine konstante Operation. Im Gegensatz zu shift (O(n) wegen Reindexing) ist pop für jede Array-Größe gleich schnell.

Daher: wenn die Reihenfolge der Verarbeitung egal ist, ist pop der schnellste Weg, ein Array zu leeren. Wenn FIFO gebraucht wird, lohnt sich für große Mengen ein anderer Datentyp (Deque, Linked List).

09 · Insights

Interessantes

pop auf leerem Array gibt undefined — kein Fehler

[].pop() liefert undefined ohne Warnung. Daher: while (arr.pop()) {...} bricht ab, wenn das letzte Element falsy ist — nicht nur bei leerem Array. Sicherer: while (arr.length) {...}.

pop ist O(1), shift ist O(n)

Beim pop wird nur length dekrementiert und das letzte Element gelöscht. Bei shift müssen alle anderen Elemente um eins nach vorn geschoben werden — daher O(n). Bei großen Arrays mit häufigem Front-Removal lohnt eine andere Datenstruktur.

pop mutiert — in React/Redux niemals direkt

setList(list.pop()) ist ein Anti-Pattern: pop liefert das entfernte Element (nicht das Array!) UND mutiert das State-Array. React sieht keinen Update. Korrekt: setList(list.slice(0, -1)) oder setList(list.toSpliced(-1, 1)).

pop gibt das entfernte Element zurück, nicht das Array

Anders als push, das die neue Länge liefert, gibt pop das entfernte Element. Daher: const last = arr.pop() setzt last auf das letzte Element.

slice(0, -1) ist immutable — pop ist destruktiv

arr.slice(0, -1) erzeugt ein neues Array ohne letztes Element, arr bleibt unverändert. Pre-ES2023 die Standard-Form für immutable „Drop Last". Heute ergänzt durch arr.toSpliced(-1, 1).

.at(-1) vs. arr[arr.length - 1]

Seit ES2022 gibt arr.at(-1) das letzte Element zurück. Lesbarer als arr[arr.length - 1]. Beide sind read-only — sie holen, mutieren nicht. pop kombiniert „lesen + entfernen" in einem Schritt.

pop auf sparse Array — Loch oder Wert? Egal, pop dekrementiert

Wenn das letzte Element ein Loch ist (sparse), liefert pop undefined und reduziert length. Sehr selten relevant — sparse Arrays sind in modernem Code rar.

In Bun und Deno verhält sich pop identisch wie in Node

Die Spec ist eindeutig, und alle Major-Engines (V8, JSC, SpiderMonkey) implementieren identisch. Anders als manche Erweiterungen (z.B. Array.prototype.last(), das in Stage-3 stecken geblieben ist), ist pop seit ES1 stabil.

10 · Resources

Weiterführende Ressourcen

Externe Quellen

/ Weiter

Zurück zu Arrays

Zur Übersicht