Methoden in Arrays und Objekten sind eingebaute Funktionen, mit denen man Daten strukturierter bearbeiten, durchsuchen oder transformieren kann.
Sie vereinfachen viele häufige Operationen wie Hinzufügen, Entfernen oder Iterieren von Werten.
String-Methoden:
| Methode | Beschreibung | Beispiel | Ergebnis |
|---|---|---|---|
at(index) | Zeichen anhand Index (negativ möglich) | "Hallo".at(-1) | "o" |
charAt(index) | Liefert das Zeichen am angegebenen Index | "Hallo".charAt(1)" | "a" |
charCodeAt(index) | Unicode-Wert eines Zeichens | "A".charCodeAt(0) | 65 |
concat(str) | Verbindet Strings | "Hi".concat("!") | "Hi!" |
endsWith(substr) | Prüft String-Ende | "Hello".endsWith("lo") | true |
includes(substr) | Prüft, ob Teilstring enthalten ist | "Test".includes("es") | true |
indexOf(substr) | Erste Position des Suchstrings | "Test".indexOf("t") | 3 |
lastIndexOf(substr) | Letzte Position des Suchstrings | "Test".lastIndexOf("t") | 3 |
length | Gibt die Länge des Strings zurück | "Hallo".length | 5 |
localeCompare(other) | Vergleich zweier Strings (Sortierung) | let a ="Wartezeit" | -1 = a dann b |
match(regex) | Sucht nach Regex-Treffern → Array | "abc1".match(/\d/) | ["1"] |
matchAll(regex) | Iterator für alle Regex-Treffer | Nutzung mit for...of nötig | — |
padEnd(len, pad) | Füllt String hinten auf | "5".padEnd(3, ".") | "5.." |
padStart(len, pad) | Füllt String vorne auf | "5".padStart(2, "0") | "05" |
repeat(n) | Wiederholt String | "Ha".repeat(3) | "HaHaHa" |
replace(search, new) | Erstes Auftreten ersetzen | "a-b-a".replace("a", "x") | "x-b-a" |
replaceAll(search, new) | Alle ersetzen | "a-a".replaceAll("a", "x") | "x-x" |
search(regex) | Position eines Regex-Treffers | "abc1".search(/\d/) | 3 |
slice(start, end) | String-Teil extrahieren | "Hallo".slice(1, 4) | "all" |
| String in Array teilen | "a,b,c".split(",") | ["a","b","c"] |
startsWith(substr) | Prüft String-Anfang | "Hello".startsWith("He") | true |
substring(start, end) | Wie slice, aber ohne negative Indizes | "Hallo".substring(1, 4) | "all" |
substr(start, length) | Veraltet – Teilstring ab Start | "Hallo".substr(1, 3) | "all" |
toLowerCase() | Kleinbuchstaben | "Hi".toLowerCase() | "hi" |
toUpperCase() | Großbuchstaben | "Hi".toUpperCase() | "HI" |
trim() | Entfernt Leerzeichen an beiden Enden | " Hi ".trim() | "Hi" |
trimStart() / trimEnd() | Nur vorne / hinten trimmen | " Hi ".trimStart() | "Hi " |
Array-Methoden:
mutierend:
| Methode | Beschreibung | Beispiel | Original verändert? |
|---|---|---|---|
push() | Einfügen hinten | [1,2].push(3) → [1,2,3] | ✅ |
pop() | Entfernt letztes Element | [1,2,3].pop() → [1,2] | ✅ |
shift() | Entfernt erstes Element | [1,2,3].shift() → [2,3] | ✅ |
unshift() | Fügt vorne ein | [2,3].unshift(1) → [1,2,3] | ✅ |
splice() | Entfernt/ersetzt/insert | [1,2,3].splice(1,1) | ✅ |
sort() | Sortiert arrayintern | [3,1].sort() → [1,3] | ✅ |
reverse() | Dreht Reihenfolge um | [1,2].reverse() → [2,1] | ✅ |
copyWithin() | kopiert intern | [1,2,3,4].copyWithin(0,2) | ✅ |
fill() | Bereich füllen | [1,2,3].fill(0,1) | ✅ |
nicht mutierend:
| Methode | Beschreibung | Beispiel | Rückgabe |
|---|---|---|---|
at(index) | Element per Index (negativ möglich) | [1,2,3].at(-1) | Element |
concat(...arrays) | Arrays verbinden | [1].concat([2]) → [1,2] | Neues Array |
entries() | Iterator über [Index, Wert] | for (const e of arr.entries()) | Iterator |
every(fn) | Prüft: treffen alle zu? | [1,2].every(x => x > 0) | Boolean |
filter(fn) | Elemente filtern | [1,2,3].filter(x => x > 1) | Neues Array |
find(fn) | Erstes passendes Element | [1,2].find(x => x > 1) | Element oder undefined |
findIndex(fn) | Index des ersten Treffers | [1,2].findIndex(x => x > 1) | Index |
findLast(fn) | Letztes passendes Element | [1,2,3,1].findLast(x => x===1) | Element |
findLastIndex(fn) | Index des letzten Treffers | [1,2,3,1].findLastIndex(x=>x===1) | Index |
flat(depth?) | Abflachen von Arrays | [1,[2]].flat() | Neues Array |
flatMap(fn) | map + flatten (Tiefe 1) | [1,2].flatMap(x=>[x,x]) | Neues Array |
forEach(fn) | Iteration | [1,2].forEach(...) | undefined |
groupBy(fn) | Gruppieren nach Kriterium | [1,2,3].groupBy(x=>x%2) | Objekt |
groupByToMap(fn) | Wie groupBy, aber Map | [1,2].groupByToMap(fn) | Map |
includes(value) | Enthält Element? | [1,2].includes(2) | Boolean |
indexOf(value) | Suche nach === (erstes Mal) | [1,2].indexOf(2) | Index oder -1 |
join(sep?) | Array → String | [1,2].join("-") | String |
keys() | Iterator über Indizes | for (const k of arr.keys()) | Iterator |
lastIndexOf(value) | Suche nach === (letztes Mal) | [1,2,1].lastIndexOf(1) | Index |
map(fn) | Transformation | [1,2].map(x=>x*2) | Neues Array |
reduce(fn, init?) | Akkumulation | [1,2].reduce(...) | Wert |
reduceRight(fn, init?) | Akkumulation rückwärts | [1,2].reduceRight(...) | Wert |
slice(start, end?) | Teilarray kopieren | [1,2,3].slice(1) | Neues Array |
some(fn) | Prüft: trifft mindestens eins zu? | [1,2].some(x=>x>1) | Boolean |
toLocaleString() | Lokale String-Darstellung | [1].toLocaleString() | String |
toReversed() | Kopie → reverse | [1,2].toReversed() | Neues Array |
toSorted(compareFn?) | Kopie → sortiert | [3,1].toSorted() | Neues Array |
toSpliced(start, deleteCount, ...items) | Nicht-mutierende Variante zu splice | [1,2,3].toSpliced(1,1) | Neues Array |
values() | Iterator über Werte | for (const v of arr.values()) | Iterator |
with(index, value) | Kopie mit geändertem Wert | [1,2,3].with(1,9) | Neues Array |
Higher-Order Methods nehmen Funktionen als Argument und erleichtern funktionales Programmieren, z.B. map, filter, reduce, some, every.
statisch (nicht mutierend):
| Methode | Beschreibung | Beispiel |
|---|---|---|
Array.isArray() | Array-Test | Array.isArray([]) |
Array.from() | Erzeugt Array aus Iterable | Array.from("abc") |
Array.of() | Array aus Argumenten | Array.of(3) |
Duplikate entfernen
function removeDublicates(arr) {
return [...new Set(arr)];
}
const noDubsArr = removeDublicates(dubsArr);Objekt-Methoden:
nicht mutierend:
| Methode | Beschreibung | Beispiel | Rückgabe |
|---|---|---|---|
Object.create(proto, props?) | Neues Objekt auf Basis eines Prototyps | Object.create({a:1}) | Neues Objekt |
Object.entries(obj) | Objekt → Array von [key,value] | Object.entries({a:1}) | [["a",1]] |
Object.fromEntries(iter) | Key/Value-Paare → Objekt | Object.fromEntries([["a",1]]) | {a:1} |
Object.getOwnPropertyDescriptor(obj, prop) | Holt Descriptor einer Eigenschaft | Object.getOwnPropertyDescriptor({a:1}, "a") | Descriptor-Objekt |
Object.getOwnPropertyDescriptors(obj) | Alle Eigenschafts-Deskriptoren | Object.getOwnPropertyDescriptors({a:1}) | Objekt |
Object.getOwnPropertyNames(obj) | Array aller eigenen Keys (inkl. non-enum) | Object.getOwnPropertyNames({a:1}) | ["a"] |
Object.getOwnPropertySymbols(obj) | Symbole als Keys | Object.getOwnPropertySymbols(obj) | Array |
Object.getPrototypeOf(obj) | Prototyp holen | Object.getPrototypeOf({}) | Objekt |
Object.groupBy(arr, fn) | Array gruppieren → Objekt | Object.groupBy([1,2,3], x=>x%2) | {0:[2],1:[1,3]} |
Object.groupByToMap(arr, fn) | Wie groupBy, aber Map | Object.groupByToMap([...], fn) | Map |
Object.hasOwn(obj, prop) | Prüft: hat eigene Property? | Object.hasOwn({a:1}, "a") | Boolean |
Object.is(a, b) | Strikter Vergleich (besser als ===) | Object.is(NaN, NaN) | true |
Object.isExtensible(obj) | Prüft: erweiterbar? | Object.isExtensible({}) | Boolean |
Object.isFrozen(obj) | Prüft: eingefroren? | Object.isFrozen({}) | Boolean |
Object.isSealed(obj) | Prüft: versiegelt? | Object.isSealed({}) | Boolean |
Object.keys(obj) | Nur enumerable-Keys | Object.keys({a:1}) | ["a"] |
Object.values(obj) | Nur enumerable-Werte | Object.values({a:1}) | [1] |
mutierend:
| Methode | Beschreibung | Beispiel | Rückgabewert |
|---|---|---|---|
delete obj.prop | Löscht eine Property | delete obj.a | true / false(ob Property gelöscht wurde) |
Object.assign(target, ...sources) | Kopiert Eigenschaften aus Quellen ins Zielobjekt | Object.assign({a:1},{b:2}) | target (das modifizierte Zielobjekt) |
Object.defineProperty(obj, prop, descriptor) | Definiert eine Property mit detaillierten Attributen (writable, enumerable, configurable, getter/setter) | Object.defineProperty(obj,'x',{value:1,writable:true}) | obj(das modifizierte Objekt) |
Object.defineProperties(obj, descriptors) | Definiert mehrere Properties auf einmal | Object.defineProperties(obj,{x:{value:1},y:{value:2}}) | obj(das modifizierte Objekt) |
Object.freeze(obj) | Macht Objekt komplett unveränderbar (keine neuen Properties, keine Änderungen möglich) | const o = Object.freeze({x:1}) | obj(das eingefrorene Objekt) |
Object.preventExtensions(obj) | Verhindert Hinzufügen neuer Properties | Object.preventExtensions(obj) | obj(Objekt, das keine neuen Props akzeptiert) |
Object.seal(obj) | Verhindert Hinzufügen/Löschen von Properties, Werte können noch geändert werden | const o = Object.seal({x:1}) | obj(versiegeltes Objekt) |
Object.setPrototypeOf(obj, proto) | Setzt das Prototype-Objekt | Object.setPrototypeOf(obj, otherObj) | obj(Objekt mit neuem Prototyp) |
Reflect.deleteProperty(obj, prop) | Löscht Property über Reflect API | Reflect.deleteProperty(obj,'x') | true / false |
Reflect.set(obj, prop, value) | Setzt Property-Wert über Reflect API (mutierend) | Reflect.set(obj,'x',5) | true / false(ob Wert gesetzt wurde) |
Kurzfazit:
| Kategorie | Methoden |
|---|---|
| Objekt → neue Struktur | create, entries, fromEntries |
| Objekt analysieren | hasOwn, is, isExtensible, isFrozen, isSealed, getPrototypeOf |
| Properties auslesen | keys, values, getOwnPropertyNames, getOwnPropertySymbols, getOwnPropertyDescriptors |
| Arrays → gruppierte Objekte | groupBy, groupByToMap |
Sonstiges:
Method Chaining:
[1,2,3,4].filter(x=>x%2===0).map(x=>x*2) // → [4,8]
Objekte iterierbar machen:
for (const [key,value] of Object.entries(obj)) {
console.log(key,value);
}