Ich habe eine Liste von Objekten, die ich basierend auf einem Feld attrvom Typ Zeichenfolge sortieren möchte . Ich habe es versucht-

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

Es wurde jedoch festgestellt, dass -dies mit Zeichenfolgen in JavaScript nicht funktioniert. Wie kann ich eine Liste von Objekten basierend auf einem Attribut mit Typzeichenfolge sortieren?

Verwenden Sie String.prototype.localeCompareein Beispiel:

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

Wir erzwingen, dass a.attr eine Zeichenfolge ist, um Ausnahmen zu vermeiden. localeComparewird seit Internet Explorer 6 und Firefox 1 unterstützt. Möglicherweise wird auch der folgende verwendete Code angezeigt, der ein Gebietsschema nicht 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, daher habe ich einige Zeit gebraucht, um dieses Problem zu untersuchen. Ich hoffe das hilft.

Um es kurz zu machen

localeCompare()Charakterunterstützung ist schlecht, benutze sie einfach. Wie bereits erwähnt, Shog9lautet die Antwort auf Ihre Frage:

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

Fehler, die in allen benutzerdefinierten Javascript-Implementierungen "Sortierung nach natürlicher Zeichenfolge" gefunden wurden

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

Beim "Spielen" mit diesen Implementierungen fiel mir immer eine seltsame "natürliche Sortierreihenfolge" auf, oder eher Fehler (oder Auslassungen im besten Fall).

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

Sie werden dann feststellen, dass sie an verschiedenen Stellen gemischt erscheinen. Dies kann normalerweise sein:

• Einige werden zwischen dem Großbuchstaben 'Z' und dem Kleinbuchstaben 'a' stehen.
• Einige werden zwischen der '9' und dem Großbuchstaben 'A' stehen.
• einige werden nach Kleinbuchstaben 'z' stehen

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

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

Recherche zu benutzerdefinierten Implementierungen:

• Natural Compare Lite https://github.com/litejs/natural-compare-lite : Fehler beim konsistenten Sortieren https://github.com/litejs/natural-compare-lite/issues/1 und http://jsbin.com/bevututodavi/ 1 / edit? Js, Konsole , grundlegende lateinische Zeichen sortieren http://jsbin.com/bevututodavi/5/edit?js,console
• Natural Sort https://github.com/javve/natural-sort : Fehler beim konsistenten Sortieren, siehe Problem https://github.com/javve/natural-sort/issues/7 und grundlegende lateinische Zeichen beim Sortieren von http: // jsbin. com / cipimosedoqe / 3 / edit? js, Konsole
• Javascript Natural Sort https://github.com/overset/javascript-natural-sort : scheint seit Februar 2012 eher vernachlässigt zu sein. Fehler beim konsistenten Sortieren, siehe Ausgabe https://github.com/overset/javascript-natural-sort/issues/16
• Alphanum http://www.davekoelle.com/files/alphanum.js , Fehler beim konsistenten Sortieren, siehe http://jsbin.com/tuminoxifuyo/1/edit?js,console

Browsers native "Natural String Sort Order" -Implementierungen über localeCompare()

localeCompare()Die älteste Implementierung (ohne die Argumente für Gebietsschemas und Optionen) wird von IE6 + unterstützt (siehe http://msdn.microsoft.com/en-us/library/ie/s4esdbwz(v=vs.94).aspx (scrollen Sie nach unten zu localeCompare ()). ) Methode). Die integrierte localeCompare()Methode eignet sich viel besser zum Sortieren, auch für internationale und Sonderzeichen. Das einzige Problem bei der Verwendung der localeCompare()Methode besteht darin, dass "das verwendete Gebietsschema und die verwendete Sortierreihenfolge vollständig von der Implementierung abhängen". 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 der grundlegenden lateinischen Zeichen mit localeCompare () http://jsbin.com/viyucavudela/2/ - Vergleich der grundlegenden lateinischen Zeichen mit localeCompare () zum Testen auf IE8
• http://jsbin.com/beboroyifomu/2/edit?js,console - grundlegende lateinische Zeichen im Zeichenfolgenvergleich: Konsistenzprüfung in Zeichenfolge im Vergleich zu einem einzelnen Zeichen
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare - IE11 + unterstützt die neuen Argumente für Gebietsschemas und Optionen

Schwierigkeit der "natürlichen Sortierreihenfolge der Zeichenfolge"

Die Implementierung eines soliden Algorithmus (dh konsistent, aber auch für eine Vielzahl von Zeichen) ist eine sehr schwierige Aufgabe. UTF8 enthält mehr als 2000 Zeichen und umfasst mehr als 120 Skripte (Sprachen) . Schließlich gibt es einige Spezifikationen für diese Aufgaben, die als "Unicode-Kollatierungsalgorithmus" bezeichnet werden und unter http://www.unicode.org/reports/tr10/ zu finden sind . Weitere Informationen hierzu finden Sie zu dieser Frage, die ich unter /software/257286/is-there-any-language-agnostic-specification-for-string-natural-sorting-order veröffentlicht habe

Schlußfolgerung

In Anbetracht des aktuellen Unterstützungsniveaus der benutzerdefinierten Javascript-Implementierungen, auf die ich gestoßen bin, werden wir wahrscheinlich nie sehen, dass irgendetwas der Unterstützung all dieser Zeichen und Skripte (Sprachen) nahe kommt. Daher würde ich lieber die native localeCompare () -Methode des Browsers verwenden. Ja, es hat den Nachteil, dass es in allen Browsern nicht konsistent ist, aber grundlegende Tests zeigen, dass es einen viel größeren Bereich von Zeichen abdeckt und solide und aussagekräftige Sortierreihenfolgen ermöglicht.

Wie bereits erwähnt, Shog9lautet die Antwort auf Ihre Frage:

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

Weiterführende Literatur:

• /software/257286/is-there-any-language-agnostic-specification-for-string-natural-sorting-order
• Wie führt man einen Zeichenfolgenvergleich in JavaScript durch?
• Javascript: natürliche Art von alphanumerischen Zeichenfolgen
• Sortieren Array von numerischen und alphabetischen Elementen (natürliche Sortierung)
• Sortieren Sie gemischte alphanumerische Arrays
• 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/

Dank der netten Antwort von Shog9, die mich in die "richtige" Richtung gebracht hat, glaube ich

Antwort (in Modern 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 Logik entspricht also typischen Sortierkomparatorfunktionen.

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

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)

Da Zeichenfolgen direkt in Javascript verglichen werden können, ist dies der Fall

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 natürlich nicht mit Zeichenfolgen funktioniert

Ich hatte mich lange darum gekümmert, also habe ich es endlich recherchiert und dir diesen langwierigen Grund gegeben, warum die Dinge so sind, wie sie sind.

Aus der Spezifikation :

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)

Nun gehen wir 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 Operator "Triple Equals", der auf Zeichenfolgen angewendet wird, gibt "true" zurück, wenn die Argumente genau dieselben Zeichenfolgen sind (gleiche Länge und gleiche Zeichen an entsprechenden Positionen).

Dies ===funktioniert auch in den Fällen, in denen wir versuchen, Zeichenfolgen zu vergleichen, die möglicherweise aus verschiedenen Quellen stammen, von denen wir jedoch wissen, dass sie letztendlich dieselben Werte haben - ein Szenario, das für Inline-Zeichenfolgen in unserem Code häufig genug ist. Wenn wir beispielsweise eine Variable mit dem Namen connection_statehaben und wissen möchten, in welchem ​​der folgenden Zustände ['connecting', 'connected', 'disconnecting', 'disconnected']sie sich gerade befindet, können wir die direkt verwenden=== .

Aber es gibt noch mehr. Knapp ü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 Saiten können und werden höchstwahrscheinlich eine seltsame Unicodey sein, und unsere Sanftheit ===wird ihnen nicht gerecht. In kommt localeComparezur 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;

Um Strings in Javascript, verwenden Sie zu vergleichen localeCompare; Wenn Sie wissen, dass die Zeichenfolgen keine Nicht-ASCII-Komponenten enthalten, da es sich beispielsweise um interne Programmkonstanten handelt, ===funktioniert dies ebenfalls.

In Ihrer Operation in Ihrer ersten Frage führen Sie die folgende Operation aus:

item1.attr - item2.attr

Angenommen, es handelt sich um Zahlen (dh item1.attr = "1", item2.attr = "2"). Sie können weiterhin den Operator "===" (oder andere strenge Bewerter) verwenden, sofern Sie den Typ sicherstellen. Folgendes sollte funktionieren:

return parseInt(item1.attr) - parseInt(item2.attr);

Wenn sie alphaNumerisch sind, verwenden Sie localCompare ().

list.sort(function(item1, item2){
    return +(item1.attr > item2.attr) || +(item1.attr === item2.attr) - 1;
}) 

Wie sie arbeiten Proben:

+('aaa'>'bbb')||+('aaa'==='bbb')-1
+(false)||+(false)-1
0||0-1
-1

+('bbb'>'aaa')||+('bbb'==='aaa')-1
+(true)||+(false)-1
1||0-1
1

+('aaa'>'aaa')||+('aaa'==='aaa')-1
+(false)||+(true)-1
0||1-1
0

<!doctype html>
<html>
<body>
<p id = "myString">zyxtspqnmdba</p>
<p id = "orderedString"></p>
<script>
var myString = document.getElementById("myString").innerHTML;
orderString(myString);
function orderString(str) {
    var i = 0;
    var myArray = str.split("");
    while (i < str.length){
        var j = i + 1;
        while (j < str.length) {
            if (myArray[j] < myArray[i]){
                var temp = myArray[i];
                myArray[i] = myArray[j];
                myArray[j] = temp;
            }
            j++;
        }
        i++;
    }
    var newString = myArray.join("");
    document.getElementById("orderedString").innerHTML = newString;
}
</script>
</body>
</html>

var str = ['v','a','da','c','k','l']
var b = str.join('').split('').sort().reverse().join('')
console.log(b)