Trier le tableau par prénom (alphabétiquement) en Javascript

J'ai obtenu un tableau (voir ci-dessous pour un objet dans le tableau) que je dois trier par prénom en utilisant JavaScript. Comment puis-je le faire?

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

Supposons que vous ayez un tableau users. Vous pouvez utiliser users.sortet passer une fonction qui prend deux arguments et les comparer (comparateur)

Il devrait revenir

• quelque chose de négatif si le premier argument est inférieur au second (doit être placé avant le second dans le tableau résultant)
• quelque chose de positif si le premier argument est plus grand (doit être placé après le deuxième)
• 0 si ces deux éléments sont égaux.

Dans notre cas, si deux éléments sont aet bnous voulons comparer a.firstnameetb.firstname

Exemple:

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

Ce code va fonctionner avec n'importe quel type.

Notez que dans la "vraie vie" ™, vous voulez souvent ignorer la casse, trier correctement les signes diacritiques, les symboles étranges comme ß, etc. lorsque vous comparez des chaînes, vous pouvez donc les utiliser localeCompare. Voir les autres réponses pour plus de clarté.

Code le plus court possible avec ES6!

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

Le support de base de String.prototype.localeCompare () est universel!

Quelque chose comme ça:

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

Si les chaînes comparées contiennent des caractères unicode, vous pouvez utiliser la localeComparefonction de Stringclasse comme suit:

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

Joli petit ES6 one liner:

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

Nous pouvons utiliser localeCompare mais devons également vérifier les clés pour les valeurs de falsey

Le code ci-dessous ne fonctionnera pas si une entrée manque lname.

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

Nous devons donc vérifier la valeur de falsey comme ci-dessous

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

nous pouvons utiliser lodash, c'est très simple. Il détectera les valeurs renvoyées, c'est-à-dire s'il s'agit d'un nombre ou d'une chaîne et effectuera le tri en conséquence.

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

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

underscorejs offre la très belle fonction _.sortBy:

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

ou vous pouvez utiliser une fonction de tri personnalisée:

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

Dans le cas où nous trions des noms ou quelque chose avec des caractères spéciaux, comme ñ ou áéíóú (communs en espagnol), nous pourrions utiliser les paramètres locaux ( es pour l'espagnol dans ce cas) et des options comme celle-ci:

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)

Les options locales officielles peuvent être trouvées ici en iana , es (espagnol), de (allemand), fr (français). À propos de la base de sensibilité signifie:

Seules les chaînes qui diffèrent en lettres de base se comparent comme inégales. Exemples: a ≠ b, a = á, a = A.

Fondamentalement, vous pouvez trier les tableaux avec le tri de méthode, mais si vous voulez trier les objets, vous devez passer une fonction pour trier la méthode du tableau, donc je vais vous donner un exemple en utilisant votre tableau

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

Inspiré de cette réponse,

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

Une notation plus compacte:

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

également pour le tri asec et desc, vous pouvez utiliser ceci: supposons que nous ayons une variable SortType qui spécifie le tri croissant ou le tri décroissant que vous souhaitez:

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

Une fonction généralisée peut être écrite comme ci-dessous

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

vous pouvez passer les paramètres ci-dessous

1. Les données que vous souhaitez trier
2. La propriété dans les données par elle doit être triée
3. Le dernier paramètre est de type booléen. Il vérifie si vous souhaitez trier par ordre croissant ou décroissant

essayer

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

Vous pouvez l'utiliser pour des objets

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

en termes simples, vous pouvez utiliser cette méthode

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

Vous pouvez utiliser la méthode du tableau intégré - sort. Cette méthode prend une méthode de rappel comme paramètre

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

Points clés à noter pour comprendre ce code.

1. Dans ce cas, la méthode personnalisée myCustomSortdoit renvoyer +1 ou -1 pour chaque comparaison de paires d'éléments (du tableau d'entrée).
2. Utilisez toLowerCase()/ toUpperCase()dans la méthode de rappel de tri personnalisé afin que la différence de casse n'affecte pas l'exactitude du processus de tri.

J'espère que cette explication est suffisamment claire. N'hésitez pas à commenter si vous le pensez, plus d'informations sont nécessaires.

À votre santé!

Poussé les meilleures réponses dans un prototype pour trier par clé.

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

Vous pouvez utiliser quelque chose de similaire pour vous débarrasser de la casse

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;

})

Mon implémentation fonctionne très bien dans les anciennes versions 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;
};

Juste pour mémoire, si vous voulez avoir une fonction de tri nommée, la syntaxe est la suivante:

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

Notez que ce qui suit ne fonctionne PAS:

users.sort(sortFunction(a,b))