Ich habe eine Liste von Objekten, die ich basierend auf einem Feld sortieren möchte attr vom Typ String. Ich habe versucht, mit -

list.sort(function (a, b) {
    return a.attr - b.attr
})

aber das gefunden - scheint nicht mit Zeichenfolgen in JavaScript zu funktionieren. Wie kann ich eine Liste von Objekten basierend auf einem Attribut vom Typ Zeichenfolge sortieren?

Verwenden String.prototype.localeCompare a nach deinem beispiel:

list.sort(function (a, b) {
    return ('' + a.attr).localeCompare(b.attr);
})

Wir erzwingen, dass a.attr ein String ist, um Ausnahmen zu vermeiden. localeCompare wurde unterstützt seit Internet Explorer 6 und Firefox 1. Möglicherweise sehen Sie auch den folgenden Code, der kein Gebietsschema berücksichtigt:

if (item1.attr < item2.attr)
  return -1;
if ( item1.attr > item2.attr)
  return 1;
return 0;

Eine aktualisierte Antwort (Oktober 2014)

Ich war wirklich verärgert über diese natürliche Sortierreihenfolge von Strings, also habe ich mir einige Zeit genommen, um dieses Problem zu untersuchen. Ich hoffe das hilft.

Um es kurz zu machen

localeCompare() Zeichenunterstützung ist knallhart, benutze sie einfach. Wie von betont Shog9die Antwort auf Ihre Frage lautet:

return item1.attr.localeCompare(item2.attr);

Fehler, die in allen benutzerdefinierten Javascript-Implementierungen der “natürlichen Zeichenfolgensortierreihenfolge” gefunden wurden

Es gibt eine ganze Reihe von benutzerdefinierten Implementierungen, die versuchen, einen String-Vergleich durchzuführen, der genauer als “natürliche String-Sortierreihenfolge” bezeichnet wird.

Beim “Spielen” mit diesen Implementierungen ist mir immer eine seltsame Wahl der “natürlichen Sortierreihenfolge” aufgefallen, oder besser gesagt Fehler (oder Auslassungen im besten Fall).

Normalerweise werden Sonderzeichen (Leerzeichen, Bindestrich, kaufmännisches Und, Klammern usw.) nicht korrekt verarbeitet.

Sie werden dann feststellen, dass sie an verschiedenen Stellen durcheinander erscheinen, typischerweise könnte das sein:

• einige stehen zwischen dem Großbuchstaben „Z“ und dem Kleinbuchstaben „a“.
• einige werden zwischen der ‘9’ und dem großen ‘A’ stehen
• einige werden nach Kleinbuchstaben ‘z’ sein

Wenn man erwartet hätte, dass Sonderzeichen alle an einer Stelle “gruppiert” werden, außer vielleicht das Leerzeichen (das immer das erste Zeichen wäre). Das heißt, entweder alle vor Zahlen oder alle zwischen Zahlen und Buchstaben (Klein- und Großbuchstaben sind “zusammen” nacheinander) oder alle nach Buchstaben.

Meine Schlussfolgerung ist, dass sie alle keine konsistente Reihenfolge bieten, wenn ich anfange, kaum ungewöhnliche Zeichen hinzuzufügen (dh Zeichen mit diakritischen Zeichen oder Zeichen wie Bindestrich, Ausrufezeichen usw.).

Recherche zu den benutzerdefinierten Implementierungen:

• Natural Compare Lite https://github.com/litejs/natural-compare-lite : Sortiert nicht konsistent https://github.com/litejs/natural-compare-lite/issues/1 und http://jsbin.com/bevututodavi/1/edit?js,console Sortierung der grundlegenden lateinischen Zeichen http://jsbin.com/bevututodavi/5/edit?js,console
• Natural Sort https://github.com/javve/natural-sort : Sortiert nicht konsistent, siehe Problem https://github.com/javve/natural-sort/issues/7 und sehen Sie sich die Sortierung der grundlegenden lateinischen Zeichen an http://jsbin.com/cipimosedoqe/3/edit?js,console
• Javascript Natural Sort https://github.com/overset/javascript-natural-sort : Scheint seit Februar 2012 eher vernachlässigt worden zu sein, Sortiert nicht konsequent, siehe Problem https://github.com/overset/javascript-natural-sort/issues/16
• Alphanum http://www.davekoelle.com/files/alphanum.js schlägt beim Sortieren fehl, siehe http://jsbin.com/tuminoxifuyo/1/edit?js,console

Die nativen Implementierungen der Browser für die “natürliche Zeichenfolgensortierung” via localeCompare()

localeCompare() Die älteste Implementierung (ohne die Locales- und Optionsargumente) wird von IE6+ unterstützt, siehe http://msdn.microsoft.com/en-us/library/ie/s4esdbwz(v=vs.94).aspx (Scrollen Sie nach unten zur Methode localeCompare()). Das eingebaute localeCompare() -Methode ist beim Sortieren viel besser, sogar bei internationalen und Sonderzeichen. Das einzige Problem mit der localeCompare() Methode ist das “Das verwendete Gebietsschema und die verwendete Sortierreihenfolge sind vollständig von der Implementierung abhängig”. Mit anderen Worten, wenn Sie localeCompare wie stringOne.localeCompare(stringTwo) verwenden: Firefox, Safari, Chrome und IE haben eine andere Sortierreihenfolge für Strings.

Recherche zu den Browser-nativen Implementierungen:

• http://jsbin.com/beboroyifomu/1/edit?js,console – Vergleich einfacher lateinischer Zeichen mit localeCompare()
  http://jsbin.com/viyucavudela/2/ – Vergleich grundlegender lateinischer Zeichen mit localeCompare() zum Testen auf IE8
• http://jsbin.com/beboroyifomu/2/edit?js,console – Grundlegende lateinische Zeichen im Zeichenkettenvergleich: Konsistenzprüfung in der Zeichenkette vs. wenn ein Zeichen allein steht
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare – IE11+ unterstützt die neuen Locales & Options-Argumente

Schwierigkeit der “string natural sorting order”

Die Implementierung eines soliden Algorithmus (d. h. konsistent, aber auch für eine breite Palette von Zeichen) ist eine sehr schwierige Aufgabe. UTF8 enthält mehr als 2000 Zeichen & umfasst mehr als 120 Schriften (Sprachen). Schließlich gibt es einige Spezifikationen für diese Aufgaben, sie werden “Unicode Collation Algorithm” genannt und sind unter zu finden http://www.unicode.org/reports/tr10/ . Weitere Informationen dazu finden Sie in dieser Frage, die ich gepostet habe https://softwareengineering.stackexchange.com/questions/257286/is-there-any-language-agnostic-specification-for-string-natural-sorting-order

Schlußfolgerung

In Anbetracht des aktuellen Unterstützungsniveaus der benutzerdefinierten Javascript-Implementierungen, auf die ich gestoßen bin, werden wir wahrscheinlich nie etwas sehen, das auch nur annähernd all diese Zeichen und Skripte (Sprachen) unterstützt. Daher würde ich lieber die native Methode localeCompare() des Browsers verwenden. Ja, es hat den Nachteil, dass es in verschiedenen Browsern nicht konsistent ist, aber grundlegende Tests zeigen, dass es eine viel größere Bandbreite an Zeichen abdeckt und solide und aussagekräftige Sortierreihenfolgen ermöglicht.

Also wie von hervorgehoben Shog9die Antwort auf Ihre Frage lautet:

return item1.attr.localeCompare(item2.attr);

Weiterlesen:

• https://softwareengineering.stackexchange.com/questions/257286/is-there-any-language-agnostic-specification-for-string-natural-sorting-order
• Wie führen Sie einen Zeichenfolgenvergleich in JavaScript durch?
• Javascript : natürliche Art von alphanumerischen Zeichenfolgen
• Sort Array aus numerischen und alphabetischen Elementen (natürliche Sortierung)
• Gemischtes alpha/numerisches Array sortieren
• https://web.archive.org/web/20130929122019/http://my.opera.com/GreyWyvern/blog/show.dml/1671288
• https://web.archive.org/web/20131005224909/http://www.davekoelle.com/alphanum.html
• http://snipplr.com/view/36012/javascript-natural-sort/
• http://blog.codinghorror.com/sorting-for-humans-natural-sort-order/

Danke an die nette Antwort von Shog9, die mich, glaube ich, in die “richtige” Richtung gebracht hat

Antwort (in modernem ECMAScript)

list.sort((a, b) => (a.attr > b.attr) - (a.attr < b.attr))

Oder

list.sort((a, b) => +(a.attr > b.attr) || -(a.attr < b.attr))

Beschreibung

Das Umwandeln eines booleschen Werts in eine Zahl ergibt Folgendes:

• true -> 1
• false -> 0

Betrachten Sie drei mögliche Muster:

• x ist größer als y: (x > y) - (y < x) -> 1 - 0 -> 1
• x ist gleich y: (x > y) - (y < x) -> 0 - 0 -> 0
• x ist kleiner als y: (x > y) - (y < x) -> 0 - 1 -> -1

(Alternative)

• x ist größer als y: +(x > y) || -(x < y) -> 1 || 0 -> 1
• x ist gleich y: +(x > y) || -(x < y) -> 0 || 0 -> 0
• x ist kleiner als y: +(x > y) || -(x < y) -> 0 || -1 -> -1

Diese Logiken sind also äquivalent zu typischen Sortierkomparatorfunktionen.

if (x == y) {
    return 0;
}
return x > y ? 1 : -1;

Da Zeichenfolgen direkt in Javascript verglichen werden können, wird dies die Aufgabe erledigen

list.sort(function (a, b) {
    return a.attr > b.attr ? 1: -1;
})

Die Subtraktion in einer Sortierfunktion wird nur verwendet, wenn eine nicht alphabetische (numerische) Sortierung gewünscht wird, und funktioniert natürlich nicht mit Zeichenfolgen

Sie sollten hier > oder < und == verwenden. Die Lösung wäre also:

list.sort(function(item1, item2) {
    var val1 = item1.attr,
        val2 = item2.attr;
    if (val1 == val2) return 0;
    if (val1 > val2) return 1;
    if (val1 < val2) return -1;
});

Verschachtelte ternäre Pfeilfunktion

(a,b) => (a < b ? -1 : a > b ? 1 : 0)

Ich hatte mich lange darüber Gedanken gemacht, also habe ich das endlich recherchiert und Ihnen diesen langatmigen Grund dafür gegeben, warum die Dinge so sind, wie sie sind.

Von dem spez:

Section 11.9.4   The Strict Equals Operator ( === )

The production EqualityExpression : EqualityExpression === RelationalExpression
is evaluated as follows: 
- Let lref be the result of evaluating EqualityExpression.
- Let lval be GetValue(lref).
- Let rref be the result of evaluating RelationalExpression.
- Let rval be GetValue(rref).
- Return the result of performing the strict equality comparison 
  rval === lval. (See 11.9.6)

Also gehen wir jetzt zu 11.9.6

11.9.6   The Strict Equality Comparison Algorithm

The comparison x === y, where x and y are values, produces true or false. 
Such a comparison is performed as follows: 
- If Type(x) is different from Type(y), return false.
- If Type(x) is Undefined, return true.
- If Type(x) is Null, return true.
- If Type(x) is Number, then
...
- If Type(x) is String, then return true if x and y are exactly the 
  same sequence of characters (same length and same characters in 
  corresponding positions); otherwise, return false.

Das ist es. Der auf Strings angewendete Triple-Equals-Operator gibt „true“ zurück, wenn die Argumente genau die gleichen Strings sind (gleiche Länge und gleiche Zeichen an entsprechenden Positionen).

Damit === funktioniert in den Fällen, in denen wir versuchen, Zeichenfolgen zu vergleichen, die möglicherweise aus verschiedenen Quellen stammen, von denen wir aber wissen, dass sie letztendlich dieselben Werte haben werden – ein Szenario, das häufig genug für Inline-Zeichenfolgen in unserem Code ist. Wenn wir zum Beispiel eine Variable mit dem Namen haben connection_stateund wir möchten wissen, welcher der folgenden Zustände ist ['connecting', 'connected', 'disconnecting', 'disconnected'] ist es gerade drin, können wir das direkt verwenden ===.

Aber es gibt noch mehr. Direkt über 11.9.4 gibt es einen kurzen Hinweis:

NOTE 4     
  Comparison of Strings uses a simple equality test on sequences of code 
  unit values. There is no attempt to use the more complex, semantically oriented
  definitions of character or string equality and collating order defined in the 
  Unicode specification. Therefore Strings values that are canonically equal
  according to the Unicode standard could test as unequal. In effect this 
  algorithm assumes that both Strings are already in normalized form.

Hmm. Was jetzt? Extern erhaltene Strings können und werden höchstwahrscheinlich seltsam unicodey und unsere sanft sein === wird ihnen nicht gerecht. Herein kommt localeCompare zur Rettung:

15.5.4.9   String.prototype.localeCompare (that)
    ...
    The actual return values are implementation-defined to permit implementers 
    to encode additional information in the value, but the function is required 
    to define a total ordering on all Strings and to return 0 when comparing
    Strings that are considered canonically equivalent by the Unicode standard. 

Wir können jetzt nach Hause gehen.

tl;dr;

Verwenden Sie zum Vergleichen von Zeichenfolgen in Javascript localeCompare; wenn Sie wissen, dass die Zeichenketten keine Nicht-ASCII-Komponenten enthalten, weil es sich beispielsweise um interne Programmkonstanten handelt, dann === funktioniert auch.