por - Cómo ordenar una matriz de objetos con múltiples valores de campo en JavaScript

sort object javascript

Question

Encontré un excelente método para ordenar una matriz de objetos en función de una de las propiedades definidas en:

Clasificar matriz de objetos por valor de propiedad de cadena en JavaScript

El uso de esa función funciona perfectamente para una sola ordenación (en todos los navegadores), e incluso para una ordenación de otro tipo ¡EXCEPTO con Google Chrome! Aquí está la gran rutina de ordenamiento de Ege Özcan para matrices de objetos

function dynamicSort(property) { 
    return function (a,b) {
        return (a[property] < b[property]) ? -1 : (a[property] > b[property]) ? 1 : 0;
    }
}

Usando una matriz llamada "Datos" (por supuesto, mi matriz tiene muchos más pares de objetos) ...

var Data = [{Category: "Business", Value: "ABC"},{Category:"Personal", Value:"XYZ"}];

Puedo obtener una ordenación adecuada donde la orden se enumera como todos los valores dentro de cada categoría haciendo esto ...

Data.sort(dynamicSort("Value"));
Data.sort(dynamicSort("Category"));

Al ordenar primero el Value y luego por Category , mi matriz coloca todos los valores en orden con todos los valores de la base empresarial enumerados primero y luego todos los valores basados ​​en el personal. ¡Perfecto! Excepto en Chrome, donde los datos están ordenados por categoría, pero el orden de los valores dentro de cada categoría parece bastante aleatorio.

¿Alguien sabe de una mejor manera de hacer un tipo dentro de un género que también funcionaría en Chrome?

Answer 1

Creé una versión de múltiples parámetros de esa función dynamicSort:

function dynamicSort(property) { 
    return function (obj1,obj2) {
        return obj1[property] > obj2[property] ? 1
            : obj1[property] < obj2[property] ? -1 : 0;
    }
}

function dynamicSortMultiple() {
    /*
     * save the arguments object as it will be overwritten
     * note that arguments object is an array-like object
     * consisting of the names of the properties to sort by
     */
    var props = arguments;
    return function (obj1, obj2) {
        var i = 0, result = 0, numberOfProperties = props.length;
        /* try getting a different result from 0 (equal)
         * as long as we have extra properties to compare
         */
        while(result === 0 && i < numberOfProperties) {
            result = dynamicSort(props[i])(obj1, obj2);
            i++;
        }
        return result;
    }
}

Creé una matriz de la siguiente manera:

var arr = [
    {a:"a",b:"a",c:"a"},
    {a:"b",b:"a",c:"b"},
    {a:"b",b:"a",c:"a"},
    {a:"b",b:"a",c:"b"},
    {a:"b",b:"b",c:"a"},
    {a:"b",b:"b",c:"b"},
    {a:"b",b:"b",c:"a"},
    {a:"b",b:"b",c:"b"},
    {a:"b",b:"b",c:"a"},
    {a:"b",b:"b",c:"b"},
    {a:"b",b:"b",c:"a"},
    {a:"c",b:"b",c:"b"},
    {a:"c",b:"c",c:"a"}
];

y funcionó cuando lo hice,

arr.sort(dynamicSortMultiple("c","b","a"));

Y aquí hay un ejemplo de trabajo: http://jsfiddle.net/ZXedp/

Answer 2

También es posible que desee echar un vistazo a thenBy.js: https://github.com/Teun/thenBy.js

Le permite usar el Array.sort estándar, pero con el estilo firstBy (). ThenBy (). ThenBy ().

Answer 3

Aquí está mi solución. Es más rápido que la función de ordenación de varias columnas _.sortBy () de Lodash en aproximadamente dos veces (consulte http://jsperf.com/multi-column-sort . Genero texto de la función de clasificación, luego lo uso en .sort estándar () También funciona en Chrome y Firefox.

function multiColumnSort(arr,sf) {
    var s = '''';
    sf.forEach(function(f,idx) {
        s += ''if(arguments[0].''+f+''>arguments[1].''+f+'')return 1;'';
        s += ''else if(arguments[0].''+f+''==arguments[1].''+f+'')'';
        s += (idx < sf.length-1)? ''{'' : ''return 0'';
    });
    s += Array(sf.length).join(''}'')+'';return -1'';
    return arr.sort(new Function(s));
};

Answer 4

Ahora que esta publicación es bastante antigua, de todos modos la encontré hoy y cito a Ege Özcan , mejoré su excelente solución implementando la funcionalidad DESC-ASC SQL-Like para cualquiera que esté interesado ( http://jsfiddle.net/ZXedp/65/ ):

function dynamicSortMultiple() {
    var props=[];
    /*Let''s separate property name from ascendant or descendant keyword*/
    for(var i=0; i < arguments.length; i++){
        var splittedArg=arguments[i].split(/ +/);
        props[props.length]=[splittedArg[0], (splittedArg[1] ? splittedArg[1].toUpperCase() : "ASC")];
    }
    return function (obj1, obj2) {
        var i = 0, result = 0, numberOfProperties = props.length ;
        /*Cycle on values until find a difference!*/
        while(result === 0 && i < numberOfProperties) {
            result = dynamicSort(props[i][0], props[i][1])(obj1, obj2);
            i++;
        }
        return result;
    }
}

/*Base function returning -1,1,0 for custom sorting*/
function dynamicSort(property, isAscDesc) { 
    return function (obj1,obj2) {
        if(isAscDesc==="DESC"){
            return ((obj1[property] > obj2[property]) ? (-1) : ((obj1[property] < obj2[property]) ? (1) : (0)));
        }
        /*else, if isAscDesc==="ASC"*/
        return ((obj1[property] > obj2[property]) ? (1) : ((obj1[property] < obj2[property]) ? (-1) : (0)));
    }
}

llama a la función por algo como esto:

arr.sort(dynamicSortMultiple("c DESC","b Asc","a"));

Answer 5

La forma más fácil de realizar una clasificación .sort Javascript (o clasificación de múltiples parámetros) es utilizar .sort , concatenar los múltiples parámetros juntos y comparar los dos inconvenientes.

Por ejemplo:

data.sort(function (a, b) {

  var aConcat = a["property1"] + a["property2"];
  var bConcat = b["property1"] + b["property2"];

  if (aConcat > bConcat) {
    return 1;
  } else if (aConcat < bConcat) {
    return -1;
  } else {
    return 0;
  }

});

He incluido un script JsFiddle aquí: http://jsfiddle.net/oahxg4u3/6/