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

Quelque Chose comme ceci:

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 localeCompare Fonction de la classe String comme suit:

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

Code le plus court possible avec ES6!

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

Chaîne de caractères.prototype.localeCompare() Le support de base est universel!

Belle petite ES6 une doublure:

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

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é:

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

Fondamentalement, vous pouvez trier les tableaux avec le tri par méthode, mais si vous voulez trier les objets, vous devez passer la fonction à la méthode de tri 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;
});

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

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

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

Nous devons donc vérifier la valeur 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 si nombre ou chaîne et fera le tri en conséquence .

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

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

Inspiré de ce 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;
})

Vous pouvez l'utiliser pour les 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);}

A poussé les meilleures réponses dans un prototype pour les 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 la méthode de tableau intégrée - sort. Cette méthode prend une méthode de rappel en tant que param

    // 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. la méthode personnalisée, dans ce cas, myCustomSort, devrait renvoyer + 1 ou -1 pour chaque paire d'éléments (à partir du tableau d'entrée) comparaison.
2. Utilisation toLowerCase()/toUpperCase() dans la méthode de rappel de tri personnalisée, cette différence de cas n'affecte pas l'exactitude du processus de tri.

J'espère que c'est clair assez d'explication. N'hésitez pas à commenter si vous pensez, plus d'informations sont nécessaires.

Cheers!

En termes simples, vous pouvez utiliser cette méthode

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

Dans le cas où nous sommes de tri des noms ou quelque chose avec des caractères spéciaux, comme ñ ou áéíóú (communes en espagnol), nous pourrions utiliser les paramètres les paramètres régionaux (es, pour l'espagnol, dans ce cas ) et options comme ceci:

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 dans iana, es (espagnol), de (Allemand), fr (Français). À propos de sensibilité base signifie:

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

Vous pouvez utiliser quelque chose de similaire, pour se débarrasser de sensible à 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;

})

Aussi 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 voulez:

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