new - recorrer array de objetos javascript

Ordenar JavaScript objeto por valor de la propiedad

Question

Si tengo un objeto JavaScript como:

var list = {
  "you": 100, 
  "me": 75, 
  "foo": 116, 
  "bar": 15
};

¿Hay una manera de ordenar las propiedades basadas en el valor? Para que termine con

list = {
  "bar": 15, 
  "me": 75, 
  "you": 100, 
  "foo": 116
};

Answer 1

Actualización con ES6: si su preocupación es tener un objeto ordenado para iterar (por lo que imagino que quiere que se ordenen las propiedades de su objeto), puede usar el objeto Map .

Puede insertar sus pares (clave, valor) en orden ordenado y luego hacer un ciclo for..of le garantizará tenerlos en el orden en que los insertó

var myMap = new Map();
myMap.set(0, "zero");
myMap.set(1, "one");
for (var [key, value] of myMap) {
  console.log(key + " = " + value);
}
// 0 = zero 
// 1 = one

Answer 2

Aquí está la manera de ordenar el objeto y obtener el objeto ordenado a cambio

let sortedObject = {}
sortedObject = Object.keys(yourObject).sort((a, b) => {
                        return yourObject[a] - yourObject[b] 
                    }).reduce((prev, curr, i) => {
                        prev[i] = yourObject[curr]
                        return prev
                    }, {});

Puede personalizar su función de clasificación según su requisito

Answer 3

Aquí hay un ejemplo más:

function sortObject(obj) {
  var arr = [];
  var prop;
  for (prop in obj) {
    if (obj.hasOwnProperty(prop)) {
      arr.push({
        ''key'': prop,
        ''value'': obj[prop]
      });
    }
  }
  arr.sort(function(a, b) {
    return a.value - b.value;
  });
  return arr; // returns array
}
var list = {
  car: 300,
  bike: 60,
  motorbike: 200,
  airplane: 1000,
  helicopter: 400,
  rocket: 8 * 60 * 60
};
var arr = sortObject(list);
console.log(arr);

Answer 4

Colóquelos en una matriz, ordene esa matriz y luego use esa matriz para sus propósitos. Aquí hay una solución:

var maxSpeed = {
    car: 300, 
    bike: 60, 
    motorbike: 200, 
    airplane: 1000,
    helicopter: 400, 
    rocket: 8 * 60 * 60
};
var sortable = [];
for (var vehicle in maxSpeed) {
    sortable.push([vehicle, maxSpeed[vehicle]]);
}

sortable.sort(function(a, b) {
    return a[1] - b[1];
});

//[["bike", 60], ["motorbike", 200], ["car", 300],
//["helicopter", 400], ["airplane", 1000], ["rocket", 28800]]

Una vez que tenga la matriz, puede reconstruir el objeto a partir de la matriz en el orden que desee, logrando así exactamente lo que se propuso hacer. Eso funcionaría en todos los navegadores que conozco, pero dependería de una peculiaridad de implementación y podría fallar en cualquier momento. Nunca debe hacer suposiciones sobre el orden de los elementos en un objeto de JavaScript.

Answer 5

ECMAScript 2017 introduce Object.values / Object.entries . Como sugiere su nombre, el primero agrega todos los valores de un objeto en una matriz, y el último hace todo el objeto en una matriz de matrices [key, value] ; El equivalente de Python de dict.values() y dict.items() .

Las características hacen que sea más fácil ordenar cualquier hash en un objeto ordenado. A partir de ahora, solo una pequeña parte de las plataformas JavaScript las admiten , pero puedes probarlas en Firefox 47+.

let obj = {"you": 100, "me": 75, "foo": 116, "bar": 15};

let entries = Object.entries(obj);
// [["you",100],["me",75],["foo",116],["bar",15]]

let sorted = entries.sort((a, b) => a[1] - b[1]);
// [["bar",15],["me",75],["you",100],["foo",116]]

Answer 6

Esta podría ser una forma sencilla de manejarlo como un objeto real ordenado. No estoy seguro de lo lento que es. También podría ser mejor con un bucle while.

Object.sortByKeys = function(myObj){
  var keys = Object.keys(myObj)
  keys.sort()
  var sortedObject = Object()
  for(i in keys){
    key = keys[i]
    sortedObject[key]=myObj[key]
   }

  return sortedObject

}

Y luego encontré esta función de inversión desde: http://nelsonwells.net/2011/10/swap-object-key-and-values-in-javascript/

Object.invert = function (obj) {

  var new_obj = {};

  for (var prop in obj) {
    if(obj.hasOwnProperty(prop)) {
      new_obj[obj[prop]] = prop;
    }
  }

  return new_obj;
};

Asi que

var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
var invertedList = Object.invert(list)
var invertedOrderedList = Object.sortByKeys(invertedList)
var orderedList = Object.invert(invertedOrderedList)

Answer 7

Estoy siguiendo la solución dada por slebetman (ve a leerla para todos los detalles), pero ajustada, ya que tu objeto no está anidado.

// First create the array of keys/values so that we can sort it:
var sort_array = [];
for (var key in list) {
    sort_array.push({key:key,value:list[key]});
}

// Now sort it:
sort_array.sort(function(x,y){return x.value - y.value});

// Now process that object with it:
for (var i=0;i<sort_array.length;i++) {
    var item = list[sort_array[i].key];

    // now do stuff with each item
}

Answer 8

Gracias y sigue respondiendo @Nosredna

Ahora que entendemos que es necesario convertir el objeto en una matriz, ordene la matriz. esto es útil para ordenar la matriz (u objeto convertido a matriz) por cadena:

Object {6: Object, 7: Object, 8: Object, 9: Object, 10: Object, 11: Object, 12: Object}
   6: Object
   id: "6"
   name: "PhD"
   obe_service_type_id: "2"
   __proto__: Object
   7: Object
   id: "7"
   name: "BVC (BPTC)"
   obe_service_type_id: "2"
   __proto__: Object


    //Sort options
    var sortable = [];
    for (var vehicle in options)
    sortable.push([vehicle, options[vehicle]]);
    sortable.sort(function(a, b) {
        return a[1].name < b[1].name ? -1 : 1;
    });


    //sortable => prints  
[Array[2], Array[2], Array[2], Array[2], Array[2], Array[2], Array[2]]
    0: Array[2]
    0: "11"
    1: Object
        id: "11"
        name: "AS/A2"
        obe_service_type_id: "2"
        __proto__: Object
        length: 2
        __proto__: Array[0]
    1: Array[2]
    0: "7"
    1: Object
        id: "7"
        name: "BVC (BPTC)"
        obe_service_type_id: "2"
        __proto__: Object
        length: 2

Answer 9

Hice un complemento solo para esto, acepta 1 arg, que es un objeto sin clasificar, y devuelve un objeto que ha sido ordenado por valor de prop. Esto funcionará en todos los objetos bidimensionales como {"Nick": 28, "Bob": 52} ...

var sloppyObj = {
    ''C'': 78,
    ''A'': 3,
    ''B'': 4
};

// Extend object to support sort method
function sortObj(obj) {
    "use strict";

    function Obj2Array(obj) {
        var newObj = [];
        for (var key in obj) {
            if (!obj.hasOwnProperty(key)) return;
            var value = [key, obj[key]];
            newObj.push(value);
        }
        return newObj;
    }

    var sortedArray = Obj2Array(obj).sort(function(a, b) {
        if (a[1] < b[1]) return -1;
        if (a[1] > b[1]) return 1;
        return 0;
    });

    function recreateSortedObject(targ) {
        var sortedObj = {};
        for (var i = 0; i < targ.length; i++) {
            sortedObj[targ[i][0]] = targ[i][1];
        }
        return sortedObj;
    }
    return recreateSortedObject(sortedArray);
}

var sortedObj = sortObj(sloppyObj);

alert(JSON.stringify(sortedObj));

Aquí hay una demostración de la función que funciona como se espera http://codepen.io/nicholasabrams/pen/RWRqve?editors=001

Answer 10

Los objetos de JavaScript no están ordenados por definición (consulte la Especificación del lenguaje ECMAScript , sección 8.6). La especificación del lenguaje ni siquiera garantiza que, si recorres las propiedades de un objeto dos veces seguidas, saldrán en el mismo orden la segunda vez.

Si necesita ordenar cosas, use una matriz y el método Array.prototype.sort.

Answer 11

No queremos duplicar toda la estructura de datos, o usar una matriz donde necesitamos una matriz asociativa.

Aquí hay otra manera de hacer lo mismo que bonna:

var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
keysSorted = Object.keys(list).sort(function(a,b){return list[a]-list[b]})
console.log(keysSorted);     // bar,me,you,foo

Answer 12

No se pudo encontrar la respuesta anterior que funcionaría y sería PEQUEÑA , y admitiría objetos anidados (no arrays), así que escribí la mía propia :) Funciona tanto con cadenas como con caracteres.

  function sortObjectProperties(obj, sortValue){
      var keysSorted = Object.keys(obj).sort(function(a,b){return obj[a][sortValue]-obj[b][sortValue]});
      var objSorted = {};
      for(var i = 0; i < keysSorted.length; i++){
          objSorted[keysSorted[i]] = obj[keysSorted[i]];
      }
      return objSorted;
    }

Uso:

    /* sample object with unsorder properties, that we want to sort by 
    their "customValue" property */

    var objUnsorted = {
       prop1 : {
          customValue : ''ZZ''
       },
       prop2 : {
          customValue : ''AA''
       }
    }

    // call the function, passing object and property with it should be sorted out
    var objSorted = sortObjectProperties(objUnsorted, ''customValue'');

    // now console.log(objSorted) will return:
    { 
       prop2 : {
          customValue : ''AA''
       },
       prop1 : {
          customValue : ''ZZ''
       } 
    }

Answer 13

Objeto ordenado por valor (DESC)

function sortObject(list) {
  var sortable = [];
  for (var key in list) {
    sortable.push([key, list[key]]);
  }

  sortable.sort(function(a, b) {
    return (a[1] > b[1] ? -1 : (a[1] < b[1] ? 1 : 0));
  });

  var orderedList = {};
  for (var i = 0; i < sortable.length; i++) {
    orderedList[sortable[i][0]] = sortable[i][1];
  }

  return orderedList;
}

Answer 14

Otra forma de resolver esto:

var res = [{"s1":5},{"s2":3},{"s3":8}].sort(function(obj1,obj2){ 
 var prop1;
 var prop2;
 for(prop in obj1) {
  prop1=prop;
 }
 for(prop in obj2) {
  prop2=prop;
 }
 //the above two for loops will iterate only once because we use it to find the key
 return obj1[prop1]-obj2[prop2];
});

// res tendrá la matriz de resultados

Answer 15

Para completar, esta función devuelve una matriz ordenada de propiedades de objeto:

function sortObject(obj) {
    var arr = [];
    for (var prop in obj) {
        if (obj.hasOwnProperty(prop)) {
            arr.push({
                ''key'': prop,
                ''value'': obj[prop]
            });
        }
    }
    arr.sort(function(a, b) { return a.value - b.value; });
    //arr.sort(function(a, b) { a.value.toLowerCase().localeCompare(b.value.toLowerCase()); }); //use this to sort as strings
    return arr; // returns array
}

var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
var arr = sortObject(list);
console.log(arr); // [{key:"bar", value:15}, {key:"me", value:75}, {key:"you", value:100}, {key:"foo", value:116}]

Jsfiddle con el código de arriba está aquí . Esta solución se basa en este artículo .

El violín actualizado para ordenar cadenas está aquí. Puede eliminar ambas conversiones .toLowerCase () adicionales para la comparación de cadenas sensibles a mayúsculas y minúsculas.

Answer 16

Por si acaso, alguien está buscando mantener el objeto (con claves y valores), usando la referencia del código de @Markus R y @James Moran comentando, solo use:

var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
var newO = {};
Object.keys(list).sort(function(a,b){return list[a]-list[b]})
                 .map(key => newO[key] = list[key]);
console.log(newO);  // {bar: 15, me: 75, you: 100, foo: 116}

Answer 17

Prueba esto. Incluso su objeto no es tener la propiedad basada en la que está tratando de ordenar, también se manejará.

Simplemente llámalo enviando propiedad con objeto.

var sortObjectByProperty = function(property,object){

    console.time("Sorting");
    var  sortedList      = [];
         emptyProperty   = [];
         tempObject      = [];
         nullProperty    = [];
    $.each(object,function(index,entry){
        if(entry.hasOwnProperty(property)){
            var propertyValue = entry[property];
            if(propertyValue!="" && propertyValue!=null){
              sortedList.push({key:propertyValue.toLowerCase().trim(),value:entry});  
            }else{
                emptyProperty.push(entry);
           }
        }else{
            nullProperty.push(entry);
        }
    });

      sortedList.sort(function(a,b){
           return a.key < b.key ? -1 : 1;
         //return a.key < b.key?-1:1;   // Asc 
         //return a.key < b.key?1:-1;  // Desc
      });


    $.each(sortedList,function(key,entry){
        tempObject[tempObject.length] = entry.value;
     });

    if(emptyProperty.length>0){
        tempObject.concat(emptyProperty);
    }
    if(nullProperty.length>0){
        tempObject.concat(nullProperty);
    }
    console.timeEnd("Sorting");
    return tempObject;
}

Answer 18

Si estoy teniendo un objeto como este,

var dayObj = {
              "Friday":["5:00pm to 12:00am"] ,
              "Wednesday":["5:00pm to 11:00pm"],
              "Sunday":["11:00am to 11:00pm"], 
              "Thursday":["5:00pm to 11:00pm"],
              "Saturday":["11:00am to 12:00am"]
           }

quiero ordenarlo por orden del día,

deberíamos tener el daySorterMap primero,

var daySorterMap = {
  // "sunday": 0, // << if sunday is first day of week
  "Monday": 1,
  "Tuesday": 2,
  "Wednesday": 3,
  "Thursday": 4,
  "Friday": 5,
  "Saturday": 6,
  "Sunday": 7
}

Iniciar un objeto separado ordenadoDayObj,

var sortedDayObj={};
Object.keys(dayObj)
.sort((a,b) => daySorterMap[a] - daySorterMap[b])
.forEach(value=>sortedDayObj[value]= dayObj[value])

Puedes devolver el ordenadoDayObj

Answer 19

Sus objetos pueden tener cualquier cantidad de propiedades y usted puede elegir ordenar por cualquier propiedad de objeto, número o cadena, si coloca los objetos en una matriz. Considera esta matriz:

var arrayOfObjects = [   
    {
        name: ''Diana'',
        born: 1373925600000, // Mon, Jul 15 2013
        num: 4,
        sex: ''female''
    },
    {

        name: ''Beyonce'',
        born: 1366832953000, // Wed, Apr 24 2013
        num: 2,
        sex: ''female''
    },
    {            
        name: ''Albert'',
        born: 1370288700000, // Mon, Jun 3 2013
        num: 3,
        sex: ''male''
    },    
    {
        name: ''Doris'',
        born: 1354412087000, // Sat, Dec 1 2012
        num: 1,
        sex: ''female''
    }
];

ordenar por fecha de nacimiento, el más antiguo primero

// use slice() to copy the array and not just make a reference
var byDate = arrayOfObjects.slice(0);
byDate.sort(function(a,b) {
    return a.born - b.born;
});
console.log(''by date:'');
console.log(byDate);

ordenar por nombre

var byName = arrayOfObjects.slice(0);
byName.sort(function(a,b) {
    var x = a.name.toLowerCase();
    var y = b.name.toLowerCase();
    return x < y ? -1 : x > y ? 1 : 0;
});

console.log(''by name:'');
console.log(byName);

http://jsfiddle.net/xsM5s/16/

Answer 20

Una versión "con flecha" de la respuesta de @marcusR para referencia

var myObj = {"you": 100, "me": 75, "foo": 116, "bar": 15};
keysSorted = Object.keys(myObj).sort((a,b) => myObj[a]-myObj[b])
alert(keysSorted);     // bar,me,you,foo

ACTUALIZACIÓN: abril de 2017 - Esto devuelve un objeto myObj ordenado definido anteriormente.

Object
 .keys(myObj)
 .sort((a, b) => myObj[a]-myObj[b])
 .reduce((_sortedObj, key) => ({
   ..._sortedObj, 
   [key]: myObj[key]
 }), {})

Pruébalo aquí!

ACTUALIZACIÓN: Octubre 2018 - Versión Object.entries

Object
 .entries(myObj)
 .sort()
 .reduce((_sortedObj, [k,v]) => ({
   ..._sortedObj, 
   [k]: v
 }), {})

Pruébalo aquí!

Answer 21

Underscore.js o Lodash.js para ordenamiento avanzado de matrices u objetos

 var data={
        "models": {

            "LTI": [
                "TX"
            ],
            "Carado": [
                "A",
                "T",
                "A(пасс)",
                "A(груз)",
                "T(пасс)",
                "T(груз)",
                "A",
                "T"
            ],
            "SPARK": [
                "SP110C 2",
                "sp150r 18"
            ],
            "Autobianchi": [
                "A112"
            ]
        }
    };

    var arr=[],
        obj={};
    for(var i in data.models){
      arr.push([i, _.sortBy(data.models[i],function (el){return el;})]);
    }
    arr=_.sortBy(arr,function (el){
      return el[0];
    });
    _.map(arr,function (el){return obj[el[0]]=el[1];});
     console.log(obj);

demo

Answer 22

Usando query-js puedes hacerlo así.

list.keys().select(function(k){
    return {
        key: k,
        value : list[k]
    }
}).orderBy(function(e){ return e.value;});

Puedes encontrar un artículo introductorio en query-js here

Answer 23

muchas funciones similares y útiles: https://github.com/shimondoodkin/groupbyfunctions/

function sortobj(obj)
{
    var keys=Object.keys(obj);
    var kva= keys.map(function(k,i)
    {
        return [k,obj[k]];
    });
    kva.sort(function(a,b){
        if(a[1]>b[1]) return -1;if(a[1]<b[1]) return 1;
        return 0
    });
    var o={}
    kva.forEach(function(a){ o[a[0]]=a[1]})
    return o;
}

function sortobjkey(obj,key)
{
    var keys=Object.keys(obj);
    var kva= keys.map(function(k,i)
    {
        return [k,obj[k]];
    });
    kva.sort(function(a,b){
        k=key;      if(a[1][k]>b[1][k]) return -1;if(a[1][k]<b[1][k]) return 1;
        return 0
    });
    var o={}
    kva.forEach(function(a){ o[a[0]]=a[1]})
    return o;
}

Answer 24

De acuerdo , como sabrás, javascript tiene la función sort () para ordenar los arreglos, pero nada para el objeto ...

Entonces, en ese caso, necesitamos obtener de alguna manera la matriz de las claves y ordenarlas, esa es la razón por la que la apis le da objetos en una matriz la mayor parte del tiempo, porque la matriz tiene más funciones nativas para jugar con ellas que el objeto literal, de todos modos, la solución rápida es usar Object.key, que devuelve una matriz de las claves de objeto, creo la función ES6 debajo de la cual se encarga del trabajo, usa las funciones de ordenación () y reducción () nativas en javascript:

function sortObject(obj) {
  return Object.keys(obj)
    .sort().reduce((a, v) => {
    a[v] = obj[v];
    return a; }, {});
}

Y ahora puedes usarlo así:

let myObject = {a: 1, c: 3, e: 5, b: 2, d: 4};
let sortedMyObject = sortObject(myObject);

Verifique el ordenadoMyObject y podrá ver el resultado ordenado por claves como esta:

{a: 1, b: 2, c: 3, d: 4, e: 5}

También de esta manera, el objeto principal no se tocará y en realidad obtendremos un nuevo objeto.

También creo la imagen a continuación, para que los pasos de la función sean más claros, en caso de que necesite cambiarlo un poco para que funcione a su manera:

Answer 25

a = { b: 1, p: 8, c: 2, g: 1 }
Object.keys(a)
  .sort((c,b) => {
    return a[b]-a[c]
  })
  .reduce((acc, cur) => {
    let o = {}
    o[cur] = a[cur]
    acc.push(o)
    return acc
   } , [])

salida = [{p: 8}, {c: 2}, {b: 1}, {g: 1}]

Answer 26

function sortObjByValue(list){
 var sortedObj = {}
 Object.keys(list)
  .map(key => [key, list[key]])
  .sort((a,b) => a[1] > b[1] ? 1 : a[1] < b[1] ? -1 : 0)
  .forEach(data => sortedObj[data[0]] = data[1]);
 return sortedObj;
}
sortObjByValue(list);

Link Github Gist

Answer 27

var list = {
    "you": 100,
    "me": 75,
    "foo": 116,
    "bar": 15
};
var tmpList = {};
while (Object.keys(list).length) {
    var key = Object.keys(list).reduce((a, b) => list[a] > list[b] ? a : b);
    tmpList[key] = list[key];
    delete list[key];
}
list = tmpList;
console.log(list); // { foo: 116, you: 100, me: 75, bar: 15 }

Answer 28

var list = {
    "you": 100, 
    "me": 75, 
    "foo": 116, 
    "bar": 15
};

function sortAssocObject(list) {
    var sortable = [];
    for (var key in list) {
        sortable.push([key, list[key]]);
    }

    sortable.sort(function(a, b) {
        return (a[1] < b[1] ? -1 : (a[1] > b[1] ? 1 : 0));
    });

    var orderedList = {};
    for (var i = 0; i < sortable.length; i++) {
        orderedList[sortable[i][0]] = sortable[i][1];
    }

    return orderedList;
}

sortAssocObject(list);

// {bar: 15, me: 75, you: 100, foo: 116}