Trier les objets JavaScript par clé
Je dois trier les objets JavaScript par clé.
D'où ce qui suit:
{ 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' }
Deviendrait:
{ 'a' : 'dsfdsfsdf', 'b' : 'asdsad', 'c' : 'masdas' }
Objets JavaScript1 ne sont pas commandés. Essayer de les "trier" n'a pas de sens. Si vous souhaitez parcourir les propriétés d'un objet, vous pouvez trier les clés puis récupérer les valeurs associées:
var myObj = {
'b': 'asdsadfd',
'c': 'masdasaf',
'a': 'dsfdsfsdf'
},
keys = [],
k, i, len;
for (k in myObj) {
if (myObj.hasOwnProperty(k)) {
keys.Push(k);
}
}
keys.sort();
len = keys.length;
for (i = 0; i < len; i++) {
k = keys[i];
console.log(k + ':' + myObj[k]);
}Autre implémentation utilisant Object.keys fantaisie:
var myObj = {
'b': 'asdsadfd',
'c': 'masdasaf',
'a': 'dsfdsfsdf'
},
keys = Object.keys(myObj),
i, len = keys.length;
keys.sort();
for (i = 0; i < len; i++) {
k = keys[i];
console.log(k + ':' + myObj[k]);
}1Ne pas être pédant, mais il n’existe pas d’objet JSON .
Beaucoup de gens ont mentionné que "les objets ne peuvent pas être triés" , mais après cela, ils vous proposent une solution qui fonctionne. Paradoxe, n'est-ce pas?
Personne ne dit pourquoi ces solutions fonctionnent. Ils le sont, car dans la plupart des implémentations du navigateur, les valeurs des objets sont stockées dans l'ordre dans lequel elles ont été ajoutées. C'est pourquoi, si vous créez un nouvel objet à partir d'une liste de clés triée, vous obtenez un résultat attendu.
Et je pense que nous pourrions ajouter une solution supplémentaire - la manière fonctionnelle ES5:
function sortObject(obj) {
return Object.keys(obj).sort().reduce(function (result, key) {
result[key] = obj[key];
return result;
}, {});
}
Version ES2015 de ci-dessus (formaté en "one-liner"):
function sortObject(o) {
return Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {});
}
Brève explication des exemples ci-dessus (comme demandé dans les commentaires):
Object.keys nous donne une liste de clés dans l'objet fourni (obj ou o), puis nous les trions à l'aide de l'algorithme de tri par défaut, next .reduce est utilisé pour reconvertir ce tableau en objet, mais cette fois avec toutes les clés triées. .
Ça marche pour moi
/**
* Return an Object sorted by it's Key
*/
var sortObjectByKey = function(obj){
var keys = [];
var sorted_obj = {};
for(var key in obj){
if(obj.hasOwnProperty(key)){
keys.Push(key);
}
}
// sort keys
keys.sort();
// create new array based on Sorted Keys
jQuery.each(keys, function(i, key){
sorted_obj[key] = obj[key];
});
return sorted_obj;
};
Les gars je suis figurativement choqué! Certes, toutes les réponses sont un peu anciennes, mais personne n’a même mentionné la stabilité dans le tri! Alors soyez patient avec moi, je ferai de mon mieux pour répondre à la question elle-même et entrer dans les détails ici. Je vais donc m'excuser, il y aura beaucoup de choses à lire.
_ {Depuis 2018, je n'utiliserai que ES6, les Polyfill sont tous disponibles dans la documentation MDN, que je vais lier à la partie donnée.
Réponse à la question:
Si vos clés ne sont que des chiffres, vous pouvez utiliser en toute sécurité Object.keys() avec Array.prototype.reduce() pour renvoyer l'objet trié:
// Only numbers to show it will be sorted.
const testObj = {
'2000': 'Articel1',
'4000': 'Articel2',
'1000': 'Articel3',
'3000': 'Articel4',
};
// I'll explain what reduces does after the answer.
console.log(Object.keys(testObj).reduce((accumulator, currentValue) => {
accumulator[currentValue] = testObj[currentValue];
return accumulator;
}, {}));
/**
* expected output:
* {
* '1000': 'Articel3',
* '2000': 'Articel1',
* '3000': 'Articel4',
* '4000': 'Articel2'
* }
*/
// if needed here is the one liner:
console.log(Object.keys(testObj).reduce((a, c) => (a[c] = testObj[c], a), {}));
Cependant, si vous travaillez avec des chaînes, je vous recommande fortement d'enchaîner Array.prototype.sort() dans tout ceci:
// String example
const testObj = {
'a1d78eg8fdg387fg38': 'Articel1',
'z12989dh89h31d9h39': 'Articel2',
'f1203391dhj32189h2': 'Articel3',
'b10939hd83f9032003': 'Articel4',
};
// Chained sort into all of this.
console.log(Object.keys(testObj).sort().reduce((accumulator, currentValue) => {
accumulator[currentValue] = testObj[currentValue];
return accumulator;
}, {}));
/**
* expected output:
* {
* a1d78eg8fdg387fg38: 'Articel1',
* b10939hd83f9032003: 'Articel4',
* f1203391dhj32189h2: 'Articel3',
* z12989dh89h31d9h39: 'Articel2'
* }
*/
// again the one liner:
console.log(Object.keys(testObj).sort().reduce((a, c) => (a[c] = testObj[c], a), {}));
Si quelqu'un se demande ce que réduit fait:
// Will return Keys of object as an array (sorted if only numbers or single strings like a,b,c).
Object.keys(testObj)
// Chaining reduce to the returned array from Object.keys().
// Array.prototype.reduce() takes one callback
// (and another param look at the last line) and passes 4 arguments to it:
// accumulator, currentValue, currentIndex and array
.reduce((accumulator, currentValue) => {
// setting the accumulator (sorted new object) with the actual property from old (unsorted) object.
accumulator[currentValue] = testObj[currentValue];
// returning the newly sorted object for the next element in array.
return accumulator;
// the empty object {} ist the initial value for Array.prototype.reduce().
}, {});
Si nécessaire, voici l'explication de la doublure:
Object.keys(testObj).reduce(
// Arrow function as callback parameter.
(a, c) =>
// parenthesis return! so we can safe the return and write only (..., a);
(a[c] = testObj[c], a)
// initial value for reduce.
,{}
);
- Documents pour réduire: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce
- Pourquoi utiliser des parenthèses dans les instructions de retour JavaScript: http://jamesknelson.com/javascript-return-parenthesis/
Pourquoi le tri est un peu compliqué:
En bref, Object.keys() retournera un tableau avec le même ordre que celui obtenu avec une boucle normale:
const object1 = {
a: 'somestring',
b: 42,
c: false
};
console.log(Object.keys(object1));
// expected output: Array ["a", "b", "c"]
Object.keys () renvoie un tableau dont les éléments sont des chaînes correspondant aux propriétés énumérables trouvées directement sur l'objet . L'ordre des propriétés est le même que celui donné par looping sur les propriétés de l'objet manuellement.
Sidenote - vous pouvez aussi utiliser Object.keys() sur les tableaux, gardez à l'esprit que l'index sera retourné:
// simple array
const arr = ['a', 'b', 'c'];
console.log(Object.keys(arr)); // console: ['0', '1', '2']
Mais il n’est pas aussi facile de voir ces exemples, les objets du monde réel peuvent contenir des nombres et des caractères alphabétiques ou même des symboles (veuillez ne pas le faire).
Voici un exemple avec tous dans un seul objet:
// This is just to show what happens, please don't use symbols in keys.
const testObj = {
'1asc': '4444',
1000: 'a',
b: '1231',
'#01010101010': 'asd',
2: 'c'
};
console.log(Object.keys(testObj));
// output: [ '2', '1000', '1asc', 'b', '#01010101010' ]
Maintenant, si nous utilisons Array.prototype.sort() sur le tableau au-dessus de la sortie, les changements:
console.log(Object.keys(testObj).sort());
// output: [ '#01010101010', '1000', '1asc', '2', 'b' ]
Voici une citation de la documentation:
La méthode sort () trie les éléments d'un tableau à la place et renvoie le tableau. Le genre n'est pas nécessairement stable. L'ordre de tri par défaut est en fonction de la chaîne de points de code Unicode.
La complexité temporelle et spatiale de ce type ne peut pas être garantie car elle dépend de la mise en œuvre.
Vous devez vous assurer que l'un d'eux renvoie la sortie souhaitée pour vous. Dans les exemples réels, les gens ont tendance à mélanger les choses, surtout si vous utilisez ensemble des entrées d'informations telles que des API et des bases de données.
Alors, quel est le problème?
Eh bien, il y a deux articles que chaque programmeur devrait comprendre:
En informatique, un algorithme sur place est un algorithme qui transforme une entrée sans structure de données auxiliaire. Cependant, une petite quantité d'espace de stockage supplémentaire est autorisée pour les variables auxiliaires. L'entrée est généralement écrasée par la sortie lors de l'exécution de l'algorithme. L'algorithme en place met à jour la séquence d'entrée uniquement par le remplacement ou l'échange d'éléments. Un algorithme qui n'est pas en place est parfois appelé non-en-place ou en-dehors.
Donc, fondamentalement, notre ancien tableau sera écrasé! Ceci est important si vous souhaitez conserver l'ancien tableau pour d'autres raisons. Alors gardez cela à l'esprit.
Les algorithmes de tri stables trient les éléments identiques dans le même ordre que ils apparaissent dans l'entrée. Lors du tri de certains types de données, seule une partie des données est examiné lors de la détermination de l'ordre de tri. Par exemple, dans l'exemple de tri des cartes à droite, les cartes sont en cours de tri par leur rang, et leur costume est ignoré. Cela permet à la possibilité de plusieurs versions différentes correctement triées du fichier liste originale. Les algorithmes de tri stables choisissent l’un d’eux, selon la règle suivante: si deux éléments sont égaux, comme les deux 5 cartes, alors leur ordre relatif sera préservé, de sorte que si l'un est venu avant l'autre dans l'entrée, il viendra aussi avant l'autre dans la sortie.
Un exemple de type stable sur les cartes à jouer. Quand les cartes sont triées par rang avec une sorte stable, les deux 5 doivent rester dans le même ordre dans la sortie triée dans laquelle ils se trouvaient à l’origine. Quand ils sont triés avec une sorte non stable, les 5 peuvent finir dans l’ordre inverse dans la sortie triée.
Cela montre que le tri est correct mais que cela a changé. Donc, dans le monde réel, même si le tri est correct, nous devons nous assurer que nous obtenons ce que nous attendons! C'est très important, gardez cela à l'esprit également. Pour plus d'exemples JavaScript, consultez Array.prototype.sort () - docs: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort
C'est une vieille question, mais, à l'instar de la réponse de Mathias Bynens, j'ai créé une version courte pour trier l'objet current , sans trop de charge.
Object.keys(unordered).sort().forEach(function(key) {
var value = unordered[key];
delete unordered[key];
unordered[key] = value;
});
après l'exécution du code, l'objet "non ordonné" lui-même aura les clés triées par ordre alphabétique.
En utilisant lodash cela fonctionnera:
some_map = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' }
// perform a function in order of ascending key
_(some_map).keys().sort().each(function (key) {
var value = some_map[key];
// do something
});
// or alternatively to build a sorted list
sorted_list = _(some_map).keys().sort().map(function (key) {
var value = some_map[key];
// return something that shall become an item in the sorted list
}).value();
Juste matière à réflexion.
Supposons que cela puisse être utile dans le débogueur VisualStudio qui montre les propriétés d'objet non ordonnées.
(function(s){var t={};Object.keys(s).sort().forEach(function(k){t[k]=s[k]});return t})({b:2,a:1,c:3})
voici le 1 paquebot
var data = { zIndex:99,
name:'sravan',
age:25,
position:'architect',
amount:'100k',
manager:'mammu'
};
console.log(Object.entries(data).sort().reduce( (o,[k,v]) => (o[k]=v,o), {} ));function order(unordered)
{
return _.object(_.sortBy(_.pairs(unordered),function(o){return o[0]}));
}
Si vous ne faites pas confiance à votre navigateur pour conserver l'ordre des clés, je vous suggère fortement de vous fier à un tableau ordonné de tableaux de paires clé-valeur.
_.sortBy(_.pairs(c),function(o){return o[0]})
Peut-être une forme un peu plus élégante:
/**
* Sorts a key-value object by key, maintaining key to data correlations.
* @param {Object} src key-value object
* @returns {Object}
*/
var ksort = function ( src ) {
var keys = Object.keys( src ),
target = {};
keys.sort();
keys.forEach(function ( key ) {
target[ key ] = src[ key ];
});
return target;
};
// Usage
console.log(ksort({
a:1,
c:3,
b:2
}));P.S. et la même chose avec la syntaxe ES6 +:
function ksort( src ) {
const keys = Object.keys( src );
keys.sort();
return keys.reduce(( target, key ) => {
target[ key ] = src[ key ];
return target;
}, {});
};
function sortObjectKeys(obj){
return Object.keys(obj).sort().reduce((acc,key)=>{
acc[key]=obj[key];
return acc;
},{});
}
sortObjectKeys({
telephone: '069911234124',
name: 'Lola',
access: true,
});
tri récursif, pour les objets et les tableaux imbriqués
function sortObjectKeys(obj){
return Object.keys(obj).sort().reduce((acc,key)=>{
if (Array.isArray(obj[key])){
acc[key]=obj[key].map(sortObjectKeys);
}
if (typeof obj[key] === 'object'){
acc[key]=sortObjectKeys(obj[key]);
}
else{
acc[key]=obj[key];
}
return acc;
},{});
}
// test it
sortObjectKeys({
telephone: '069911234124',
name: 'Lola',
access: true,
cars: [
{name: 'Family', brand: 'Volvo', cc:1600},
{
name: 'City', brand: 'VW', cc:1200,
interior: {
wheel: 'plastic',
radio: 'blaupunkt'
}
},
{
cc:2600, name: 'Killer', brand: 'Plymouth',
interior: {
wheel: 'wooden',
radio: 'earache!'
}
},
]
});
Nous sommes en 2019 et nous avons un moyen en 2019 de résoudre ce problème :)
Object.fromEntries(Object.entries({b: 3, a:8, c:1}).sort())
Comme déjà mentionné, les objets ne sont pas ordonnés.
Toutefois...
Vous pouvez trouver cet idiome utile:
var o = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' };
var kv = [];
for (var k in o) {
kv.Push([k, o[k]]);
}
kv.sort()
Vous pouvez ensuite parcourir kv et faire ce que vous voulez.
> kv.sort()
[ [ 'a', 'dsfdsfsdf' ],
[ 'b', 'asdsad' ],
[ 'c', 'masdas' ] ]
Il suffit d’utiliser lodash pour décompresser la carte et trier La première valeur de paire et Zip une fois de plus, elle retournera la clé triée.
Si vous voulez trier par valeur, changez l'index de la paire en 1 au lieu de 0
var o = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' };
console.log(_(o).toPairs().sortBy(0).fromPairs().value())
Voici une version propre basée sur Lodash qui fonctionne avec des objets imbriqués
/**
* Sort of the keys of an object alphabetically
*/
const sortKeys = function(obj) {
if(_.isArray(obj)) {
return obj.map(sortKeys);
}
if(_.isObject(obj)) {
return _.fromPairs(_.keys(obj).sort().map(key => [key, sortKeys(obj[key])]));
}
return obj;
};
Ce serait encore plus propre si lodash avait une méthode toObject() ...
Solution:
function getSortedObject(object) {
var sortedObject = {};
var keys = Object.keys(object);
keys.sort();
for (var i = 0, size = keys.length; i < size; i++) {
key = keys[i];
value = object[key];
sortedObject[key] = value;
}
return sortedObject;
}
// Test run
getSortedObject({d: 4, a: 1, b: 2, c: 3});
Explication:
De nombreuses exécutions JavaScript stockent des valeurs dans un objet dans l'ordre dans lequel elles ont été ajoutées.
Pour trier les propriétés d'un objet en fonction de leurs clés, vous pouvez utiliser la fonction Object.keys qui retournera un tableau de clés. Le tableau de clés peut ensuite être trié selon la méthode Array.prototype.sort () qui trie les éléments d'un tableau à la place (inutile de les affecter à une nouvelle variable).
Une fois les clés triées, vous pouvez commencer à les utiliser une par une pour accéder au contenu de l'ancien objet afin de remplir un nouvel objet (qui est maintenant trié).
Vous trouverez ci-dessous un exemple de procédure (vous pouvez le tester dans les navigateurs ciblés):
/**
* Returns a copy of an object, which is ordered by the keys of the original object.
*
* @param {Object} object - The original object.
* @returns {Object} Copy of the original object sorted by keys.
*/
function getSortedObject(object) {
// New object which will be returned with sorted keys
var sortedObject = {};
// Get array of keys from the old/current object
var keys = Object.keys(object);
// Sort keys (in place)
keys.sort();
// Use sorted keys to copy values from old object to the new one
for (var i = 0, size = keys.length; i < size; i++) {
key = keys[i];
value = object[key];
sortedObject[key] = value;
}
// Return the new object
return sortedObject;
}
/**
* Test run
*/
var unsortedObject = {
d: 4,
a: 1,
b: 2,
c: 3
};
var sortedObject = getSortedObject(unsortedObject);
for (var key in sortedObject) {
var text = "Key: " + key + ", Value: " + sortedObject[key];
var paragraph = document.createElement('p');
paragraph.textContent = text;
document.body.appendChild(paragraph);
}Remarque:Object.keys est une méthode ECMAScript 5.1, mais voici un polyfill pour les navigateurs plus anciens:
if (!Object.keys) {
Object.keys = function (object) {
var key = [];
var property = undefined;
for (property in object) {
if (Object.prototype.hasOwnProperty.call(object, property)) {
key.Push(property);
}
}
return key;
};
}
J'ai transféré des énumérations Java vers des objets javascript.
Ces objets m'ont renvoyé des tableaux corrects. si les clés d’objet sont de type mixte (string, int, char), il y a un problème.
var Helper = {
isEmpty: function (obj) {
return !obj || obj === null || obj === undefined || Array.isArray(obj) && obj.length === 0;
},
isObject: function (obj) {
return (typeof obj === 'object');
},
sortObjectKeys: function (object) {
return Object.keys(object)
.sort(function (a, b) {
c = a - b;
return c
});
},
containsItem: function (arr, item) {
if (arr && Array.isArray(arr)) {
return arr.indexOf(item) > -1;
} else {
return arr === item;
}
},
pushArray: function (arr1, arr2) {
if (arr1 && arr2 && Array.isArray(arr1)) {
arr1.Push.apply(arr1, Array.isArray(arr2) ? arr2 : [arr2]);
}
}
};
function TypeHelper() {
var _types = arguments[0],
_defTypeIndex = 0,
_currentType,
_value;
if (arguments.length == 2) {
_defTypeIndex = arguments[1];
}
Object.defineProperties(this, {
Key: {
get: function () {
return _currentType;
},
set: function (val) {
_currentType.setType(val, true);
},
enumerable: true
},
Value: {
get: function () {
return _types[_currentType];
},
set: function (val) {
_value.setType(val, false);
},
enumerable: true
}
});
this.getAsList = function (keys) {
var list = [];
Helper.sortObjectKeys(_types).forEach(function (key, idx, array) {
if (key && _types[key]) {
if (!Helper.isEmpty(keys) && Helper.containsItem(keys, key) || Helper.isEmpty(keys)) {
var json = {};
json.Key = key;
json.Value = _types[key];
Helper.pushArray(list, json);
}
}
});
return list;
};
this.setType = function (value, isKey) {
if (!Helper.isEmpty(value)) {
Object.keys(_types).forEach(function (key, idx, array) {
if (Helper.isObject(value)) {
if (value && value.Key == key) {
_currentType = key;
}
} else if (isKey) {
if (value && value.toString() == key.toString()) {
_currentType = key;
}
} else if (value && value.toString() == _types[key]) {
_currentType = key;
}
});
} else {
this.setDefaultType();
}
return isKey ? _types[_currentType] : _currentType;
};
this.setTypeByIndex = function (index) {
var keys = Helper.sortObjectKeys(_types);
for (var i = 0; i < keys.length; i++) {
if (index === i) {
_currentType = keys[index];
break;
}
}
};
this.setDefaultType = function () {
this.setTypeByIndex(_defTypeIndex);
};
this.setDefaultType();
}
var TypeA = {
"-1": "Any",
"2": "2L",
"100": "100L",
"200": "200L",
"1000": "1000L"
};
var TypeB = {
"U": "Any",
"W": "1L",
"V": "2L",
"A": "100L",
"Z": "200L",
"K": "1000L"
};
console.log('keys of TypeA', Helper.sortObjectKeys(TypeA));//keys of TypeA ["-1", "2", "100", "200", "1000"]
console.log('keys of TypeB', Helper.sortObjectKeys(TypeB));//keys of TypeB ["U", "W", "V", "A", "Z", "K"]
var objectTypeA = new TypeHelper(TypeA),
objectTypeB = new TypeHelper(TypeB);
console.log('list of objectA = ', objectTypeA.getAsList());
console.log('list of objectB = ', objectTypeB.getAsList());Types:
var TypeA = {
"-1": "Any",
"2": "2L",
"100": "100L",
"200": "200L",
"1000": "1000L"
};
var TypeB = {
"U": "Any",
"W": "1L",
"V": "2L",
"A": "100L",
"Z": "200L",
"K": "1000L"
};
Sorted Keys(output):
Key list of TypeA -> ["-1", "2", "100", "200", "1000"]
Key list of TypeB -> ["U", "W", "V", "A", "Z", "K"]
Trie les clés de manière récursive tout en préservant les références.
function sortKeys(o){
if(o && o.constructor === Array)
o.forEach(i=>sortKeys(i));
else if(o && o.constructor === Object)
Object.entries(o).sort((a,b)=>a[0]>b[0]?1:-1).forEach(e=>{
sortKeys(e[1]);
delete o[e[0]];
o[e[0]] = e[1];
});
}
Exemple:
let x = {d:3, c:{g:20, a:[3,2,{s:200, a:100}]}, a:1};
let y = x.c;
let z = x.c.a[2];
sortKeys(x);
console.log(x); // {a: 1, c: {a: [3, 2, {a: 1, s: 2}], g: 2}, d: 3}
console.log(y); // {a: [3, 2, {a: 100, s: 200}}, g: 20}
console.log(z); // {a: 100, s: 200}
Extrait simple et lisible, utilisant lodash.
Vous devez mettre la clé entre guillemets uniquement lorsque vous appelez sortBy. Il n'est pas nécessaire que les données soient entre guillemets.
_.sortBy(myObj, "key")
En outre, votre deuxième paramètre à mapper est incorrect. Cela devrait être une fonction, mais utiliser le plumage est plus facile.
_.map( _.sortBy(myObj, "key") , "value");
Utilisez ce code si vous avez des objets imbriqués ou si vous avez un tableau imbriqué obj.
var sortObjectByKey = function(obj){
var keys = [];
var sorted_obj = {};
for(var key in obj){
if(obj.hasOwnProperty(key)){
keys.Push(key);
}
}
// sort keys
keys.sort();
// create new array based on Sorted Keys
jQuery.each(keys, function(i, key){
var val = obj[key];
if(val instanceof Array){
//do for loop;
var arr = [];
jQuery.each(val,function(){
arr.Push(sortObjectByKey(this));
});
val = arr;
}else if(val instanceof Object){
val = sortObjectByKey(val)
}
sorted_obj[key] = val;
});
return sorted_obj;
};
@Sindresorhus a mis au point un excellent projet appelé sort-keys qui fonctionne à merveille.
Vous pouvez vérifier son code source ici:
https://github.com/sindresorhus/sort-keys
Ou vous pouvez l'utiliser avec npm:
$ npm install --save sort-keys
Voici aussi des exemples de code de son readme
const sortKeys = require('sort-keys');
sortKeys({c: 0, a: 0, b: 0});
//=> {a: 0, b: 0, c: 0}
sortKeys({b: {b: 0, a: 0}, a: 0}, {deep: true});
//=> {a: 0, b: {a: 0, b: 0}}
sortKeys({c: 0, a: 0, b: 0}, {
compare: (a, b) => -a.localeCompare(b)
});
//=> {c: 0, b: 0, a: 0}
Juste pour simplifier et clarifier la réponse de Matt Ball
//your object
var myObj = {
b : 'asdsadfd',
c : 'masdasaf',
a : 'dsfdsfsdf'
};
//fixed code
var keys = [];
for (var k in myObj) {
if (myObj.hasOwnProperty(k)) {
keys.Push(k);
}
}
keys.sort();
for (var i = 0; i < keys.length; i++) {
k = keys[i];
alert(k + ':' + myObj[k]);
}Réponse JavaScript pure pour trier un objet. C’est la seule réponse que je connaisse qui traitera les nombres négatifs. Cette fonction permet de trier des objets numériques.
Contribution obj = {1000: {}, -1200: {}, 10000: {}, 200: {}};
function osort(obj) {
var keys = Object.keys(obj);
var len = keys.length;
var rObj = [];
var rK = [];
var t = Object.keys(obj).length;
while(t > rK.length) {
var l = null;
for(var x in keys) {
if(l && parseInt(keys[x]) < parseInt(l)) {
l = keys[x];
k = x;
}
if(!l) { // Find Lowest
var l = keys[x];
var k = x;
}
}
delete keys[k];
rK.Push(l);
}
for (var i = 0; i < len; i++) {
k = rK[i];
rObj.Push(obj[k]);
}
return rObj;
}
La sortie sera un objet trié par ces nombres avec de nouvelles clés commençant à 0.
Object.keys(unordered).sort().reduce(
(acc,curr) => ({...acc, [curr]:unordered[curr]})
, {}
)
Je ne sais pas si cela répond à la question, mais c'est ce dont j'avais besoin.
Maps.iterate.sorted = function (o, callback) {
var keys = Object.keys(o), sorted = keys.sort(), k;
if ( callback ) {
var i = -1;
while( ++i < sorted.length ) {
callback(k = sorted[i], o[k] );
}
}
return sorted;
}
Appelé comme:
Maps.iterate.sorted({c:1, b:2, a:100}, function(k, v) { ... } )
La seule ligne:
Object.entries(unordered)
.sort(([keyA], [keyB]) => keyA > keyB)
.reduce((obj, [key,value]) => Object.assign(obj, {[key]: value}), {})