Eu tenho uma lista de objetos que desejo classificar com base em um campo attrdo tipo string. Eu tentei usar-

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

mas descobriu que -não parece funcionar com cadeias de caracteres em JavaScript. Como posso classificar uma lista de objetos com base em um atributo com o tipo string?

Use String.prototype.localeCompareum por seu exemplo:

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

Forçamos a.attr a ser uma string para evitar exceções. localeCompareé suportado desde o Internet Explorer 6 e Firefox 1. Você também pode ver o seguinte código usado que não respeita um código de idioma:

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

Uma resposta atualizada (outubro de 2014)

Fiquei realmente irritado com essa ordem de classificação natural da string, por isso levei algum tempo para investigar esse problema. Eu espero que isso ajude.

Longa história curta

localeCompare()suporte a personagens é foda, basta usá-lo. Conforme indicado por Shog9, a resposta para sua pergunta é:

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

Erros encontrados em todas as implementações personalizadas de "ordem de classificação de sequência natural" em javascript

Existem várias implementações personalizadas por aí, tentando fazer uma comparação de strings mais precisamente chamada "ordem natural de classificação de strings"

Ao "brincar" com essas implementações, sempre notei alguma escolha estranha de "ordem de classificação natural", ou melhor, erros (ou omissões nos melhores casos).

Normalmente, caracteres especiais (espaço, traço, e comercial, colchetes e assim por diante) não são processados ​​corretamente.

Você os encontrará aparecendo misturados em lugares diferentes, normalmente que podem ser:

• alguns estarão entre maiúsculas 'Z' e minúsculas 'a'
• alguns estarão entre o '9' e o 'A' maiúsculo
• alguns serão depois de 'z' minúsculo

Quando seria de esperar que todos os caracteres especiais fossem "agrupados" em um só lugar, exceto o caractere especial de espaço talvez (que sempre seria o primeiro caractere). Ou seja, tudo antes dos números ou entre números e letras (letras minúsculas e maiúsculas estão "juntas" uma após a outra) ou todas as letras.

Minha conclusão é que todos eles falham em fornecer uma ordem consistente quando começo a adicionar caracteres pouco comuns (ou seja, caracteres com sinais diacríticos ou caracteres como traço, ponto de exclamação e assim por diante).

Pesquisa sobre implementações personalizadas:

• Natural Compare Lite https://github.com/litejs/natural-compare-lite : falha na classificação consistente https://github.com/litejs/natural-compare-lite/issues/1 e http://jsbin.com/bevututodavi/ 1 / edit? Js, console , classificação básica de caracteres latinos http://jsbin.com/bevututodavi/5/edit?js,console
• Natural Sort https://github.com/javve/natural-sort : falha na classificação consistente, consulte o problema https://github.com/javve/natural-sort/issues/7 e veja os caracteres latinos básicos da classificação http: // jsbin. com / cipimosedoqe / 3 / edit? js, console
• Javascript Natural Sort https://github.com/overset/javascript-natural-sort : parece bastante negligenciado desde fevereiro de 2012, falha na classificação consistente, consulte o problema https://github.com/overset/javascript-natural-sort/issues/16
• Alphanum http://www.davekoelle.com/files/alphanum.js , falha na classificação consistente, consulte http://jsbin.com/tuminoxifuyo/1/edit?js,console

Implementações nativas da "ordem de classificação de cadeia natural" dos navegadores via localeCompare()

localeCompare()A implementação mais antiga (sem os argumentos códigos de idioma e opções) é suportada pelo IE6 +, consulte http://msdn.microsoft.com/en-us/library/ie/s4esdbwz(v=vs.94).aspx (role para baixo até localeCompare ( )). O localeCompare()método incorporado faz um trabalho muito melhor na classificação, mesmo em caracteres internacionais e especiais. O único problema usando o localeCompare()método é que "a localidade e a ordem de classificação usadas são totalmente dependentes da implementação". Em outras palavras, ao usar o localeCompare, como stringOne.localeCompare (stringTwo): Firefox, Safari, Chrome e IE têm uma ordem de classificação diferente para Strings.

Pesquisa sobre implementações nativas do navegador:

• http://jsbin.com/beboroyifomu/1/edit?js,console - comparação básica de caracteres latinos com localeCompare () http://jsbin.com/viyucavudela/2/ - comparação básica de caracteres latinos com localeCompare () para testar IE8
• http://jsbin.com/beboroyifomu/2/edit?js,console - caracteres latinos básicos na comparação de cadeias: verificação de consistência na cadeia versus quando um caractere está sozinho
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare - O IE11 + suporta os novos argumentos de códigos de idioma e opções

Dificuldade de "ordem de classificação natural das cadeias"

A implementação de um algoritmo sólido (significando: consistente, mas também cobrindo uma ampla variedade de caracteres) é uma tarefa muito difícil. O UTF8 contém mais de 2000 caracteres e abrange mais de 120 scripts (idiomas) . Finalmente, existem algumas especificações para essas tarefas, chamadas de "Algoritmos de Collation Unicode", que podem ser encontrados em http://www.unicode.org/reports/tr10/ . Você pode encontrar mais informações sobre isso nesta questão que eu publiquei /software/257286/is-there-any-language-agnostic-specification-for-string-natural-sorting-order

Conclusão final

Portanto, considerando o nível atual de suporte fornecido pelas implementações personalizadas de javascript que encontrei, provavelmente nunca veremos nada próximo de suportar todos esses caracteres e scripts (idiomas). Por isso, prefiro usar o método localeCompare () nativo dos navegadores. Sim, ele tem a desvantagem de não ser consistente entre os navegadores, mas os testes básicos mostram que ele abrange uma variedade muito maior de caracteres, permitindo ordens de classificação sólidas e significativas.

Portanto, conforme indicado por Shog9, a resposta para sua pergunta é:

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

Leitura adicional:

• /software/257286/is-there-any-language-agnostic-specification-for-string-natural-sorting-order
• Como você faz a comparação de strings em JavaScript?
• Javascript: tipo natural de sequências alfanuméricas
• Classificar matriz de elementos numéricos e alfabéticos (classificação natural)
• Classificar matriz alfanumérica / numérica mista
• 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/

Graças à boa resposta de Shog9, que me colocou na direção "certa", acredito

Resposta (no ECMAScript moderno)

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

Ou

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

Descrição

A conversão de um valor booleano em um número produz o seguinte:

• true -> 1
• false -> 0

Considere três padrões possíveis:

• x é maior que y: (x > y) - (y < x)-> 1 - 0->1
• x é igual a y: (x > y) - (y < x)-> 0 - 0->0
• x é menor que y: (x > y) - (y < x)-> 0 - 1->-1

(Alternativa)

• x é maior que y: +(x > y) || -(x < y)-> 1 || 0->1
• x é igual a y: +(x > y) || -(x < y)-> 0 || 0->0
• x é menor que y: +(x > y) || -(x < y)-> 0 || -1->-1

Portanto, essas lógicas são equivalentes às funções típicas do comparador de classificação.

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

Você deve usar> ou <e == aqui. Portanto, a solução seria:

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;
});

Função de seta ternária aninhada

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

como as strings podem ser comparadas diretamente em javascript, isso fará o trabalho

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

a subtração em uma função de classificação é usada apenas quando a classificação não alfabética (numérica) é desejada e, é claro, não funciona com strings

Eu me preocupei com isso por muito tempo, então finalmente pesquisei sobre isso e explico por que as coisas são do jeito que são.

Das especificações :

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)

Então agora vamos para 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.

É isso aí. O operador triple equals aplicado às strings retorna true se os argumentos são exatamente as mesmas strings (mesmo comprimento e mesmos caracteres nas posições correspondentes).

Portanto ===, funcionará nos casos em que estivermos tentando comparar cadeias que podem ter chegado de fontes diferentes, mas que sabemos que acabarão tendo os mesmos valores - um cenário bastante comum para cadeias de caracteres embutidas em nosso código. Por exemplo, se tivermos uma variável denominada connection_statee desejamos saber em qual dos seguintes estados ['connecting', 'connected', 'disconnecting', 'disconnected']ela está agora, podemos usar diretamente o ===.

Mas tem mais. Logo acima do 11.9.4, há uma breve nota:

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. E agora? Cordas obtidas externamente podem, e muito provavelmente serão, unicodey estranho, e nosso gentil ===não fará justiça a elas. Em vem localeCompareao salvamento:

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. 

Podemos ir para casa agora.

tl; dr;

Para comparar strings em javascript, use localeCompare; se você souber que as seqüências não têm componentes não ASCII porque são, por exemplo, constantes internas do programa, ===também funciona.

Na sua operação na sua pergunta inicial, você está executando a seguinte operação:

item1.attr - item2.attr

Portanto, supondo que sejam números (por exemplo, item1.attr = "1", item2.attr = "2") Você ainda pode usar o operador "===" (ou outros avaliadores rigorosos), desde que garanta o tipo. O seguinte deve funcionar:

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

Se eles são alphaNumeric, use localCompare ().

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

Como eles funcionam amostras:

+('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)