Objecteigenschap sorteren op waarden

Als ik een JavaScript-object heb zoals:

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

Is er een manier om de eigenschappen op waarde te sorteren? Zodat ik eindig met

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

Antwoord 1, autoriteit 100%

Verplaats ze naar een array, sorteer die array en gebruik die array vervolgens voor jouw doeleinden. Hier is een oplossing:

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

Zodra u de array hebt, kunt u het object uit de array opnieuw opbouwen in de door u gewenste volgorde, zodat u precies kunt bereiken wat u van plan was te doen. Dat zou werken in alle browsers die ik ken, maar het zou afhankelijk zijn van een implementatie-eigenaardigheid en zou op elk moment kunnen breken. Maak nooit aannames over de volgorde van elementen in een JavaScript-object.

var objSorted = {}
sortable.forEach(function(item){
    objSorted[item[0]]=item[1]
})

In ES8 kunt u Object.entries()om het object om te zetten in een array:

const maxSpeed = {
    car: 300, 
    bike: 60, 
    motorbike: 200, 
    airplane: 1000,
    helicopter: 400, 
    rocket: 8 * 60 * 60
};
const sortable = Object.entries(maxSpeed)
    .sort(([,a],[,b]) => a-b)
    .reduce((r, [k, v]) => ({ ...r, [k]: v }), {});
console.log(sortable);

Antwoord 2, autoriteit 55%

We willen niet de hele gegevensstructuur dupliceren, of een array gebruiken waar we een associatieve array nodig hebben.

Hier is een andere manier om hetzelfde te doen als 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

Antwoord 3, autoriteit 25%

Uw objecten kunnen een willekeurig aantal eigenschappen hebben en u kunt ervoor kiezen om te sorteren op de objecteigenschap die u wilt, aantal of tekenreeks, als u de objecten in een array plaatst. Overweeg deze array:

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

sorteer op geboortedatum, oudste eerst

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

sorteer op naam

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/


Antwoord 4, autoriteit 10%

ECMAScript 2017 introduceert Object.values / Object.entries. Zoals de naam al doet vermoeden, aggregeert de eerste alle waarden van een object in een array, en de laatste doet het hele object in een array van [key, value]arrays; Python’s equivalent van dict.values()en dict.items().

De functies maken het vrij eenvoudiger om elke hash in een geordend object te sorteren. Vanaf nu ondersteunt slechts een klein deel van de JavaScript-platforms ze, maar u kunt het proberen op Firefox 47+.

EDIT: nu ondersteund door alle moderne browsers!

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

Antwoord 5, autoriteit 8%

Voor de volledigheid retourneert deze functie gesorteerde arrayvan objecteigenschappen:

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 met de bovenstaande code is hier. Deze oplossing is gebaseerd op dit artikel.

De bijgewerkte viool voor het sorteren van strings is hier.U kunt beide aanvullende .toLowerCase()-conversies verwijderen voor hoofdletters gevoelige tekenreeksvergelijking.


Antwoord 6, autoriteit 6%

Een “gepijlde” versie van @marcusR’s antwoordter referentie

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

UPDATE: april 2017
Dit retourneert een gesorteerd myObj-object dat hierboven is gedefinieerd.

const myObj = { you: 100, me: 75, foo: 116, bar: 15 };
const result =
  Object.keys(myObj)
    .sort((a, b) => myObj[a] - myObj[b])
    .reduce(
      (_sortedObj, key) => ({
        ..._sortedObj,
        [key]: myObj[key]
      }),
      {}
    );
document.write(JSON.stringify(result));

Antwoord 7, autoriteit 4%

JavaScript-objecten zijn per definitie ongeordend (zie de ECMAScript-taal
Specificatie
, sectie 8.6). De taalspecificatie garandeert niet eens dat, als je de eigenschappen van een object twee keer achter elkaar herhaalt, ze de tweede keer in dezelfde volgorde uitkomen.

Als je dingen wilt bestellen, gebruik dan een array en de methode Array.prototype.sort.


Antwoord 8, autoriteit 4%

OK, zoals u wellicht weet, heeft javascript de functie sort()om arrays te sorteren, maar niets voor object…

Dus in dat geval moeten we op de een of andere manier een array van de sleutels krijgen en ze sorteren, dat is de reden waarom de apis je meestal objecten in een array geeft, omdat Array meer native functies heeft om ermee te spelen dan object letterlijk , hoe dan ook, de snelle solotion gebruikt Object.keydie een array van de objectsleutels retourneert, ik maak de functie ES6hieronder die het werk voor je doet, het gebruikt native sort()en reduce()functies in javascript:

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

En nu kun je het als volgt gebruiken:

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

Controleer het gesorteerd MyObject en u kunt het resultaat als volgt gesorteerd op sleutels zien:

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

Ook op deze manier wordt het hoofdobject niet aangeraakt en krijgen we eigenlijk een nieuw object.

Ik maak ook de onderstaande afbeelding om de functiestappen duidelijker te maken, voor het geval je het een beetje moet veranderen om het op jouw manier te laten werken:

Een javascript-object sorteren op eigenschapswaarde


Antwoord 9

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]]);
    }
    // [["you",100],["me",75],["foo",116],["bar",15]]
    sortable.sort(function(a, b) {
        return (a[1] < b[1] ? -1 : (a[1] > b[1] ? 1 : 0));
    });
    // [["bar",15],["me",75],["you",100],["foo",116]]
    var orderedList = {};
    for (var idx in sortable) {
        orderedList[sortable[idx][0]] = sortable[idx][1];
    }
    return orderedList;
}
sortAssocObject(list);
// {bar: 15, me: 75, you: 100, foo: 116}

Antwoord 10

Update met ES6: als u zich zorgen maakt over een gesorteerd object om doorheen te itereren (en daarom kan ik me voorstellen dat u uw objecteigenschappen gesorteerd wilt hebben), kunt u de Kaart-object.

U kunt uw paren (sleutel, waarde) in gesorteerde volgorde invoegen en vervolgens een for..of-lus uitvoeren garanderendat ze worden herhaald in de volgorde waarin u ze hebt ingevoegd

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

Antwoord 11

Sorteer waarden zonder meerdere for-loops (om te sorteren op de sleutels verander de index in de sort callback naar “0”)

const list = {
    "you": 100, 
    "me": 75, 
    "foo": 116, 
    "bar": 15
  };
let sorted = Object.fromEntries(
                Object.entries(list).sort( (a,b) => a[1] - b[1] )    
             ) 
console.log('Sorted object: ', sorted) 

Antwoord 12

Heel kort en eenvoudig!

var sortedList = {};
Object.keys(list).sort((a,b) => list[a]-list[b]).forEach((key) => {
    sortedList[key] = list[key]; });

Antwoord 13

Underscore.js of Lodash.js voor geavanceerde array- of objectsorteringen

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


Antwoord 14

Ik volg de oplossing van slebetman(lees het voor alle details ), maar aangepast, aangezien uw object niet genest is.

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

Antwoord 15

<pre>
function sortObjectByVal(obj){  
var keysSorted = Object.keys(obj).sort(function(a,b){return obj[b]-obj[a]});
var newObj = {};
for(var x of keysSorted){
    newObj[x] = obj[x];
}
return newObj;
}
var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
console.log(sortObjectByVal(list));
</pre>

Antwoord 16

Met dank aan @orad voor het geven van het antwoord in TypeScript. Nu kunnen we de onderstaande codesnippet in JavaScript gebruiken.

function sort(obj,valSelector) {
  const sortedEntries = Object.entries(obj)
    .sort((a, b) =>
      valSelector(a[1]) > valSelector(b[1]) ? 1 :
      valSelector(a[1]) < valSelector(b[1]) ? -1 : 0);
  return new Map(sortedEntries);
}
const Countries = { "AD": { "name": "Andorra", }, "AE": { "name": "United Arab Emirates", }, "IN": { "name": "India", }} 
// Sort the object inside object. 
var sortedMap = sort(Countries, val => val.name); 
// Convert to object. 
var sortedObj = {}; 
sortedMap.forEach((v,k) => { sortedObj[k] = v }); console.log(sortedObj); 
//Output: {"AD": {"name": "Andorra"},"IN": {"name": "India"},"AE": {"name": "United Arab Emirates"}}

Antwoord 17

Dit kan een eenvoudige manier zijn om het als een echt geordend object te behandelen. Niet zeker hoe traag het is. misschien is het ook beter met een while-lus.

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
}

En toen vond ik deze invert-functie van:
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;
};

Dus

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)

Antwoord 18

Object gesorteerd op waarde (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;
}

Antwoord 19

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
   } , [])

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


Antwoord 20

Voor het geval iemand op zoek is naar het behouden van het object (met sleutels en waarden), met behulp van de codeverwijzing door @Markus R en @James Moran commentaar, gebruik gewoon:

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}

Antwoord 21

   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 }

Antwoord 22

TypeScript

De volgende functie sorteert object op waarde of een eigenschap van de waarde. Als u TypeScript niet gebruikt, kunt u de type-informatie verwijderen om het naar JavaScript te converteren.

/**
 * Represents an associative array of a same type.
 */
interface Dictionary<T> {
  [key: string]: T;
}
/**
 * Sorts an object (dictionary) by value or property of value and returns
 * the sorted result as a Map object to preserve the sort order.
 */
function sort<TValue>(
  obj: Dictionary<TValue>,
  valSelector: (val: TValue) => number | string,
) {
  const sortedEntries = Object.entries(obj)
    .sort((a, b) =>
      valSelector(a[1]) > valSelector(b[1]) ? 1 :
      valSelector(a[1]) < valSelector(b[1]) ? -1 : 0);
  return new Map(sortedEntries);
}

Gebruik

var list = {
  "one": { height: 100, weight: 15 },
  "two": { height: 75, weight: 12 },
  "three": { height: 116, weight: 9 },
  "four": { height: 15, weight: 10 },
};
var sortedMap = sort(list, val => val.height);

De volgorde van sleutels in een JavaScript-object is niet gegarandeerd, dus ik sorteer en retourneer het resultaat als een Map-object dat de sorteervolgorde behoudt.

Als u het terug naar Object wilt converteren, kunt u dit doen:

var sortedObj = {} as any;
sortedMap.forEach((v,k) => { sortedObj[k] = v });

Antwoord 23

const arrayOfObjects = [
{name: 'test'},
{name: 'test2'}
]
const order = ['test2', 'test']
const setOrder = (arrayOfObjects, order) =>
    arrayOfObjects.sort((a, b) => {
        if (order.findIndex((i) => i === a.name) < order.findIndex((i) => i === b.name)) {
            return -1;
        }
        if (order.findIndex((i) => i === a.name) > order.findIndex((i) => i === b.name)) {
            return 1;
        }
        return 0;
    });

Antwoord 24

let toSort = {a:2323, b: 14, c: 799} 
let sorted = Object.entries(toSort ).sort((a,b)=> a[1]-b[1]) 

Uitvoer:

[ [ "b", 14 ], [ "c", 799 ], [ "a", 2323 ] ]

Antwoord 25

Er zijn veel manieren om dit te doen, maar aangezien ik er geen zag met reduce(), heb ik het hier geplaatst. Misschien lijkt het iemand nuttig.

var list = {
    "you": 100,
    "me": 75,
    "foo": 116,
    "bar": 15
};
let result = Object.keys(list).sort((a,b)=>list[a]>list[b]?1:-1).reduce((a,b)=> {a[b]=list[b]; return a},{});
console.log(result);

Antwoord 26

veel vergelijkbare en handige functies:
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;
}

Antwoord 27

Hier is nog een voorbeeld:

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

Antwoord 28

hier is de manier om het object te sorteren en het gesorteerde object terug te krijgen

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

u kunt uw sorteerfunctie naar wens aanpassen


Antwoord 29

invoer is object, uitvoer is object, met behulp van lodash & js ingebouwde lib, met aflopende of oplopende optie, en muteert invoerobject niet

bijv. invoer & uitvoer

{
  "a": 1,
  "b": 4,
  "c": 0,
  "d": 2
}
{
  "b": 4,
  "d": 2,
  "a": 1,
  "c": 0
}

De implementatie

const _ = require('lodash');
const o = { a: 1, b: 4, c: 0, d: 2 };
function sortByValue(object, descending = true) {
  const { max, min } = Math;
  const selector = descending ? max : min;
  const objects = [];
  const cloned = _.clone(object);
  while (!_.isEmpty(cloned)) {
    const selectedValue = selector(...Object.values(cloned));
    const [key, value] = Object.entries(cloned).find(([, value]) => value === selectedValue);
    objects.push({ [key]: value });
    delete cloned[key];
  }
  return _.merge(...objects);
}
const o2 = sortByValue(o);
console.log(JSON.stringify(o2, null, 2));

Antwoord 30

mijn oplossing met sort :

let list = {
    "you": 100, 
    "me": 75, 
    "foo": 116, 
    "bar": 15
};
let sorted = Object.entries(list).sort((a,b) => a[1] - b[1]);
for(let element of sorted) {
    console.log(element[0]+ ": " + element[1]);
}

Other episodes