Ordenar matriz por nombre (alfabéticamente) en Javascript

Obtuve una matriz (ver abajo para un objeto en la matriz) que necesito ordenar por nombre usando JavaScript. ¿Cómo puedo hacerlo?

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

Supongamos que tiene una matriz users. Puede usar users.sorty pasar una función que tome dos argumentos y compararlos (comparador)

Debería volver

• algo negativo si el primer argumento es menor que el segundo (debe colocarse antes del segundo en la matriz resultante)
• algo positivo si el primer argumento es mayor (debe colocarse después del segundo)
• 0 si esos dos elementos son iguales.

En nuestro caso si dos elementos son ay bqueremos comparar a.firstnameyb.firstname

Ejemplo:

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

Este código va a funcionar con cualquier tipo.

Tenga en cuenta que en la "vida real" ™ a menudo desea ignorar mayúsculas y minúsculas, clasificar correctamente los signos diacríticos, símbolos extraños como ß, etc. cuando compara cadenas, por lo que es posible que desee utilizarlas localeCompare. Ver otras respuestas para mayor claridad.

¡El código más corto posible con ES6!

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

¡El soporte básico String.prototype.localeCompare () es universal!

Algo como esto:

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 las cadenas comparadas contienen caracteres unicode, puede usar la localeComparefunción de Stringclase como la siguiente:

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

Bonito y pequeño ES6 one liner:

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

Podemos usar localeCompare pero también debemos verificar las claves para los valores de falsey

El siguiente código no funcionará si falta una entrada en lname.

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

Por lo tanto, debemos verificar el valor de falsey como se muestra a continuación

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

podemos usar lodash, es muy simple. Detectará los valores devueltos, es decir, ya sea número o cadena, y hará la clasificación en consecuencia.

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

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

underscorejs ofrece la muy buena función _.sortBy:

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

o puede usar una función de clasificación personalizada:

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

En caso de que estemos clasificando nombres o algo con caracteres especiales, como ñ o áéíóú (comunes en español), podríamos usar los parámetros locales ( es para español en este caso) y opciones como esta:

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)

Las opciones locales oficiales se pueden encontrar aquí en iana , es (español), de (alemán), fr (francés). Acerca de la base de sensibilidad significa:

Solo las cadenas que difieren en letras base se comparan como desiguales. Ejemplos: a ≠ b, a = á, a = A.

Básicamente, puede ordenar las matrices con el método de clasificación, pero si desea ordenar los objetos, debe pasar la función para ordenar el método de la matriz, por lo que le daré un ejemplo usando su matriz

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 en esta respuesta,

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

Una notación más compacta:

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

También para ambos tipos, asec y desc, puede usar esto: supongamos que tenemos una variable SortType que especifica la clasificación ascendente o descendente que desee:

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

Una función generalizada se puede escribir como a continuación

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

puedes pasar los siguientes parámetros

1. Los datos que quieres ordenar
2. La propiedad en los datos por debe ser ordenada
3. El último parámetro es de tipo booleano. Comprueba si quieres ordenar por ascendente o descendente

tratar

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

Puedes usar esto 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);}

en palabras simples, puedes usar este método

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

Puede usar el método de matriz incorporado - sort. Este método toma un método de devolución de llamada como 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"]

Puntos clave a tener en cuenta para comprender este código.

1. El método personalizado, en este caso, myCustomSort debería devolver +1 o -1 para cada comparación de par de elementos (de la matriz de entrada).
2. Utilice toLowerCase()/ toUpperCase()en el método de devolución de llamada de clasificación personalizado para que la diferencia de mayúsculas y minúsculas no afecte a la corrección del proceso de clasificación.

Espero que esto sea una explicación suficientemente clara. Siéntase libre de comentar si cree que se necesita más información.

¡Salud!

Introdujo las mejores respuestas en un prototipo para ordenar por clave.

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

Puedes usar algo similar para deshacerte de mayúsculas y 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;

})

Mi implementación funciona muy bien en versiones anteriores de 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;
};

Solo para el registro, si desea tener una función de clasificación con nombre, la sintaxis es la siguiente:

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

Tenga en cuenta que lo siguiente NO funciona:

users.sort(sortFunction(a,b))