Classificar matriz por nome (alfabeticamente) em Javascript

Eu tenho uma matriz (veja abaixo para um objeto na matriz) que eu preciso classificar por nome usando JavaScript. Como eu posso fazer isso?

var user = {
   bio: null,
   email:  "user@domain.com",
   firstname: "Anna",
   id: 318,
   lastAvatar: null,
   lastMessage: null,
   lastname: "Nickson",
   nickname: "anny"
};

Suponha que você tenha uma matriz users. Você pode usar users.sorte passar uma função que recebe dois argumentos e os compara (comparador)

Deve retornar

• algo negativo se o primeiro argumento for menor que o segundo (deve ser colocado antes do segundo na matriz resultante)
• algo positivo se o primeiro argumento for maior (deve ser colocado após o segundo)
• 0 se esses dois elementos forem iguais.

No nosso caso, se dois elementos existirem ae bqueremos comparar a.firstnameeb.firstname

Exemplo:

users.sort(function(a, b){
    if(a.firstname < b.firstname) { return -1; }
    if(a.firstname > b.firstname) { return 1; }
    return 0;
})

Este código funcionará com qualquer tipo.

Observe que, na "vida real" ™, você frequentemente deseja ignorar maiúsculas e minúsculas, classificar corretamente sinais diacríticos, símbolos estranhos como ß etc. quando comparar seqüências de caracteres, portanto, pode usar localeCompare. Veja outras respostas para maior clareza.

O menor código possível com o ES6!

users.sort((a, b) => a.firstname.localeCompare(b.firstname))

O suporte básico String.prototype.localeCompare () é universal!

Algo assim:

array.sort(function(a, b){
 var nameA=a.name.toLowerCase(), nameB=b.name.toLowerCase();
 if (nameA < nameB) //sort string ascending
  return -1;
 if (nameA > nameB)
  return 1;
 return 0; //default return value (no sorting)
});

Se as cadeias comparadas contiverem caracteres unicode, você poderá usar a localeComparefunção de Stringclasse da seguinte maneira:

users.sort(function(a,b){
    return a.firstname.localeCompare(b.firstname);
})

Nice little ES6 one liner:

users.sort((a, b) => a.firstname !== b.firstname ? a.firstname < b.firstname ? -1 : 1 : 0);

Podemos usar o localeCompare, mas também precisamos verificar as chaves quanto aos valores de falsey

O código abaixo não funcionará se uma entrada estiver com lname ausente.

obj.sort((a, b) => a.lname.localeCompare(b.lname))

Então, precisamos verificar o valor de Falsey como abaixo

let obj=[
{name:'john',lname:'doe',address:'Alaska'},
{name:'tom',lname:'hopes',address:'California'},
{name:'harry',address:'Texas'}
]
let field='lname';
console.log(obj.sort((a, b) => (a[field] || "").toString().localeCompare((b[field] || "").toString())));

OU

podemos usar lodash, é muito simples. Ele detectará os valores retornados, ou seja, número ou sequência e fará a classificação de acordo.

import sortBy from 'lodash/sortBy';
sortBy(obj,'name')

https://lodash.com/docs/4.17.5#sortBy

O underscorejs oferece a muito boa função _.sortBy:

_.sortBy([{a:1},{a:3},{a:2}], "a")

ou você pode usar uma função de classificação personalizada:

_.sortBy([{a:"b"},{a:"c"},{a:"a"}], function(i) {return i.a.toLowerCase()})

Em caso estamos classificando nomes ou algo com caracteres especiais, como ñ ou AEIOU (commons em espanhol) nós poderíamos usar o params locales ( es para o espanhol, neste caso) e opções como este:

let user = [{'firstname': 'Az'},{'firstname': 'Áb'},{'firstname':'ay'},{'firstname': 'Ña'},{'firstname': 'Nz'},{'firstname': 'ny'}];


user.sort((a, b) => a.firstname.localeCompare(b.firstname, 'es', {sensitivity: 'base'}))


console.log(user)

As opções oficiais de localidade podem ser encontradas aqui em iana , es (espanhol), de (alemão), fr (francês). Sobre a sensibilidade base significa:

Somente cadeias que diferem em letras base são comparadas como desiguais. Exemplos: a ≠ b, a = á, a = A.

Basicamente, você pode classificar matrizes com o método sort, mas se você quiser classificar objetos, precisará passar a função para classificar o método do array, portanto, darei um exemplo usando seu array

user = [{
bio: "<null>",
email: "user@domain.com",
firstname: 'Anna',
id: 318,
"last_avatar": "<null>",
"last_message": "<null>",
lastname: 'Nickson',
nickname: 'anny'
},
{
bio: "<null>",
email: "user@domain.com",
firstname: 'Senad',
id: 318,
"last_avatar": "<null>",
"last_message": "<null>",
lastname: 'Nickson',
nickname: 'anny'
},
{
bio: "<null>",
email: "user@domain.com",
firstname: 'Muhamed',
id: 318,
"last_avatar": "<null>",
"last_message": "<null>",
lastname: 'Nickson',
nickname: 'anny'
}];

var ar = user.sort(function(a, b)
{
  var nA = a.firstname.toLowerCase();
  var nB = b.firstname.toLowerCase();

  if(nA < nB)
    return -1;
  else if(nA > nB)
    return 1;
 return 0;
});

Inspirado nesta resposta,

users.sort((a,b) => (a.firstname  - b.firstname));

Uma notação mais compacta:

user.sort(function(a, b){
    return a.firstname === b.firstname ? 0 : a.firstname < b.firstname ? -1 : 1;
})

também para classificação asec e desc, você pode usar isso: suponha que tenhamos uma variável SortType que especifica a classificação crescente ou a classificação descendente desejada:

 users.sort(function(a,b){
            return   sortType==="asc"? a.firstName.localeCompare( b.firstName): -( a.firstName.localeCompare(  b.firstName));
        })

Uma função generalizada pode ser escrita como abaixo

    function getSortedData(data, prop, isAsc) {
        return data.sort((a, b) => (a[prop] < b[prop] ? -1 : 1) * (isAsc ? 1 : -1));
   }

você pode passar os parâmetros abaixo

1. Os dados que você deseja classificar
2. A propriedade nos dados deve ser classificada
3. O último parâmetro é do tipo booleano. Ele verifica se você deseja classificar por ascendente ou descendente

tentar

users.sort((a,b)=> (a.firstname>b.firstname)*2-1)

var users = [
  { firstname: "Kate", id: 318, /*...*/ },
  { firstname: "Anna", id: 319, /*...*/ },
  { firstname: "Cristine", id: 317, /*...*/ },
]

console.log(users.sort((a,b)=> (a.firstname>b.firstname)*2-1) );

Você pode usar isso para objetos

transform(array: any[], field: string): any[] {
return array.sort((a, b) => a[field].toLowerCase() !== b[field].toLowerCase() ? a[field].toLowerCase() < b[field].toLowerCase() ? -1 : 1 : 0);}

em palavras simples, você pode usar esse método

users.sort(function(a,b){return a.firstname < b.firstname ? -1 : 1});

Você pode usar o método de matriz incorporado - sort. Esse método usa um método de retorno de chamada como um parâmetro

    // custom sort function to be passed as param/callback to the Array's sort method
    function myCustomSort(a, b) {
        return (a.toLowerCase() > b.toLowerCase()) ? 1 : -1;
    }

    // Actual method to be called by entity that needs sorting feature
    function sortStrings() {
        var op = Array.prototype.sort.call(arguments, myCustomSort);
    }

    // Testing the implementation
    var sortedArray = sortStrings("Burger", "Mayo1", "Pizza", "boxes", "Apples", "Mayo");
    console.log(sortedArray); //["Apples", "boxes", "Burger", "Mayo", "Mayo1", "Pizza"]

Pontos principais a serem observados para a compreensão deste código.

1. O método personalizado, nesse caso, myCustomSortdeve retornar +1 ou -1 para cada comparação de pares de elementos (da matriz de entrada).
2. Use toLowerCase()/ toUpperCase()no método de retorno de chamada de classificação personalizado, para que a diferença entre maiúsculas e minúsculas não afete a correção do processo de classificação.

Espero que esta seja uma explicação suficientemente clara. Sinta-se livre para comentar se você acha que são necessárias mais informações.

Felicidades!

Introduziu as principais respostas em um protótipo para classificar por chave.

Array.prototype.alphaSortByKey= function (key) {
    this.sort(function (a, b) {
        if (a[key] < b[key])
            return -1;
        if (a[key] > b[key])
            return 1;
        return 0;
    });
    return this;
};

Você pode usar algo semelhante, para se livrar da distinção entre maiúsculas e minúsculas

users.sort(function(a, b){

  //compare two values
  if(a.firstname.toLowerCase() < b.firstname.toLowerCase()) return -1;
  if(a.firstname.toLowerCase() > b.firstname.toLowerCase()) return 1;
  return 0;

})

Minha implementação, funciona muito bem em versões mais antigas do ES:

sortObject = function(data) {
    var keys = Object.keys(data);
    var result = {};

    keys.sort();

    for(var i = 0; i < keys.length; i++) {
        var key = keys[i];

        result[key] = data[key];
    }

    return result;
};

Apenas para o registro, se você deseja ter uma função de classificação nomeada, a sintaxe é a seguinte:

let sortFunction = (a, b) => {
 if(a.firstname < b.firstname) { return -1; }
 if(a.firstname > b.firstname) { return 1; }
 return 0;
})
users.sort(sortFunction)

Observe que o seguinte NÃO funciona:

users.sort(sortFunction(a,b))