Array.prototype.sort()

Probieren Sie es aus

const months = ["March", "Jan", "Feb", "Dec"];
months.sort();
console.log(months);
// Expected output: Array ["Dec", "Feb", "Jan", "March"]

const array = [1, 30, 4, 21, 100000];
array.sort();
console.log(array);
// Expected output: Array [1, 100000, 21, 30, 4]

Syntax

sort()
sort(compareFn)

Parameter

compareFn Optional

Eine Funktion, die die Reihenfolge der Elemente bestimmt. Die Funktion wird mit den folgenden Argumenten aufgerufen:

a

Das erste Element zum Vergleich. Wird niemals undefined sein.

b

Das zweite Element zum Vergleich. Wird niemals undefined sein.

Sie sollte eine Zahl zurckgeben, wobei:

• Ein negativer Wert anzeigt, dass a vor b kommen soll.
• Ein positiver Wert anzeigt, dass a nach b kommen soll.
• Null oder NaN anzeigt, dass a und b als gleich betrachtet werden.

Um sich dies zu merken: (a, b) => a - b sortiert Zahlen in aufsteigender Reihenfolge.

Wenn nicht angegeben, werden die Array-Elemente in Strings konvertiert und dann gem dem Unicode-Codepunktwert jedes Zeichens sortiert.

Rckgabewert

Die Referenz auf das ursprngliche, nun sortierte Array. Beachten Sie, dass das Array in place sortiert wird und keine Kopie erstellt wird.

Beschreibung

Wenn compareFn nicht angegeben ist, werden alle nicht-undefined Array-Elemente durch Konvertieren in Strings und Vergleichen der Strings in UTF-16-Codeeinheitenreihenfolge sortiert. Zum Beispiel kommt "banana" vor "cherry". Bei einer numerischen Sortierung kommt 9 vor 80, aber da Zahlen in Strings konvertiert werden, kommt "80" im Unicode vor "9". Alle undefined-Elemente werden an das Ende des Arrays sortiert.

Die sort()-Methode bewahrt leere Slots. Wenn das Quell-Array sparse ist, werden die leeren Slots an das Ende des Arrays verschoben und kommen immer nach allen undefined.

Wenn compareFn angegeben ist, werden alle nicht-undefined Array-Elemente gem dem Rckgabewert der Vergleichsfunktion sortiert (alle undefined-Elemente werden ans Ende des Arrays sortiert, ohne dass compareFn aufgerufen wird).

Die Vergleichsfunktion hat somit die folgende Form:

function compareFn(a, b) {
  if (a is less than b by some ordering criterion) {
    return -1;
  } else if (a is greater than b by the ordering criterion) {
    return 1;
  }
  // a must be equal to b
  return 0;
}

Formell sollte der Vergleich folgende Eigenschaften haben, um das korrekte Sortierverhalten zu gewhrleisten:

• Pure: Der Vergleich verndert nicht die zu vergleichenden Objekte oder einen anderen ueren Zustand. (Dies ist wichtig, weil es keine Garantie gibt, wann und wie der Vergleich aufgerufen wird, daher sollte ein bestimmter Aufruf keine sichtbaren Effekte nach auen haben.)
• Stabil: Der Vergleich gibt fr dasselbe Paar von Eingaben dasselbe Ergebnis zurck.
• Reflexiv: compareFn(a, a) === 0.
• Anti-symmetrisch: compareFn(a, b) und compareFn(b, a) mssen beide 0 oder entgegengesetzte Vorzeichen haben.
• Transitiv: Wenn compareFn(a, b) und compareFn(b, c) beide positiv, null oder negativ sind, hat compareFn(a, c) dieselbe Positivitt wie die vorherigen zwei.

Ein Vergleich, der die oben genannten Einschrnkungen erfllt, kann immer 1, 0 und -1 zurckgeben, oder konsistent 0 zurckgeben. Ein Vergleich, der immer 0 zurckgibt, fhrt dazu, dass das Array nicht verndert wird, ist aber dennoch zuverlssig.

Der Standard-Lexikografische-Vergleich entspricht allen oben genannten Einschrnkungen.

Um Zahlen anstelle von Strings zu vergleichen, kann die Vergleichsfunktion b von a subtrahieren. Die folgende Funktion sortiert das Array in aufsteigender Reihenfolge (sofern es kein NaN enthlt):

function compareNumbers(a, b) {
  return a - b;
}

Die sort()-Methode ist generisch. Sie erwartet nur, dass der this-Wert eine length-Eigenschaft und integer-indizierte Eigenschaften hat. Obwohl Strings auch array-hnlich sind, eignet sich diese Methode nicht dafr, auf ihnen angewendet zu werden, da Strings unvernderlich sind.

Beispiele

Erstellen, Anzeigen und Sortieren eines Arrays

Das folgende Beispiel erstellt vier Arrays und zeigt das ursprngliche Array, dann die sortierten Arrays an. Die numerischen Arrays werden ohne Vergleichsfunktion sortiert und danach mit einer.

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']

Sortieren von Arrays von Objekten

Arrays von Objekten knnen sortiert werden, indem der Wert einer ihrer Eigenschaften verglichen wird.

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

Um Strings mit nicht-ASCII-Zeichen zu sortieren, das heit Strings mit Akzentbuchstaben (e, , , a, usw.), Strings aus anderen Sprachen als Englisch, verwenden Sie String.prototype.localeCompare(). Diese Funktion kann diese Zeichen vergleichen, sodass sie in der richtigen Reihenfolge erscheinen.

const items = ["rserv", "premier", "communiqu", "caf", "adieu", "clair"];
items.sort((a, b) => a.localeCompare(b));

// items is ['adieu', 'caf', 'communiqu', 'clair', 'premier', 'rserv']

Sortieren mit map

Die compareFn kann innerhalb des Arrays mehrmals pro Element aufgerufen werden. Abhngig von der Art der compareFn kann dies einen hohen Overhead verursachen. Je mehr Arbeit eine compareFn leistet und je mehr Elemente es zu sortieren gibt, desto effizienter kann es sein, map() fr das Sortieren zu verwenden. Die Idee ist, das Array einmal zu durchlaufen, um die tatschlichen Werte in ein temporres Array zu extrahieren, das fr das Sortieren verwendet wird, das temporre Array zu sortieren und dann das temporre Array zu durchlaufen, um die richtige Reihenfolge zu erreichen.

// 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]);

Es gibt eine Open-Source-Bibliothek namens mapsort, die diesen Ansatz verfolgt.

sort() gibt die Referenz auf dasselbe Array zurck

Die sort()-Methode gibt eine Referenz auf das ursprngliche Array zurck, sodass die nderung des zurckgegebenen Arrays auch das ursprngliche Array ndert.

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]); // 10

Falls Sie mchten, dass sort() das ursprngliche Array nicht modifiziert, sondern ein flach-kopiertes Array zurckgibt, wie es andere Array-Methoden tun (z.B. map()), verwenden Sie die toSorted()-Methode. Alternativ knnen Sie eine flache Kopie erstellen, bevor Sie sort() aufrufen, indem Sie die Spread-Syntax oder Array.from() verwenden.

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]); // 3

Stabilitt der Sortierung

Seit Version 10 (oder ECMAScript 2019) gibt die Spezifikation vor, dass Array.prototype.sort stabil ist.

Zum Beispiel, nehmen Sie an, Sie htten eine Liste von Schlern zusammen mit ihren Noten. Beachten Sie, dass die Schlerliste bereits nach Namen in alphabetischer Reihenfolge vorsortiert ist:

const students = [
  { name: "Alex", grade: 15 },
  { name: "Devlin", grade: 15 },
  { name: "Eagle", grade: 13 },
  { name: "Sam", grade: 14 },
];

Nach dem Sortieren dieses Arrays nach grade in aufsteigender Reihenfolge:

students.sort((firstItem, secondItem) => firstItem.grade - secondItem.grade);

Der students-Variable wird dann den folgenden Wert haben:

[
  { name: "Eagle", grade: 13 },
  { name: "Sam", grade: 14 },
  { name: "Alex", grade: 15 }, // original maintained for similar grade (stable sorting)
  { name: "Devlin", grade: 15 }, // original maintained for similar grade (stable sorting)
];

Es ist wichtig zu beachten, dass Schler mit derselben Note (zum Beispiel Alex und Devlin) in derselben Reihenfolge wie vor dem Aufruf der Sortierung bleiben. Dies ist, was ein stabiler Sortieralgorithmus garantiert.

Vor Version 10 (oder ECMAScript 2019) war die Stabilitt der Sortierung nicht garantiert, was bedeutete, dass Sie mglicherweise das folgende Ergebnis erhalten knnten:

[
  { name: "Eagle", grade: 13 },
  { name: "Sam", grade: 14 },
  { name: "Devlin", grade: 15 }, // original order not maintained
  { name: "Alex", grade: 15 }, // original order not maintained
];

Sortieren mit nicht gut geformtem Vergleichsoperator

Wenn eine Vergleichsfunktion nicht alle Regeln von Reinheit, Stabilitt, Reflexivitt, Anti-Symmetrie und Transitivitt, wie in der Beschreibung erklrt, einhlt, ist das Verhalten des Programms nicht wohldefiniert.

Betrachten Sie zum Beispiel diesen Code:

const arr = [3, 1, 4, 1, 5, 9];
const compareFn = (a, b) => (a > b ? 1 : 0);
arr.sort(compareFn);

Die compareFn-Funktion hier ist nicht gut geformt, da sie nicht die Anti-Symmetrie erfllt: Wenn a > b, gibt sie 1 zurck; aber wenn a und b vertauscht werden, gibt sie 0 anstelle eines negativen Werts zurck. Daher wird das resultierende Array je nach Engine unterschiedlich sein. Zum Beispiel wrden V8 (verwendet von Chrome, Node.js, etc.) und JavaScriptCore (verwendet von Safari) das Array berhaupt nicht sortieren und [3, 1, 4, 1, 5, 9] zurckgeben, whrend SpiderMonkey (verwendet von Firefox) das Array aufsteigend sortiert zurckgeben wird, als [1, 1, 3, 4, 5, 9].

Wenn die compareFn-Funktion jedoch leicht so gendert wird, dass sie -1 oder 0 zurckgibt:

const arr = [3, 1, 4, 1, 5, 9];
const compareFn = (a, b) => (a > b ? -1 : 0);
arr.sort(compareFn);

Dann sortieren V8 und JavaScriptCore es absteigend, als [9, 5, 4, 3, 1, 1], whrend SpiderMonkey es unverndert zurckgibt: [3, 1, 4, 1, 5, 9].

Aufgrund dieser Implementierungskonsistenz wird immer empfohlen, Ihren Vergleich so zu gestalten, dass er den fnf Einschrnkungen entspricht.

Verwenden von sort() auf sparsamen Arrays

Leere Slots werden an das Ende des Arrays verschoben.

console.log(["a", "c", , "b"].sort()); // ['a', 'b', 'c', empty]
console.log([, undefined, "a", "b"].sort()); // ["a", "b", undefined, empty]

Aufrufen von sort() auf Nicht-Array-Objekten

Die sort()-Methode liest die length-Eigenschaft von this. Sie sammelt dann alle vorhandenen integer-indizierten Eigenschaften im Bereich von 0 bis length - 1, sortiert sie und schreibt sie zurck. Wenn es fehlende Eigenschaften in dem Bereich gibt, werden die entsprechenden angehngten Eigenschaften gelscht, als ob die nicht existierenden Eigenschaften zum Ende sortiert wurden.

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' }

Spezifikationen

Browser-Kompatibilitt

Siehe auch

• Polyfill von Array.prototype.sort mit modernem Verhalten wie stabile Sortierung in core-js
• Leitfaden zu indizierten Sammlungen
• Array
• Array.prototype.reverse()
• Array.prototype.toSorted()
• String.prototype.localeCompare()
• TypedArray.prototype.sort()
• Konzepte der Sortierung in V8 auf v8.dev (2018)
• Stabile Array.prototype.sort auf v8.dev (2019)
• Array.prototype.sort-Stabilitt von Mathias Bynens