Sortuj obiekt JavaScript według klucza

Muszę sortować obiekty JavaScript według klucza.

Stąd następujące:

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

Stanie się:

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

Inne odpowiedzi na to pytanie są nieaktualne, nigdy nie pasowały do ​​rzeczywistości implementacyjnej i oficjalnie stały się niepoprawne po opublikowaniu specyfikacji ES6 / ES2015.

Zobacz sekcję dotyczącą kolejności iteracji właściwości w Exploring ES6 autorstwa Axela Rauschmayera :

Wszystkie metody iterujące po kluczach właściwości robią to w tej samej kolejności:

1. Najpierw wszystkie indeksy macierzy, posortowane numerycznie.
2. Następnie wszystkie klucze łańcuchowe (które nie są indeksami), w kolejności, w jakiej zostały utworzone.
3. Następnie wszystkie symbole, w kolejności, w jakiej zostały utworzone.

Tak, tak, obiekty JavaScript są w rzeczywistości uporządkowane, a kolejność ich kluczy / właściwości można zmienić.

Oto, w jaki sposób możesz posortować obiekt według jego kluczy / właściwości, alfabetycznie:

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

Użyj varzamiast constdla kompatybilności z silnikami ES5.

Obiekty JavaScript ¹ nie są uporządkowane. Nie ma sensu „sortować” ich. Jeśli chcesz wykonać iterację właściwości obiektu, możesz posortować klucze, a następnie pobrać powiązane wartości:

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

Alternatywne wdrożenie z wykorzystaniem Object.keysfanciness:

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 Nie być pedantycznym, ale nie ma czegoś takiego jak obiekt JSON .}

Wiele osób wspomniało, że „obiektów nie można sortować” , ale potem dają ci rozwiązanie, które działa. Paradoks, prawda?

Nikt nie wspomina, dlaczego te rozwiązania działają. Są, ponieważ w większości implementacji przeglądarki wartości w obiektach są przechowywane w kolejności, w jakiej zostały dodane. Dlatego jeśli tworzysz nowy obiekt z posortowanej listy kluczy, zwraca oczekiwany wynik.

I myślę, że moglibyśmy dodać jeszcze jedno rozwiązanie - funkcjonalny sposób ES5:

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

Powyższa wersja ES2015 (sformatowana jako „one-liner”):

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

Krótkie wyjaśnienie powyższych przykładów (zgodnie z pytaniami w komentarzach):

Object.keysdaje nam listę kluczy w podanym obiekcie ( objlub o), następnie sortujemy je za pomocą domyślnego algorytmu sortowania, następnie .reducesłuży do konwersji tej tablicy z powrotem na obiekt, ale tym razem z posortowanymi wszystkimi kluczami.

Chłopaki jestem w szoku w przenośni! Oczywiście wszystkie odpowiedzi są nieco stare, ale nikt nawet nie wspomniał o stabilności sortowania! Więc proszę o cierpliwość, postaram się jak najlepiej odpowiedzieć na pytanie i przejść do szczegółów tutaj. Przepraszam, więc będzie dużo do przeczytania.

Ponieważ jest 2018, będę używać tylko ES6, wszystkie polifill są dostępne w dokumentach MDN, które podlinkuję w danej części.

Odpowiedz na pytanie:

Jeśli twoje klucze są tylko cyframi, możesz bezpiecznie użyć Object.keys()razem z, Array.prototype.reduce()aby zwrócić posortowany obiekt:

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

Jednak jeśli pracujesz z łańcuchami, bardzo polecam połączenie tego Array.prototype.sort()wszystkiego:

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

Jeśli ktoś zastanawia się, co robi redukcja:

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

W razie potrzeby znajduje się wyjaśnienie dla jednej wkładki:

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

• Dokumenty do zmniejszenia: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce
• Dlaczego warto używać nawiasów na zwrotnych instrukcjach JavaScript: http://jamesknelson.com/javascript-return-parenthesis/

Dlaczego sortowanie jest trochę skomplikowane:

W skrócie Object.keys()zwróci tablicę o takiej samej kolejności, jak w przypadku normalnej pętli:

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

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

Object.keys () zwraca tablicę, której elementy są łańcuchami odpowiadającymi wyliczalnym właściwościom znalezionym bezpośrednio na obiekcie. Kolejność właściwości jest taka sama, jak podana przez ręczne zapętlenie właściwości obiektu.

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

Sidenote - możesz używać również Object.keys()na tablicach, pamiętaj, że indeks zostanie zwrócony:

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

Ale nie jest to tak łatwe, jak pokazano w tych przykładach, obiekty świata rzeczywistego mogą zawierać liczby i znaki alfabetyczne, a nawet symbole (nie rób tego).

Oto przykład z nimi wszystkimi w jednym obiekcie:

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

Teraz, jeśli użyjemy Array.prototype.sort()tablicy powyżej zmiany danych wyjściowych:

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

Oto cytat z dokumentów:

Metoda sort () sortuje elementy tablicy na miejscu i zwraca tablicę. Sortowanie niekoniecznie jest stabilne. Domyślna kolejność sortowania jest zgodna z ciągami znaków kodu Unicode.

Nie można zagwarantować złożoności czasowej i przestrzennej tego rodzaju, ponieważ zależy ona od implementacji.

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

Musisz upewnić się, że jeden z nich zwróci dla Ciebie żądane wyjście. W rzeczywistych przykładach ludzie mają tendencję do pomieszania rzeczy, szczególnie jeśli używasz różnych danych wejściowych, takich jak interfejsy API i bazy danych.

Więc o co chodzi?

Cóż, są dwa artykuły, które każdy programista powinien zrozumieć:

Algorytm lokalny :

W informatyce algorytm lokalny jest algorytmem, który przekształca dane wejściowe bez żadnej struktury danych pomocniczych. Jednak niewielka ilość dodatkowej przestrzeni dyskowej jest dozwolona dla zmiennych pomocniczych. Dane wejściowe są zwykle nadpisywane przez dane wyjściowe podczas wykonywania algorytmu. Algorytm lokalny aktualizuje sekwencję wprowadzania tylko poprzez zamianę lub zamianę elementów. Algorytm, który nie jest na miejscu, jest czasem nazywany „nie na miejscu” lub „na miejscu”.

Więc w zasadzie nasza stara tablica zostanie nadpisana! Jest to ważne, jeśli chcesz zachować starą tablicę z innych powodów. Miej to na uwadze.

Algorytm sortowania

Stabilne algorytmy sortowania sortują identyczne elementy w tej samej kolejności, w jakiej pojawiają się na wejściu. Podczas sortowania niektórych rodzajów danych, tylko część danych jest sprawdzana podczas określania kolejności sortowania. Na przykład w przykładzie sortowania kart po prawej stronie, karty są sortowane według ich rangi, a ich kolor jest ignorowany. Pozwala to na wiele różnych poprawnie posortowanych wersji oryginalnej listy. Stabilne algorytmy sortowania wybierają jeden z nich, zgodnie z następującą zasadą: jeśli dwa elementy będą porównywane jako równe, podobnie jak dwie 5 kart, to ich względna kolejność zostanie zachowana, tak że jeśli jedna pojawi się przed drugą na wejściu, to również pojawiają się przed innymi w wyniku.

Przykład stabilnego sortowania na kartach do gry. Kiedy karty są sortowane według rangi przy użyciu stabilnego sortowania, dwie 5 muszą pozostać w tej samej kolejności na posortowanym wyjściu, w którym były pierwotnie. Kiedy są sortowane z niestabilnym sortowaniem, 5 mogą skończyć odwrotnie kolejność w posortowanym wyjściu.

To pokazuje, że sortowanie jest prawidłowe, ale się zmieniło. Tak więc w prawdziwym świecie, nawet jeśli sortowanie jest prawidłowe, musimy upewnić się, że otrzymamy to, czego oczekujemy! To bardzo ważne, należy o tym pamiętać. Więcej przykładów JavaScript można znaleźć w Array.prototype.sort () - docs: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort

To działa dla mnie

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

Jest rok 2019 i mamy sposób na rozwiązanie tego w 2019 roku :)

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

tutaj jest 1 wkładka

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

To stare pytanie, ale biorąc pod uwagę odpowiedź Mathiasa Bynensa, stworzyłem krótką wersję, aby posortować bieżący obiekt, bez większego obciążenia.

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

po wykonaniu kodu sam „nieuporządkowany” obiekt będzie posortowany alfabetycznie.

Przy użyciu lodash będzie to działać:

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

Tylko jedzenie do namysłu.

Załóżmy, że może to być przydatne w debuggerze VisualStudio, który pokazuje nieuporządkowane właściwości obiektu.

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

Wersja podkreślenia :

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

Jeśli nie ufasz przeglądarce, że zachowuje porządek kluczy, zdecydowanie sugeruję, aby polegać na uporządkowanej tablicy sparowanych tablic klucz-wartość.

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

Może nieco bardziej elegancka forma:

 /**
     * 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 i to samo ze składnią ES6 +:

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

sortowanie rekurencyjne, dla zagnieżdżonych obiektów i tablic

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

Jak już wspomniano, obiekty są nieuporządkowane.

Jednak...

Ten idiom może ci się przydać:

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

var kv = [];

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

kv.sort()

Następnie możesz iterować przez kv i robić, co chcesz.

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

Oto czysta wersja oparta na lodash, która działa z zagnieżdżonymi obiektami

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

Byłoby jeszcze czystsze, gdyby lodash miał toObject()metodę ...

Wystarczy użyć lodash, aby rozpakować mapę i sortować.Pierwsza wartość pary i zip ponownie zwróci posortowany klucz.

Jeśli chcesz posortować wartość, zmień indeks par na 1 zamiast 0

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

Sortuje klucze rekurencyjnie, zachowując odwołania.

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

Przykład:

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

Jest to lekkie rozwiązanie do wszystkiego, czego potrzebuję do sortowania 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;
    }, {});
}

Użyj tego kodu, jeśli zagnieżdżałeś obiekty lub zagnieżdżałeś tablicę obj.

var sortObjectByKey = function(obj){
    var keys = [];
    var sorted_obj = {};
    for(var key in obj){
        if(obj.hasOwnProperty(key)){
            keys.push(key);
        }
    }
    // sort keys
    keys.sort();

    // create new array based on Sorted Keys
    jQuery.each(keys, function(i, key){
        var val = obj[key];
        if(val instanceof Array){
            //do for loop;
            var arr = [];
            jQuery.each(val,function(){
                arr.push(sortObjectByKey(this));
            }); 
            val = arr;

        }else if(val instanceof Object){
            val = sortObjectByKey(val)
        }
        sorted_obj[key] = val;
    });
    return sorted_obj;
};

Rozwiązanie:

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

Wyjaśnienie:

Wiele środowisk wykonawczych JavaScript zapisuje wartości wewnątrz obiektu w kolejności, w jakiej są dodawane.

Aby posortować właściwości obiektu według kluczy, możesz skorzystać z funkcji Object.keys, która zwróci tablicę kluczy. Tablicę kluczy można następnie posortować za pomocą Array.prototype.sort () metody , która sortuje elementy tablicy w miejscu (nie trzeba przypisywać ich do nowej zmiennej).

Po posortowaniu kluczy możesz zacząć używać ich jeden po drugim, aby uzyskać dostęp do zawartości starego obiektu w celu wypełnienia nowego obiektu (który jest teraz posortowany).

Poniżej znajduje się przykład procedury (możesz to przetestować w wybranych przeglądarkach):

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

Uwaga: Object.keys to metoda ECMAScript 5.1, ale tutaj jest wypełnianie wielu starszych przeglądarek:

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

Przekazałem niektóre wyliczenia Java do obiektów javascript.

Te obiekty zwróciły dla mnie prawidłowe tablice. jeśli klucze obiektów są typu mieszanego (string, int, char), istnieje problem.

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

Prosty i czytelny fragment kodu, korzystający z lodash.

Musisz wpisać klucz w cudzysłów tylko podczas wywoływania sortBy. Nie musi zawierać cudzysłowów w samych danych.

_.sortBy(myObj, "key")

Ponadto drugi parametr do mapowania jest nieprawidłowy. Powinna to być funkcja, ale łatwiejsze jest używanie skubania.

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

Jest świetny projekt @sindresorhus o nazwie sort-keys, który działa niesamowicie.

Możesz sprawdzić jego kod źródłowy tutaj:

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

Możesz też użyć go z npm:

$ npm install --save sort-keys

Oto także przykłady kodu z jego pliku 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}

Czysta odpowiedź JavaScript do sortowania obiektu. To jedyna znana mi odpowiedź, która poradzi sobie z liczbami ujemnymi. Ta funkcja służy do sortowania obiektów numerycznych.

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

Wyjściem będzie obiekt posortowany według tych liczb z nowymi kluczami zaczynającymi się od 0.

Aby to uprościć i wyjaśnić odpowiedź 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]);
}

Nie jestem pewien, czy to odpowiada na pytanie, ale tego właśnie potrzebowałem.

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

Nazywany jako:

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

Jedna linia:

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

najlepszym sposobem na to jest

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

Możesz najpierw przekonwertować prawie podobny do tablicy obiekt na prawdziwą tablicę, a następnie użyć .reverse ():

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

Puste miejsce na końcu, jeśli powoduje, ponieważ twój pierwszy indeks to 1 zamiast 0. Możesz usunąć puste miejsce za pomocą .length-- lub .pop ().

Alternatywnie, jeśli chcesz pożyczyć .reverse i wywołać go na tym samym obiekcie, musi to być obiekt w pełni tablicowy. Oznacza to, że potrzebuje właściwości length:

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

Zauważ, że zwróci ten sam obiekt obiektowy w pełni tablicowy, więc nie będzie to prawdziwa tablica. Następnie możesz użyć delete, aby usunąć właściwość length.