Signatur
Beschreibung
Die Methode sort() von Array-Instanzen sortiert die Elemente eines Arrays in-place und gibt die Referenz auf dasselbe, nun sortierte Array zurück. Die Standard-Sortierreihenfolge ist aufsteigend, basierend auf der Umwandlung der Elemente in Strings und dem anschließenden Vergleich ihrer Sequenzen von UTF-16-Code-Unit-Werten.
Die Zeit- und Speicherkomplexität der Sortierung kann nicht garantiert werden, da sie von der Implementierung abhängt.
Um die Elemente eines Arrays zu sortieren, ohne das ursprüngliche Array zu verändern, verwende toSorted().
Wenn compareFn nicht angegeben wird, werden alle nicht-undefined-Array-Elemente sortiert, indem sie in Strings umgewandelt und die Strings in UTF-16-Code-Unit-Reihenfolge verglichen werden. Zum Beispiel kommt "banana" vor "cherry". Bei einer numerischen Sortierung kommt 9 vor 80, aber da Zahlen in Strings umgewandelt werden, kommt "80" in der Unicode-Reihenfolge vor "9". Alle undefined-Elemente werden ans Ende des Arrays sortiert.
Die Methode sort() bewahrt leere Slots. Wenn das Quell-Array sparse ist, werden die leeren Slots ans Ende des Arrays verschoben und kommen immer nach allen undefined-Werten.
Hinweis: In UTF-16 werden Unicode-Zeichen oberhalb von \uFFFF als zwei Surrogate-Code-Units im Bereich \uD800 - \uDFFF kodiert. Der Wert jeder Code-Unit wird für den Vergleich separat berücksichtigt. Somit wird das aus dem Surrogatpaar \uD855\uDE51 gebildete Zeichen vor dem Zeichen \uFF3A einsortiert.
Wenn compareFn angegeben wird, werden alle nicht-undefined-Array-Elemente entsprechend dem Rückgabewert der Vergleichsfunktion sortiert (alle undefined-Elemente werden ans Ende des Arrays sortiert, ohne dass compareFn aufgerufen wird).
compareFn(a, b)Rückgabewert > 0:anachbsortieren, z. B.[b, a]compareFn(a, b)Rückgabewert < 0:avorbsortieren, z. B.[a, b]compareFn(a, b)Rückgabewert === 0: ursprüngliche Reihenfolge vonaundbbeibehalten
Formaler ausgedrückt sollte der Komparator die folgenden Eigenschaften haben, um korrektes Sortierverhalten zu gewährleisten:
- Pure: Der Komparator verändert weder die verglichenen Objekte noch externen Zustand. (Das ist wichtig, weil es keine Garantie gibt, wann und wie der Komparator aufgerufen wird, sodass ein einzelner Aufruf keine nach außen sichtbaren Effekte erzeugen sollte.)
- Stable: Der Komparator liefert für dasselbe Eingabepaar dasselbe Ergebnis.
- Reflexive:
compareFn(a, a) === 0. - Anti-symmetric:
compareFn(a, b)undcompareFn(b, a)müssen entweder beide0sein oder entgegengesetzte Vorzeichen haben. - Transitive: Wenn
compareFn(a, b)undcompareFn(b, c)beide positiv, null oder negativ sind, dann hatcompareFn(a, c)dieselbe Positivität wie die beiden vorherigen.
Ein Komparator, der die oben genannten Bedingungen erfüllt, kann immer alle Werte 1, 0 und -1 zurückgeben oder konsistent 0. Gibt ein Komparator zum Beispiel nur 1 und 0 oder nur 0 und -1 zurück, kann er nicht zuverlässig sortieren, weil die Anti-Symmetrie verletzt ist. Ein Komparator, der immer 0 zurückgibt, führt dazu, dass das Array überhaupt nicht verändert wird, ist aber dennoch zuverlässig.
Der standardmäßige lexikografische Komparator erfüllt alle oben genannten Bedingungen.
Um Zahlen anstelle von Strings zu vergleichen, kann die Vergleichsfunktion b von a subtrahieren. Die folgende Funktion sortiert das Array aufsteigend (sofern es kein NaN enthält).
Die Methode sort() ist generisch. Sie erwartet lediglich, dass der this-Wert eine length-Eigenschaft und ganzzahlig indizierte Eigenschaften hat. Obwohl Strings ebenfalls array-ähnlich sind, ist diese Methode nicht dazu geeignet, auf sie angewendet zu werden, da Strings unveränderlich sind.
Parameter
| Name | Typ | Default | Beschreibung |
|---|---|---|---|
| $compareFn | Function | — | Eine Funktion, die die Reihenfolge der Elemente bestimmt. Die Funktion wird mit zwei Argumenten aufgerufen: a (das erste Element für den Vergleich; niemals undefined) und b (das zweite Element für den Vergleich; niemals undefined). Sie soll eine Zahl zurückgeben, wobei: ein negativer Wert bedeutet, dass a vor b stehen soll; ein positiver Wert bedeutet, dass a nach b stehen soll; null oder NaN bedeutet, dass a und b als gleich betrachtet werden. Als Merkhilfe: (a, b) => a - b sortiert Zahlen aufsteigend. Wird sie weggelassen, werden die Array-Elemente in Strings umgewandelt und nach dem Unicode-Codepoint-Wert jedes Zeichens sortiert. |
Rückgabewert
Beispiele
Erstellen, Anzeigen und Sortieren eines Arrays
const stringArray = ["Blue", "Humpback", "Beluga"];
const numberArray = [40, 1, 5, 200];
const numericStringArray = ["80", "9", "700"];
const mixedNumericArray = ["80", "9", "700", 40, 1, 5, 200];
function compareNumbers(a, b) {
return a - b;
}
stringArray.join(); // 'Blue,Humpback,Beluga'
stringArray.sort(); // ['Beluga', 'Blue', 'Humpback']
numberArray.join(); // '40,1,5,200'
numberArray.sort(); // [1, 200, 40, 5]
numberArray.sort(compareNumbers); // [1, 5, 40, 200]
numericStringArray.join(); // '80,9,700'
numericStringArray.sort(); // ['700', '80', '9']
numericStringArray.sort(compareNumbers); // ['9', '80', '700']
mixedNumericArray.join(); // '80,9,700,40,1,5,200'
mixedNumericArray.sort(); // [1, 200, 40, 5, '700', '80', '9']
mixedNumericArray.sort(compareNumbers); // [1, 5, '9', 40, '80', 200, '700']Array aus Objekten sortieren
const items = [
{ name: "Edward", value: 21 },
{ name: "Sharpe", value: 37 },
{ name: "And", value: 45 },
{ name: "The", value: -12 },
{ name: "Magnetic", value: 13 },
{ name: "Zeros", value: 37 },
];
// sort by value
items.sort((a, b) => a.value - b.value);
// sort by name
items.sort((a, b) => {
const nameA = a.name.toUpperCase(); // ignore upper and lowercase
const nameB = b.name.toUpperCase(); // ignore upper and lowercase
if (nameA < nameB) {
return -1;
}
if (nameA > nameB) {
return 1;
}
// names must be equal
return 0;
});Sortieren von Nicht-ASCII-Zeichen
const items = ["réservé", "premier", "communiqué", "café", "adieu", "éclair"];
items.sort((a, b) => a.localeCompare(b));
// items is ['adieu', 'café', 'communiqué', 'éclair', 'premier', 'réservé']Sortieren mit map
// the array to be sorted
const data = ["delta", "alpha", "charlie", "bravo"];
// temporary array holds objects with position and sort-value
const mapped = data.map((v, i) => ({ i, value: someSlowOperation(v) }));
// sorting the mapped array containing the reduced values
mapped.sort((a, b) => {
if (a.value > b.value) {
return 1;
}
if (a.value < b.value) {
return -1;
}
return 0;
});
const result = mapped.map((v) => data[v.i]);sort() gibt die Referenz auf dasselbe Array zurück
const numbers = [3, 1, 4, 1, 5];
const sorted = numbers.sort((a, b) => a - b);
// numbers and sorted are both [1, 1, 3, 4, 5]
sorted[0] = 10;
console.log(numbers[0]); // 10Ohne Mutation via Shallow Copy
const numbers = [3, 1, 4, 1, 5];
// [...numbers] creates a shallow copy, so sort() does not mutate the original
const sorted = [...numbers].sort((a, b) => a - b);
sorted[0] = 10;
console.log(numbers[0]); // 3Sortier-Stabilität
const students = [
{ name: "Alex", grade: 15 },
{ name: "Devlin", grade: 15 },
{ name: "Eagle", grade: 13 },
{ name: "Sam", grade: 14 },
];
students.sort((firstItem, secondItem) => firstItem.grade - secondItem.grade);
// Ergebnis:
// [
// { name: "Eagle", grade: 13 },
// { name: "Sam", grade: 14 },
// { name: "Alex", grade: 15 },
// { name: "Devlin", grade: 15 },
// ];Sortieren mit nicht wohlgeformtem Komparator
const arr = [3, 1, 4, 1, 5, 9];
const compareFn = (a, b) => (a > b ? 1 : 0);
arr.sort(compareFn);sort() bei sparse Arrays
console.log(["a", "c", , "b"].sort()); // ['a', 'b', 'c', empty]
console.log([, undefined, "a", "b"].sort()); // ["a", "b", undefined, empty]sort() auf Nicht-Array-Objekten
const arrayLike = {
length: 3,
unrelated: "foo",
0: 5,
2: 4,
};
console.log(Array.prototype.sort.call(arrayLike));
// { '0': 4, '1': 5, length: 3, unrelated: 'foo' }// Wichtig · Fallstricke
Array.prototype.sort stabil ist. Vor Version 10 war die Sortier-Stabilität nicht garantiert. Aufgrund von Implementierungs-Inkonsistenzen ist es ratsam, den Komparator wohlgeformt zu gestalten, indem die fünf Bedingungen (Pure, Stable, Reflexive, Anti-symmetric, Transitive) eingehalten werden.