Ordina l'array per nome (in ordine alfabetico) in Javascript

Ho un array (vedi sotto per un oggetto nell'array) che devo ordinare per nome usando JavaScript. Come posso farlo?

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

Supponiamo di avere un array users. È possibile utilizzare users.sorte passare una funzione che accetta due argomenti e li confronta (comparatore)

Dovrebbe tornare

• qualcosa di negativo se il primo argomento è inferiore al secondo (dovrebbe essere posizionato prima del secondo nell'array risultante)
• qualcosa di positivo se il primo argomento è maggiore (dovrebbe essere inserito dopo il secondo)
• 0 se quei due elementi sono uguali.

Nel nostro caso se due elementi sono ae bvogliamo confrontare a.firstnameeb.firstname

Esempio:

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

Questo codice funzionerà con qualsiasi tipo.

Si noti che nella "vita reale" ™ spesso si desidera ignorare il caso, ordinare correttamente i segni diacritici, simboli strani come ß, ecc. Quando si confrontano le stringhe, quindi è consigliabile utilizzarle localeCompare. Vedi altre risposte per chiarezza.

Il codice più breve possibile con ES6!

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

String.prototype.localeCompare () il supporto di base è universale!

Qualcosa come questo:

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 le stringhe confrontate contengono caratteri unicode puoi utilizzare la localeComparefunzione di Stringclasse come la seguente:

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

È possibile utilizzare localeCompare ma è necessario controllare anche le chiavi per i valori di falso

Il codice seguente non funzionerà se in una voce manca lname.

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

Quindi dobbiamo verificare il valore del falso come di seguito

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

O

possiamo usare lodash, è molto semplice. Rileverà i valori restituiti, ovvero se il numero o la stringa e eseguirà l'ordinamento di conseguenza.

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

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

underscorejs offre la bellissima funzione _.sortBy:

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

oppure puoi utilizzare una funzione di ordinamento personalizzata:

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

Nel caso in cui stiamo ordinando nomi o qualcosa con caratteri speciali, come ñ o áéíóú (beni comuni in spagnolo), potremmo usare i parametri locali ( es in spagnolo in questo caso) e opzioni come questa:

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)

Le opzioni locali locali possono essere trovate qui in iana , es (spagnolo), de (tedesco), fr (francese). A proposito di base di sensibilità significa:

Solo le stringhe che differiscono nelle lettere di base si equivalgono. Esempi: a ≠ b, a = á, a = A.

Fondamentalmente puoi ordinare le matrici con il metodo sort, ma se vuoi ordinare gli oggetti, devi passare la funzione per ordinare il metodo dell'array, quindi ti darò un esempio usando l'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;
});

Ispirato da questa risposta,

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

Una notazione più compatta:

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

anche per asec e sort, puoi usare questo: supponiamo di avere un SortType variabile che specifica l'ordinamento crescente o l'ordinamento decrescente che desideri:

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

Una funzione generalizzata può essere scritta come di seguito

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

puoi passare i seguenti parametri

1. I dati che desideri ordinare
2. La proprietà nei dati da essa deve essere ordinata
3. L'ultimo parametro è di tipo booleano. Controlla se si desidera ordinare in ordine crescente o decrescente

provare

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

Puoi usarlo per gli oggetti

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

in parole semplici puoi usare questo metodo

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

È possibile utilizzare il metodo array incorporato - sort. Questo metodo utilizza un metodo di callback come parametro

    // 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"]

Punti chiave da notare per comprendere questo codice.

1. Il metodo personalizzato, in questo caso, myCustomSortdovrebbe restituire +1 o -1 per ogni confronto di coppie di elementi (dall'array di input).
2. Utilizzare toLowerCase()/ toUpperCase()nel metodo di callback di ordinamento personalizzato in modo che la differenza tra maiuscole e minuscole non influisca sulla correttezza del processo di ordinamento.

Spero che questa sia una spiegazione abbastanza chiara. Sentiti libero di commentare se pensi che siano necessarie maggiori informazioni.

Saluti!

Inserito le risposte migliori in un prototipo per ordinare in base alla chiave.

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

Puoi usare qualcosa di simile per sbarazzarti della distinzione tra maiuscole e minuscole

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;

})

La mia implementazione funziona alla grande nelle versioni ES precedenti:

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

Solo per la cronaca, se si desidera avere una funzione di ordinamento denominata, la sintassi è la seguente:

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

Si noti che quanto segue NON funziona:

users.sort(sortFunction(a,b))