Trier l'objet JavaScript par clé

J'ai besoin de trier les objets JavaScript par clé.

D'où ce qui suit:

{ 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' }

Deviendrait:

{ 'a' : 'dsfdsfsdf', 'b' : 'asdsad', 'c' : 'masdas' }

Les autres réponses à cette question sont dépassées, n'ont jamais correspondu à la réalité de la mise en œuvre et sont officiellement devenues incorrectes maintenant que la spécification ES6 / ES2015 a été publiée.

Voir la section sur l' ordre d'itération des propriétés dans Exploration ES6 par Axel Rauschmayer :

Toutes les méthodes qui itèrent sur les clés de propriété le font dans le même ordre:

1. Tout d'abord tous les indices Array, triés numériquement.
2. Ensuite, toutes les clés de chaîne (qui ne sont pas des index), dans l'ordre dans lequel elles ont été créées.
3. Ensuite, tous les symboles, dans l'ordre dans lequel ils ont été créés.

Alors oui, les objets JavaScript sont en fait ordonnés et l'ordre de leurs clés / propriétés peut être modifié.

Voici comment trier un objet par ses clés / propriétés, par ordre alphabétique:

const unordered = {
  'b': 'foo',
  'c': 'bar',
  'a': 'baz'
};

console.log(JSON.stringify(unordered));
// → '{"b":"foo","c":"bar","a":"baz"}'

const ordered = {};
Object.keys(unordered).sort().forEach(function(key) {
  ordered[key] = unordered[key];
});

console.log(JSON.stringify(ordered));
// → '{"a":"baz","b":"foo","c":"bar"}'

Utilisez varau lieu de constpour la compatibilité avec les moteurs ES5.

Les objets JavaScript ¹ ne sont pas commandés. Cela n'a aucun sens d'essayer de les "trier". 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]);
}

Object.keysMise en œuvre alternative utilisant la 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]);
}

^{1 Ne pas être pédant, mais un objet JSON n'existe pas .}

Beaucoup de gens ont mentionné que "les objets ne peuvent pas être triés" , mais après cela, ils vous donnent une solution qui fonctionne. Paradoxe, n'est-ce pas?

Personne ne mentionne 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 triée de clés, cela renvoie un résultat attendu.

Et je pense que nous pourrions ajouter une autre solution - 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 ci-dessus (formatée en "one-liner"):

const sortObject = o => 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.keysnous donne une liste de clés dans l'objet fourni ( objou o), puis nous trions celles qui utilisent l'algorithme de tri par défaut, la prochaine .reduceest utilisée pour reconvertir ce tableau en objet, mais cette fois avec toutes les clés triées.

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.
  ,{}
);

• Documents pour réduire: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce
• Pourquoi utiliser des parenthèses sur les déclarations 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 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.

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys

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.

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort

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

Ç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;
};

Nous sommes en 2019 et nous avons un moyen de résoudre ce problème en 2019 :)

Object.fromEntries(Object.entries({b: 3, a:8, c:1}).sort())

voici le 1 liner

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), {} ));

C'est une vieille question, mais en s'inspirant de la réponse de Mathias Bynens, j'ai fait une version courte pour trier l' objet actuel , sans trop de surcharge.

    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 verra les clés triées alphabétiquement.

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 qu'il puisse être utile dans le débogueur VisualStudio qui affiche 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})

Version de soulignement :

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

function sortObjectKeys(obj){
    return Object.keys(obj).sort().reduce((acc,key)=>{
        acc[key]=obj[key];
        return acc;
    },{});
}

sortObjectKeys({
    telephone: '069911234124',
    name: 'Lola',
    access: true,
});

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

PS et même 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;
  }, {});
};

tri récursif, pour les objets imbriqués et les tableaux

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

Comme déjà mentionné, les objets ne sont pas classé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 le kv et faire ce que vous voulez.

> kv.sort()
[ [ 'a', 'dsfdsfsdf' ],
  [ 'b', 'asdsad' ],
  [ 'c', 'masdas' ] ]

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 toObject()méthode ...

Utilisez simplement lodash pour décompresser la carte et trier par la première valeur de pair et zip à nouveau, il renverra la clé triée.

Si vous voulez que l'index de paire de valeurs triées soit à 1 au lieu de 0

var o = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' };
console.log(_(o).toPairs().sortBy(0).fromPairs().value())

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}

Object.keys(unordered).sort().reduce(
    (acc,curr) => ({...acc, [curr]:unordered[curr]})
    , {}
)

Il s'agit d'une solution légère à tout ce dont j'ai besoin pour le tri JSON.

function sortObj(obj) {
    if (typeof obj !== "object" || obj === null)
        return obj;

    if (Array.isArray(obj))
        return obj.map((e) => sortObj(e)).sort();

    return Object.keys(obj).sort().reduce((sorted, k) => {
        sorted[k] = sortObj(obj[k]);
        return sorted;
    }, {});
}

Utilisez ce code si vous avez des objets imbriqués ou si vous avez un obj de tableau imbriqué.

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

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 nombreux runtimes JavaScript stockent les valeurs à l'intérieur d'un objet dans l'ordre dans lequel elles sont ajoutées.

Pour trier les propriétés d'un objet par leurs clés, vous pouvez utiliser la fonction Object.keys qui renverra un tableau de clés. Le tableau de clés peut ensuite être trié par la méthode Array.prototype.sort () qui trie les éléments d'un tableau en place (pas besoin 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é).

Voici un exemple de la procédure (vous pouvez la tester dans vos 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é quelques énumérations Java vers des objets javascript.

Ces objets m'ont retourné 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"]

Extrait simple et lisible, utilisant lodash.

Vous devez mettre la clé entre guillemets uniquement lorsque vous appelez sortBy. Il n'est pas nécessaire qu'il soit entre guillemets dans les données elles-mêmes.

_.sortBy(myObj, "key")

De plus, votre deuxième paramètre à mapper est incorrect. Cela devrait être une fonction, mais l'utilisation de la plumaison est plus facile.

_.map( _.sortBy(myObj, "key") , "value");

Il y a un grand projet de @sindresorhus appelé sort-keys qui fonctionne très bien.

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 également des exemples de code de son fichier Lisezmoi

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}

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.

Input 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.

Juste pour simplifier et rendre plus claire 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]);
}

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}), {})

la meilleure façon de le faire est

 const object =  Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {})

 //else if its in reverse just do 

 const object = Object.keys(0).reverse ()

Vous pouvez d'abord convertir votre objet quasi-tableau en un vrai tableau, puis utiliser .reverse ():

Object.assign([], {1:'banana', 2:'apple', 
3:'orange'}).reverse();
// [ "orange", "apple", "banana", <1 empty slot> ]

L'emplacement vide à la fin est dû au fait que votre premier index est 1 au lieu de 0. Vous pouvez supprimer l'emplacement vide avec .length-- ou .pop ().

Alternativement, si vous souhaitez emprunter .reverse et l'appeler sur le même objet, il doit s'agir d'un objet de type tableau complet. Autrement dit, il a besoin d'une propriété de longueur:

Array.prototype.reverse.call({1:'banana', 2:'apple', 
3:'orange', length:4});
// {0:"orange", 1:"apple", 3:"banana", length:4}

Notez qu'il renverra le même objet objet de type tableau complet, donc ce ne sera pas un vrai tableau. Vous pouvez ensuite utiliser delete pour supprimer la propriété length.