Les gars, je suis choqué au figuré! Bien sûr, toutes les réponses sont un peu anciennes, mais personne n'a même mentionné la stabilité du tri! Alors soyez indulgents, 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 maintenant, ce sera beaucoup à lire.
Comme c'est 2018, je n'utiliserai que ES6, les Polyfills sont tous disponibles sur la documentation MDN, que je lierai à la partie donnée.
Réponse à la question:
Si vos clés ne sont que des chiffres, vous pouvez les 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 recommande fortement d'enchaîner Array.prototype.sort()tout cela:
// 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 fait réduire:
// 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.
,{}
);
Pourquoi le tri est un peu compliqué:
En bref Object.keys()retournera un tableau avec le même ordre que celui que nous obtenons 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é en bouclant manuellement les propriétés de l'objet.
Sidenote - vous pouvez également l'utiliser Object.keys()sur des 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 ce n'est pas aussi facile que le montrent ces exemples, les objets du monde réel peuvent contenir des chiffres 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 ci-dessus, les modifications de sortie:
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 en place et retourne le tableau. Le tri n'est pas nécessairement stable. L'ordre de tri par défaut est en fonction des points de code Unicode de la chaîne.
La complexité temporelle et spatiale du tri ne peut pas être garantie car elle dépend de l'implémentation.
Vous devez vous assurer que l'un d'eux renvoie la sortie souhaitée pour vous. Dans des exemples réels, les gens ont tendance à mélanger les choses, surtout si vous utilisez ensemble différentes entrées d'informations telles que les API et les bases de données.
Alors, quel est le gros problème?
Eh bien, il y a deux articles que chaque programmeur doit comprendre:
Algorithme sur place :
En informatique, un algorithme sur place est un algorithme qui transforme l'entrée sans utiliser de 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 remplacée par la sortie lors de l'exécution de l'algorithme. L'algorithme sur place met à jour la séquence d'entrée uniquement par remplacement ou échange d'éléments. Un algorithme qui n'est pas en place est parfois appelé non en place ou hors place.
Donc, fondamentalement, notre ancien tableau sera écrasé! Ceci est important si vous souhaitez conserver l'ancien tableau pour d'autres raisons. Gardez cela à l'esprit.
Algorithme de tri
Les algorithmes de tri stables trient les éléments identiques dans le même ordre qu'ils apparaissent dans l'entrée. Lors du tri de certains types de données, seule une partie des données est examinée lors de la détermination de l'ordre de tri. Par exemple, dans l'exemple de tri des cartes à droite, les cartes sont triées selon leur rang et leur couleur est ignorée. Cela permet la possibilité de plusieurs versions différentes correctement triées de la liste d'origine. Les algorithmes de tri stables choisissent l'un d'eux, selon la règle suivante: si deux éléments se comparent comme égaux, comme les deux 5 cartes, alors leur ordre relatif sera préservé, de sorte que si l'un précède l'autre dans l'entrée, il sera également venir avant l'autre dans la sortie.
Un exemple de tri stable sur les cartes à jouer. Lorsque les cartes sont triées par rang avec un tri stable, les deux 5 doivent rester dans le même ordre dans la sortie triée dans laquelle ils étaient à l'origine. Lorsqu'elles sont triées avec un tri non stable, les 5 peuvent finir dans le sens opposé ordre dans la sortie triée.
Cela montre que le tri est correct mais qu'il 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, examinez Array.prototype.sort () - docs: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort
