it-swarm.com.de

JavaScript-Objekt nach Schlüssel sortieren

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' }
372
vdh_ant

Die anderen Antworten auf diese Frage sind veraltet, entsprechen nicht der Realität der Implementierung und sind offiziell falsch geworden, seit die ES6/ES2015-Spezifikation veröffentlicht wurde.


Siehe den Abschnitt über Eigenschaftsiterationsreihenfolge in Exploring ES6 von Axel Rauschmayer :

Alle Methoden, die Eigenschaftsschlüssel durchlaufen, werden in derselben Reihenfolge ausgeführt:

  1. Zuerst alle Array-Indizes, numerisch sortiert.
  2. Dann alle String-Schlüssel (dh keine Indizes) in der Reihenfolge, in der sie erstellt wurden.
  3. Dann alle Symbole in der Reihenfolge, in der sie erstellt wurden.

Ja, die 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 var anstelle von const, um die Kompatibilität mit ES5-Engines zu gewährleisten.

322
Mathias Bynens

JavaScript-Objekte1 sind nicht bestellt. 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 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.keys fancy:

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


1Nicht um Pedantik zu sein, aber es gibt kein JSON-Objekt .

230
Matt Ball

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

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

Und ich denke, dass wir eine weitere Lösung hinzufügen könnten - 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"):

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

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

Object.keys gibt uns eine Liste von Schlüsseln im bereitgestellten Objekt (obj oder o), dann sortieren wir diese mit dem Standardsortieralgorithmus. Als nächstes wird .reduce verwendet, um dieses Array wieder in ein Objekt zu konvertieren, diesmal jedoch mit allen Schlüsseln .

136
codename-

Das funktioniert für mich

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

Jungs, ich bin im übertragenen Sinne geschockt! Sicher, alle Antworten sind etwas alt, aber niemand hat die Stabilität beim Sortieren erwähnt! Ich werde mein Bestes geben, um die Frage selbst zu beantworten und hier auf Details einzugehen. Ich werde 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 Object.keys() zusammen mit Array.prototype.reduce() verwenden, um das sortierte Objekt zurückzugeben:

// 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 Strings arbeiten, empfehle ich dringend, Array.prototype.sort() in all das einzubinden:

// 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 reduziert ist:

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

Wenn nötig, ist hier die Erklärung für den One 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.
  ,{}
);

Warum das Sortieren etwas kompliziert ist:

Kurz gesagt, Object.keys() wird ein Array mit derselben Reihenfolge zurückgeben, wie wir es 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 entsprechend den aufzählbaren Eigenschaften, die direkt auf dem Objekt gefunden wurden . Die Reihenfolge der Eigenschaften ist die gleiche wie in der Schleife über die Eigenschaften des Objekts manuell.

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

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

Diese Beispiele zeigen jedoch nicht so einfach, dass Objekte der realen Welt Zahlen, alphabetische Zeichen oder sogar Symbole enthalten können (dies 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() für das Array oberhalb der Ausgabe verwenden, ändert sich Folgendes:

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 .__ zurück. das Array Die Sortierung ist nicht unbedingt stabil. Die Standardsortierreihenfolge entspricht den String-Unicode-Codepunkten.

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

Sie müssen sicherstellen, dass einer von ihnen die gewünschte Ausgabe für Sie liefert. In realen Beispielen neigen die Menschen dazu, Dinge besonders zu verwechseln, wenn Sie verschiedene Informationseingaben wie APIs und Datenbanken zusammen verwenden.


Was ist also 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. Es ist jedoch ein wenig zusätzlicher Speicherplatz für Hilfsvariablen zulässig. Die Eingabe wird normalerweise von der Ausgabe überschrieben, wenn der Algorithmus ausgeführt wird. Der In-Place-Algorithmus aktualisiert die Eingabefolge nur durch Ersetzen oder Austauschen von Elementen. Ein Algorithmus, der nicht in-place ist, wird manchmal als nicht in-place oder out-of-place bezeichnet. 

Im Grunde 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 wie Sie erscheinen in der Eingabe. Beim Sortieren einiger Datenarten ist nur der Teil der Daten wird beim Bestimmen der Sortierreihenfolge geprüft. Zum Beispiel, Im Beispiel für die Kartensortierung rechts werden die Karten sortiert von ihrem Rang, und ihre Klage wird ignoriert. Dies ermöglicht die Möglichkeit, mehrere verschiedene korrekt sortierte Versionen von ursprüngliche Liste. Stabile Sortieralgorithmen wählen eine davon aus gemäß der folgenden Regel: Wenn zwei Elemente gleich sind, z. B. die beiden 5 Karten, dann bleibt ihre relative Reihenfolge erhalten, so dass wenn einer in der Eingabe vor dem anderen kam, wird es auch vor .__ kommen. der andere in der Ausgabe.

 enter image description here

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

Dies zeigt, dass die Sortierung richtig ist, sich aber geändert hat. In der realen Welt müssen wir, selbst wenn die Sortierung stimmt, sicherstellen, dass wir das bekommen, was wir erwarten! Das ist super wichtig, bedenke dies auch. Weitere JavaScript-Beispiele finden Sie in Array.prototype.sort () - docs: https://developer.mozilla.org/de-de/docs/Web/JavaScript/Reference/Global_Objects/Array/sort

24
Megajin

Dies ist eine alte Frage, aber unter Berücksichtigung der Antwort von Mathias Bynens habe ich eine kurze Version gemacht, um das Objekt current ohne viel 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 des "ungeordneten" Objekts selbst alphabetisch sortiert.

18
Sergio Moura

Mit lodash funktioniert das:

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 zum Nachdenken.

16
Brian M. Hunt

Angenommen, es könnte in 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})
13
Serg

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

13

Unterstreichungsversion :

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

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

_.sortBy(_.pairs(c),function(o){return o[0]})
8
Flavien Volken

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

P.S. und dasselbe mit ES6 + -Syntax:

function ksort( src ) {
  const keys = Object.keys( src );
  keys.sort();
  return keys.reduce(( target, key ) => {
        target[ key ] = src[ key ];
        return target;
  }, {});
};
8
Dmitry Sheiko
function sortObjectKeys(obj){
    return Object.keys(obj).sort().reduce((acc,key)=>{
        acc[key]=obj[key];
        return acc;
    },{});
}

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

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

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

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

Wie bereits erwähnt, sind Objekte ungeordnet.

Jedoch...

Diese Redewendung kann nützlich sein:

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 möchten.

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

Verwenden Sie einfach lodash, um die Karte zu entpacken und sortBy durch den ersten Wert von pair und Zip erneut zu sortieren.

Wenn Sie möchten, dass der Sortierwert den Paarindex auf 1 anstelle von 0 ändert.

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

 enter image description here

Hier ist eine saubere lodash-basierte Version, 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 ...

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

Erklärung:

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 Schlüsselarray kann dann nach der Methode Array.prototype.sort () sortiert werden, die die Elemente eines Arrays an Ort und Stelle sortiert (keine Notwendigkeit, sie einer neuen Variablen zuzuordnen).

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

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

Anmerkung:Object.keys ist eine ECMAScript 5.1-Methode, aber hier ist eine Füllfunktion 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;
  };
}
2

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

Diese Objekte lieferten korrekte Arrays für mich. Wenn Objektschlüssel vom gemischten Typ sind (string, int, char), 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"]
2

Sortiert Schlüssel rekursiv, während Referenzen beibehalten werden.

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}
2
brunettdan

Einfacher und lesbarer Ausschnitt 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")

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

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

Verwenden Sie diesen Code, wenn Sie verschachtelte Objekte oder verschachtelte Array-Objekte 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;
};
2
Phani Reddy

Es gibt ein großartiges Projekt von @sindresorhus namens sort-keys, das großartig 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 finden Sie auch Codebeispiele aus seiner Readme-Datei

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}
2
fernandopasik

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

Reine JavaScript-Antwort zum Sortieren eines Objekts. Dies ist die einzige Antwort, von der ich weiß, dass sie mit negativen Zahlen umgehen kann. Diese Funktion dient zum Sortieren von numerischen Objekten. 

Eingang 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 Nummern sortiert ist, wobei die neuen Schlüssel bei 0 beginnen.

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

Ich bin nicht sicher, ob dies die Frage beantwortet, aber ich brauchte es. 

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) { ... } ) 
0
momomo

Die eine Zeile:

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