Sortieren Sie das JavaScript-Objekt nach Schlüssel

Ich muss JavaScript-Objekte nach Schlüssel sortieren.

Daher folgendes:

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

Würde werden:

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

Die anderen Antworten auf diese Frage sind veraltet, entsprechen nie der Implementierungsrealität und sind nach Veröffentlichung der ES6 / ES2015-Spezifikation offiziell falsch geworden.

Weitere Informationen finden Sie im Abschnitt zur Reihenfolge der Eigenschaftsiteration in Exploring ES6 von Axel Rauschmayer :

Alle Methoden, die über Eigenschaftsschlüssel iterieren, tun dies in derselben Reihenfolge:

1. Zunächst alle Array-Indizes, numerisch sortiert.
2. Dann alle Zeichenfolgenschlüssel (die keine Indizes sind) in der Reihenfolge, in der sie erstellt wurden.
3. Dann alle Symbole in der Reihenfolge, in der sie erstellt wurden.

Ja, JavaScript-Objekte sind tatsächlich geordnet, und die Reihenfolge ihrer Schlüssel / Eigenschaften kann geändert werden.

So können Sie ein Objekt alphabetisch nach seinen Schlüsseln / Eigenschaften sortieren:

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"}'

Verwenden Sie varstatt constfür die Kompatibilität mit ES5-Motoren.

JavaScript-Objekte ¹ sind nicht geordnet. Es ist sinnlos zu versuchen, sie zu "sortieren". Wenn Sie die Eigenschaften eines Objekts durchlaufen möchten, können Sie die Schlüssel sortieren und dann die zugehörigen Werte abrufen:

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

Alternative Implementierung mit Object.keysPhantasie:

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 Um nicht pedantisch zu sein, aber es gibt kein JSON-Objekt .}

Viele Leute haben erwähnt, dass "Objekte nicht sortiert werden können" , aber danach geben sie Ihnen eine Lösung, die funktioniert. Paradox, nicht wahr?

Niemand erwähnt, warum diese Lösungen funktionieren. Dies ist der Fall, da in den meisten Implementierungen des Browsers Werte in Objekten in der Reihenfolge gespeichert werden, in der sie hinzugefügt wurden. Wenn Sie ein neues Objekt aus einer sortierten Liste von Schlüsseln erstellen, wird daher ein erwartetes Ergebnis zurückgegeben.

Und ich denke, wir könnten noch eine Lösung hinzufügen - ES5-Funktionsweise:

function sortObject(obj) {
    return Object.keys(obj).sort().reduce(function (result, key) {
        result[key] = obj[key];
        return result;
    }, {});
}

ES2015-Version von oben (formatiert als "Einzeiler"):

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

Kurze Erklärung der obigen Beispiele (wie in den Kommentaren gefragt):

Object.keysgibt uns eine Liste der Schlüssel in dem bereitgestellten Objekt ( objoder o), dann sortieren wir diese mit dem Standardsortieralgorithmus. Als nächstes .reducewird dieses Array wieder in ein Objekt konvertiert, diesmal jedoch mit allen Schlüsseln sortiert.

Leute, ich bin im übertragenen Sinne schockiert! Sicher, alle Antworten sind etwas alt, aber niemand hat die Stabilität beim Sortieren erwähnt! Nehmen Sie also mein Bestes, um die Frage selbst zu beantworten und hier auf Details einzugehen. Also werde ich mich jetzt entschuldigen, es wird viel zu lesen sein.

Da es 2018 ist, werde ich nur ES6 verwenden. Die Polyfills sind alle in den MDN-Dokumenten verfügbar, die ich im angegebenen Teil verlinken werde.

Antwort auf die Frage:

Wenn Ihre Schlüssel nur Zahlen sind, können Sie das sortierte Objekt sicher Object.keys()zusammen mit Array.prototype.reduce()zurückgeben:

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

Wenn Sie jedoch mit Zeichenfolgen arbeiten, empfehle ich dringend, Array.prototype.sort()all dies zu verketten :

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

Wenn sich jemand fragt, was Reduzieren bewirkt:

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

Bei Bedarf finden Sie hier die Erklärung für den einen Liner:

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

• Zu reduzierende Dokumente : https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce
• Warum Klammern für JavaScript-Rückgabeanweisungen verwenden: http://jamesknelson.com/javascript-return-parenthesis/

Warum das Sortieren etwas kompliziert ist:

Kurz gesagt, Object.keys()wird ein Array mit der gleichen Reihenfolge zurückgegeben, die wir mit einer normalen Schleife erhalten:

const object1 = {
  a: 'somestring',
  b: 42,
  c: false
};

console.log(Object.keys(object1));
// expected output: Array ["a", "b", "c"]

Object.keys () gibt ein Array zurück, dessen Elemente Zeichenfolgen sind, die den aufzählbaren Eigenschaften entsprechen, die direkt auf dem Objekt gefunden werden. Die Reihenfolge der Eigenschaften entspricht der Reihenfolge, in der die Eigenschaften des Objekts manuell durchlaufen werden.

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

Nebenbemerkung - Sie können sie auch Object.keys()für Arrays verwenden. Beachten Sie jedoch , dass der Index zurückgegeben wird:

// simple array
const arr = ['a', 'b', 'c'];
console.log(Object.keys(arr)); // console: ['0', '1', '2']

Es ist jedoch nicht so einfach wie in diesen Beispielen gezeigt. Objekte der realen Welt können Zahlen und alphabetische Zeichen oder sogar Symbole enthalten (bitte nicht tun).

Hier ist ein Beispiel mit allen in einem Objekt:

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

Wenn wir nun Array.prototype.sort()das Array oben verwenden, ändert sich die Ausgabe:

console.log(Object.keys(testObj).sort());
// output: [ '#01010101010', '1000', '1asc', '2', 'b' ]

Hier ist ein Zitat aus den Dokumenten:

Die sort () -Methode sortiert die Elemente eines Arrays an Ort und Stelle und gibt das Array zurück. Die Sortierung ist nicht unbedingt stabil. Die Standardsortierreihenfolge entspricht den Zeichenfolgen-Unicode-Codepunkten.

Die zeitliche und räumliche Komplexität der Sortierung kann nicht garantiert werden, da sie implementierungsabhängig ist.

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

Sie müssen sicherstellen, dass einer von ihnen die gewünschte Ausgabe für Sie zurückgibt. In Beispielen aus der Praxis neigen Menschen dazu, Dinge zu verwechseln, insbesondere wenn Sie verschiedene Informationseingaben wie APIs und Datenbanken zusammen verwenden.

Also, was ist die große Sache?

Nun, es gibt zwei Artikel, die jeder Programmierer verstehen sollte:

In-Place-Algorithmus :

In der Informatik ist ein In-Place-Algorithmus ein Algorithmus, der Eingaben ohne Hilfsdatenstruktur transformiert. Für Hilfsvariablen ist jedoch ein geringer zusätzlicher Speicherplatz zulässig. Die Eingabe wird normalerweise von der Ausgabe überschrieben, wenn der Algorithmus ausgeführt wird. Der In-Place-Algorithmus aktualisiert die Eingabesequenz nur durch Ersetzen oder Austauschen von Elementen. Ein Algorithmus, der nicht vorhanden ist, wird manchmal als nicht vorhanden oder nicht vorhanden bezeichnet.

Im Grunde genommen wird unser altes Array überschrieben! Dies ist wichtig, wenn Sie das alte Array aus anderen Gründen beibehalten möchten. Denken Sie also daran.

Sortieralgorithmus

Stabile Sortieralgorithmen sortieren identische Elemente in derselben Reihenfolge, in der sie in der Eingabe erscheinen. Beim Sortieren einiger Arten von Daten wird bei der Bestimmung der Sortierreihenfolge nur ein Teil der Daten untersucht. Im Beispiel für die Kartensortierung rechts werden die Karten beispielsweise nach ihrem Rang sortiert und ihre Farbe wird ignoriert. Dies ermöglicht die Möglichkeit mehrerer verschiedener korrekt sortierter Versionen der ursprünglichen Liste. Stabile Sortieralgorithmen wählen eine davon gemäß der folgenden Regel aus: Wenn zwei Elemente wie die beiden 5 Karten als gleich verglichen werden, bleibt ihre relative Reihenfolge erhalten, sodass dies auch der Fall ist, wenn eines in der Eingabe vor dem anderen kam kommen vor dem anderen in der Ausgabe.

Ein Beispiel für eine stabile Sortierung auf Spielkarten. Wenn die Karten nach Rang mit einer stabilen Sortierung sortiert sind, müssen die beiden 5er in der sortierten Ausgabe, in der sie sich ursprünglich befanden, in derselben Reihenfolge bleiben. Wenn sie mit einer nicht stabilen Sortierung sortiert werden, können die 5er in der entgegengesetzten Richtung enden Reihenfolge in der sortierten Ausgabe.

Dies zeigt, dass die Sortierung richtig ist, sich aber geändert hat. Selbst wenn die Sortierung korrekt ist, müssen wir in der realen Welt sicherstellen, dass wir das bekommen, was wir erwarten! Dies ist sehr wichtig. Denken Sie auch daran. Weitere JavaScript-Beispiele finden Sie in den Dokumenten Array.prototype.sort () - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort

Das funktioniert bei mir

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

Es ist 2019 und wir haben 2019 einen Weg, dies zu lösen :)

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

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

Dies ist eine alte Frage, aber unter Berücksichtigung der Antwort von Mathias Bynens habe ich eine Kurzversion erstellt, um das aktuelle Objekt ohne großen Aufwand zu sortieren .

    Object.keys(unordered).sort().forEach(function(key) {
        var value = unordered[key];
        delete unordered[key];
        unordered[key] = value;
    });

Nach der Codeausführung werden die Schlüssel für das "ungeordnete" Objekt selbst alphabetisch sortiert.

Mit lodash funktioniert dies:

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

Nur Denkanstöße.

Angenommen, es könnte im VisualStudio-Debugger nützlich sein, der ungeordnete Objekteigenschaften anzeigt.

(function(s){var t={};Object.keys(s).sort().forEach(function(k){t[k]=s[k]});return t})({b:2,a:1,c:3})

Unterstreichungsversion :

function order(unordered)
{
return _.object(_.sortBy(_.pairs(unordered),function(o){return o[0]}));
}

Wenn Sie Ihrem Browser nicht vertrauen, dass er die Reihenfolge der Schlüssel beibehält, empfehle ich dringend, sich auf ein geordnetes Array von Schlüssel-Wert-gepaarten Arrays zu verlassen.

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

Vielleicht etwas elegantere Form:

 /**
     * 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 und das gleiche mit ES6 + -Syntax:

function ksort( src ) {
  const keys = Object.keys( src );
  keys.sort();
  return keys.reduce(( target, key ) => {
        target[ key ] = src[ key ];
        return target;
  }, {});
};

rekursive Sortierung für verschachtelte Objekte und Arrays

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

Wie bereits erwähnt, sind Objekte ungeordnet.

Jedoch...

Sie können diese Redewendung nützlich finden:

var o = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' };

var kv = [];

for (var k in o) {
  kv.push([k, o[k]]);
}

kv.sort()

Sie können dann durch kv iterieren und tun, was Sie wollen.

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

Hier ist eine saubere Version auf Lodash-Basis, die mit verschachtelten Objekten funktioniert

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

Es wäre noch sauberer, wenn lodash eine toObject()Methode hätte ...

Verwenden Sie einfach lodash, um die Karte zu entpacken und sortBy den ersten Wert von pair und zip erneut, um den sortierten Schlüssel zurückzugeben.

Wenn Sie einen Sortierwert wünschen, ändern Sie den Paarindex auf 1 anstelle von 0

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

Sortiert Schlüssel rekursiv unter Beibehaltung von Referenzen.

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

Beispiel:

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

Dies ist eine einfache Lösung für alles, was ich für die JSON-Sortierung benötige.

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

Verwenden Sie diesen Code, wenn Sie verschachtelte Objekte oder ein verschachteltes Array obj haben.

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

Lösung:

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

Erläuterung:

Viele JavaScript-Laufzeiten speichern Werte in einem Objekt in der Reihenfolge, in der sie hinzugefügt werden.

Um die Eigenschaften eines Objekts nach ihren Schlüsseln zu sortieren, können Sie die Funktion Object.keys verwenden, die ein Array von Schlüsseln zurückgibt . Das Array von Schlüsseln kann dann nach Array.prototype.sort () sortiert werden. Methode die Elemente eines Arrays an Ort und Stelle (ohne dass sie einer neuen Variablen zugewiesen werden müssen).

Sobald die Schlüssel sortiert sind, können Sie sie einzeln verwenden, um auf den Inhalt des alten Objekts zuzugreifen und ein neues Objekt zu füllen (das jetzt sortiert ist).

Unten finden Sie ein Beispiel für das Verfahren (Sie können es in Ihren Zielbrowsern testen):

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

Hinweis: Object.keys ist eine ECMAScript 5.1-Methode, aber hier ist eine Polyfüllung für ältere Browser:

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

Ich habe einige Java-Enums auf Javascript-Objekte übertragen.

Diese Objekte haben für mich die richtigen Arrays zurückgegeben. Wenn die Objektschlüssel vom gemischten Typ sind (Zeichenfolge, Int, Zeichen), liegt ein Problem vor.

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

Einfaches und lesbares Snippet mit lodash.

Sie müssen den Schlüssel nur in Anführungszeichen setzen, wenn Sie sortBy aufrufen. Es muss nicht in Anführungszeichen in den Daten selbst stehen.

_.sortBy(myObj, "key")

Außerdem ist Ihr zweiter zuzuordnender Parameter falsch. Es sollte eine Funktion sein, aber das Zupfen ist einfacher.

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

Es gibt ein großartiges Projekt von @sindresorhus namens Sort-Keys, das fantastisch funktioniert.

Sie können den Quellcode hier überprüfen:

https://github.com/sindresorhus/sort-keys

Oder Sie können es mit npm verwenden:

$ npm install --save sort-keys

Hier sind auch Codebeispiele aus seiner 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}

Reine JavaScript-Antwort zum Sortieren eines Objekts. Dies ist die einzige Antwort, von der ich weiß, dass sie mit negativen Zahlen umgeht. Diese Funktion dient zum Sortieren numerischer Objekte.

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

Die Ausgabe ist ein Objekt, das nach diesen Zahlen sortiert ist, wobei neue Schlüssel bei 0 beginnen.

Nur um es zu vereinfachen und die Antwort von Matt Ball klarer zu machen

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

Ich bin mir nicht sicher, ob dies die Frage beantwortet, aber das ist es, was ich brauchte.

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

Genannt als:

Maps.iterate.sorted({c:1, b:2, a:100}, function(k, v) { ... } ) 

Die eine Zeile:

Object.entries(unordered)
  .sort(([keyA], [keyB]) => keyA > keyB)
  .reduce((obj, [key,value]) => Object.assign(obj, {[key]: value}), {})

Der beste Weg, dies zu tun, ist

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

Sie können zuerst Ihr fast Array-ähnliches Objekt in ein reales Array konvertieren und dann .reverse () verwenden:

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

Der leere Slot am Ende, wenn Ursache, weil Ihr erster Index 1 statt 0 ist. Sie können den leeren Slot mit .length-- oder .pop () entfernen.

Wenn Sie alternativ .reverse ausleihen und für dasselbe Objekt aufrufen möchten, muss es sich um ein vollständig Array-ähnliches Objekt handeln. Das heißt, es benötigt eine Längeneigenschaft:

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

Beachten Sie, dass es dasselbe vollständig Array-ähnliche Objektobjekt zurückgibt, sodass es kein echtes Array ist. Anschließend können Sie mit delete die Eigenschaft length entfernen.