Urutkan objek JavaScript dengan kunci

Saya perlu mengurutkan objek JavaScript dengan kunci.

Maka berikut ini:

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

Akan menjadi:

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

Jawaban lain untuk pertanyaan ini sudah usang, realitas implementasi tidak pernah cocok, dan secara resmi menjadi tidak benar sekarang karena spesifikasi ES6 / ES2015 telah diterbitkan.

Lihat bagian tentang urutan iterasi properti di Menjelajahi ES6 oleh Axel Rauschmayer :

Semua metode yang beralih pada kunci properti melakukannya dalam urutan yang sama:

1. Pertama semua indeks Array, diurutkan secara numerik.
2. Kemudian semua kunci string (yang bukan indeks), sesuai urutan pembuatannya.
3. Lalu semua simbol, sesuai urutan pembuatannya.

Jadi ya, objek JavaScript yang sebenarnya memerintahkan, dan urutan kunci mereka / sifat dapat diubah.

Inilah cara Anda bisa mengurutkan objek berdasarkan kunci / propertinya, menurut abjad:

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

Gunakan varalih-alih constuntuk kompatibilitas dengan mesin ES5.

Objek JavaScript ¹ tidak dipesan. Tidak ada artinya mencoba "memilah" mereka. Jika Anda ingin mengulangi properti objek, Anda bisa mengurutkan kunci dan kemudian mengambil nilai terkait:

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

Implementasi alternatif menggunakan 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 Tidak ingin bertele-tele, tetapi tidak ada objek JSON .}

Banyak orang telah menyebutkan bahwa "objek tidak dapat diurutkan" , tetapi setelah itu mereka memberi Anda solusi yang berfungsi. Paradox, bukan?

Tidak ada yang menyebutkan mengapa solusi itu berhasil. Yaitu, karena di sebagian besar implementasi nilai-nilai browser dalam objek disimpan dalam urutan di mana mereka ditambahkan. Itu sebabnya jika Anda membuat objek baru dari daftar kunci yang disortir, itu mengembalikan hasil yang diharapkan.

Dan saya pikir kita bisa menambahkan satu lagi solusi - cara fungsional ES5:

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

Versi ES2015 di atas (diformat menjadi "satu-liner"):

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

Penjelasan singkat dari contoh di atas (seperti yang ditanyakan dalam komentar):

Object.keysmemberi kami daftar kunci pada objek yang disediakan ( objatau o), lalu kami menyortirnya menggunakan algoritma penyortiran default, selanjutnya .reducedigunakan untuk mengubah array itu kembali menjadi objek, tapi kali ini dengan semua kunci yang diurutkan.

Teman-teman saya secara kiasan terkejut! Tentu semua jawaban agak lama, tetapi tidak ada yang menyebutkan stabilitas dalam penyortiran! Jadi bersabarlah, saya akan mencoba yang terbaik untuk menjawab pertanyaan itu sendiri dan pergi ke detail di sini. Jadi saya akan minta maaf sekarang akan banyak dibaca.

Karena ini tahun 2018 saya hanya akan menggunakan ES6, semua Polyfill tersedia di dokumen MDN, yang akan saya tautkan pada bagian yang diberikan.

Jawab pertanyaan:

Jika kunci Anda hanya angka maka Anda dapat dengan aman menggunakannya Object.keys()bersama Array.prototype.reduce()untuk mengembalikan objek yang diurutkan:

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

Namun jika Anda bekerja dengan string, saya sangat menyarankan untuk merantai Array.prototype.sort()semua ini:

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

Jika seseorang bertanya-tanya pengurangan apa yang terjadi:

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

Jika diperlukan di sini adalah penjelasan untuk 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.
  ,{}
);

• Documents untuk mengurangi: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce
• Mengapa menggunakan tanda kurung pada pernyataan pengembalian JavaScript: http://jamesknelson.com/javascript-return-parenthesis/

Mengapa Penyortiran agak rumit:

Singkatnya Object.keys()akan mengembalikan array dengan urutan yang sama seperti yang kita dapatkan dengan loop normal:

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

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

Object.keys () mengembalikan array yang elemen-elemennya adalah string yang bersesuaian dengan properti enumerable yang ditemukan langsung pada objek. Urutan properti adalah sama dengan yang diberikan dengan mengulangi properti objek secara manual.

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

Sidenote - Anda dapat menggunakan Object.keys()pada array juga, perlu diingat indeks akan dikembalikan:

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

Tapi itu tidak semudah yang ditunjukkan oleh contoh-contoh itu, objek dunia nyata dapat berisi angka dan karakter alfabet atau bahkan simbol (tolong jangan lakukan itu).

Ini adalah contoh dengan semuanya dalam satu objek:

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

Sekarang jika kita gunakan Array.prototype.sort()pada array di atas perubahan output:

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

Berikut ini kutipan dari dokumen:

Metode sort () mengurutkan elemen-elemen dari array di tempat dan mengembalikan array. Semacam ini belum tentu stabil. Urutan penyortiran default adalah sesuai dengan poin kode Unicode string.

Kompleksitas waktu dan ruang dari jenis tidak dapat dijamin karena tergantung implementasi.

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

Anda harus memastikan bahwa salah satu dari mereka mengembalikan output yang diinginkan untuk Anda. Dalam contoh nyata, orang cenderung mencampuradukkan hal-hal secara khusus jika Anda menggunakan input informasi yang berbeda seperti API dan Database secara bersamaan.

Jadi apa masalahnya?

Ada dua artikel yang harus dipahami oleh setiap programmer:

Algoritma di tempat :

Dalam ilmu komputer, algoritma in-place adalah algoritma yang mengubah input tanpa menggunakan struktur data tambahan. Namun sejumlah kecil ruang penyimpanan tambahan diizinkan untuk variabel tambahan. Input biasanya ditimpa oleh output saat algoritma dijalankan. Algoritma in-place memperbarui urutan input hanya melalui penggantian atau pertukaran elemen. Algoritma yang tidak di tempat kadang-kadang disebut tidak di tempat atau di luar tempat.

Jadi pada dasarnya array lama kita akan ditimpa! Ini penting jika Anda ingin menyimpan array lama karena alasan lain. Jadi ingatlah ini.

Algoritma penyortiran

Algoritma sortir yang stabil mengurutkan elemen identik dalam urutan yang sama dengan yang muncul pada input. Saat mengurutkan beberapa jenis data, hanya sebagian dari data yang diperiksa saat menentukan urutan pengurutan. Misalnya, dalam contoh penyortiran kartu di sebelah kanan, kartu disortir berdasarkan pangkatnya, dan setelannya diabaikan. Ini memungkinkan beberapa versi berbeda yang diurutkan dengan benar dari daftar asli. Algoritma sorting yang stabil memilih salah satu dari ini, sesuai dengan aturan berikut: jika dua item membandingkan sama, seperti dua 5 kartu, maka urutan relatif mereka akan dipertahankan, sehingga jika satu datang sebelum yang lain dalam input, itu juga akan datang sebelum yang lain di output.

Contoh stabil pada kartu remi. Ketika kartu diurutkan berdasarkan peringkat dengan pengurutan yang stabil, kedua 5s harus tetap dalam urutan yang sama dalam output yang diurutkan di mana mereka awalnya masuk. Ketika mereka diurutkan dengan pengurutan yang tidak stabil, 5s mungkin berakhir sebaliknya. memesan dalam output yang diurutkan.

Ini menunjukkan bahwa penyortirannya benar tetapi itu berubah. Jadi di dunia nyata bahkan jika penyortirannya benar kita harus memastikan bahwa kita mendapatkan apa yang kita harapkan! Ini sangat penting mengingat hal ini juga. Untuk contoh JavaScript lainnya, lihat Array.prototype.sort () - docs: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort

Ini bekerja untuk saya

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

Ini tahun 2019 dan kami memiliki cara 2019 untuk menyelesaikan ini :)

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

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

Ini adalah pertanyaan lama, tetapi mengambil isyarat dari jawaban Mathias Bynens ', saya telah membuat versi pendek untuk mengurutkan objek saat ini , tanpa banyak overhead.

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

setelah eksekusi kode, objek "tidak berurutan" itu sendiri akan memiliki kunci yang diurutkan berdasarkan abjad.

Menggunakan lodash ini akan bekerja:

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

Hanya makanan untuk dipikirkan.

Misalkan itu bisa berguna dalam VisualStudio debugger yang menunjukkan properti objek yang tidak terurut.

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

Versi garis bawah :

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

Jika Anda tidak mempercayai peramban Anda untuk menjaga urutan kunci, saya sangat menyarankan untuk mengandalkan array array berpasangan dengan nilai kunci.

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

Mungkin bentuk yang sedikit lebih elegan:

 /**
     * 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 dan sama dengan sintaks ES6 +:

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

pengurutan rekursif, untuk objek dan array bersarang

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

Seperti yang telah disebutkan, objek tidak berurutan.

Namun...

Anda mungkin menemukan idiom ini berguna:

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

var kv = [];

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

kv.sort()

Anda kemudian dapat beralih melalui kv dan melakukan apapun yang Anda inginkan.

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

Berikut ini adalah versi berbasis Lodash bersih yang berfungsi dengan objek bersarang

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

Akan lebih bersih jika lodash memiliki toObject()metode ...

Cukup gunakan lodash untuk unzip peta dan urutkan oleh nilai pertama pasangan dan zip lagi itu akan mengembalikan kunci yang diurutkan.

Jika Anda ingin nilai pengubahan nilai indeks pasangan menjadi 1, bukan 0

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

Mengurutkan kunci secara rekursif sambil mempertahankan referensi.

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

Contoh:

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

Ini adalah solusi ringan untuk semua yang saya butuhkan untuk menyortir 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;
    }, {});
}

Gunakan kode ini jika Anda memiliki objek bersarang atau jika Anda memiliki objek array bersarang.

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

Larutan:

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

Penjelasan:

Banyak runtimes JavaScript menyimpan nilai di dalam objek sesuai urutan penambahannya.

Untuk mengurutkan properti suatu objek dengan kunci mereka, Anda dapat menggunakan fungsi Object.keys yang akan mengembalikan array kunci. Array kunci kemudian dapat diurutkan berdasarkan Array.prototype.sort () yang mengurutkan elemen-elemen array di tempat (tidak perlu menempatkan mereka ke variabel baru).

Setelah tombol diurutkan, Anda dapat mulai menggunakannya satu per satu untuk mengakses konten objek lama untuk mengisi objek baru (yang sekarang disortir).

Di bawah ini adalah contoh prosedur (Anda dapat mengujinya di browser yang ditargetkan):

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

Catatan: Object.keys adalah metode ECMAScript 5.1 tetapi di sini ada polyfill untuk peramban yang lebih lama:

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

Saya mentransfer beberapa enum Java ke objek javascript.

Objek-objek ini mengembalikan array yang benar untuk saya. jika kunci objek adalah tipe campuran (string, int, char), ada masalah.

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

Cuplikan sederhana dan mudah dibaca, menggunakan lodash.

Anda harus memasukkan kunci dalam tanda kutip hanya saat memanggil sortBy. Itu tidak harus dalam tanda kutip dalam data itu sendiri.

_.sortBy(myObj, "key")

Juga, parameter kedua Anda untuk memetakan salah. Seharusnya fungsi, tetapi menggunakan memetik lebih mudah.

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

Ada proyek hebat oleh @sindresorhus yang disebut sort-keys yang bekerja dengan sangat baik.

Anda dapat memeriksa kode sumbernya di sini:

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

Atau Anda dapat menggunakannya dengan npm:

$ npm install --save sort-keys

Berikut juga contoh kode dari readme-nya

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}

JavaScript murni menjawab untuk mengurutkan Objek. Ini adalah satu-satunya jawaban yang saya tahu yang akan menangani angka negatif. Fungsi ini untuk menyortir Objek numerik.

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

Output akan menjadi objek yang diurutkan berdasarkan angka-angka itu dengan kunci baru mulai dari 0.

Hanya untuk menyederhanakannya dan membuatnya lebih jelas jawaban dari 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]);
}

Tidak yakin apakah ini menjawab pertanyaan, tetapi inilah yang saya butuhkan.

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

Disebut sebagai:

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

Satu baris:

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

cara terbaik untuk melakukannya adalah

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

Pertama-tama Anda dapat mengonversi objek yang hampir mirip array menjadi array nyata, dan kemudian menggunakan .reverse ():

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

Slot kosong di bagian akhir jika disebabkan karena indeks pertama Anda adalah 1 bukan 0. Anda dapat menghapus slot kosong dengan .length-- atau .pop ().

Atau, jika Anda ingin meminjam .reverse dan menyebutnya pada objek yang sama, itu harus objek yang sepenuhnya seperti array. Artinya, perlu properti panjang:

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

Catatan itu akan mengembalikan objek objek yang sepenuhnya seperti array, sehingga tidak akan menjadi array nyata. Anda kemudian dapat menggunakan delete untuk menghapus properti panjang.