เรียงลำดับวัตถุ JavaScript ตามคีย์

ฉันต้องการเรียงลำดับวัตถุ JavaScript ตามรหัส

ดังนั้นต่อไปนี้:

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

จะกลายเป็น:

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

คำตอบอื่น ๆ สำหรับคำถามนี้ล้าสมัยไม่เคยจับคู่ความเป็นจริงในการใช้งานและได้กลายเป็นไม่ถูกต้องอย่างเป็นทางการในขณะนี้ซึ่งข้อมูลจำเพาะ ES6 / ES2015 ได้รับการเผยแพร่แล้ว

ดูหัวข้อการเรียงลำดับคุณสมบัติในExploring ES6โดย Axel Rauschmayer :

วิธีการทั้งหมดที่ทำซ้ำผ่านคีย์คุณสมบัติทำตามลำดับเดียวกัน:

1. อันดับแรกดัชนี Array ทั้งหมดเรียงลำดับตัวเลข
2. จากนั้นสตริงคีย์ทั้งหมด (ซึ่งไม่ใช่ดัชนี) ตามลำดับที่สร้างขึ้น
3. จากนั้นสัญลักษณ์ทั้งหมดตามลำดับที่สร้างขึ้น

ดังนั้นใช่วัตถุ JavaScript อยู่ในความเป็นจริงได้รับคำสั่งและคำสั่งของกุญแจ / คุณสมบัติสามารถเปลี่ยนแปลงได้

นี่คือวิธีที่คุณสามารถเรียงลำดับวัตถุตามคีย์ / คุณสมบัติของมันตามลำดับตัวอักษร:

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

ใช้varแทนconstสำหรับความเข้ากันได้กับเอ็นจิ้น ES5

ไม่มีการสั่งซื้อวัตถุ JavaScript ¹ มันไม่มีความหมายเลยที่จะลอง "เรียง" พวกมัน หากคุณต้องการวนซ้ำคุณสมบัติของวัตถุคุณสามารถเรียงลำดับคีย์แล้วดึงค่าที่เกี่ยวข้อง:

var myObj = {
    'b': 'asdsadfd',
    'c': 'masdasaf',
    'a': 'dsfdsfsdf'
  },
  keys = [],
  k, i, len;

for (k in myObj) {
  if (myObj.hasOwnProperty(k)) {
    keys.push(k);
  }
}

keys.sort();

len = keys.length;

for (i = 0; i < len; i++) {
  k = keys[i];
  console.log(k + ':' + myObj[k]);
}

การติดตั้งสำรองโดยใช้Object.keysความเพ้อฝัน:

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เพื่อไม่ให้อวดความรู้ แต่ไม่มีสิ่งดังกล่าวเป็นวัตถุ JSON}

ผู้คนมากมายพูดถึงว่า"ไม่สามารถจัดเรียงวัตถุ"แต่หลังจากนั้นพวกเขาก็ให้วิธีแก้ปัญหาที่ใช้งานได้กับคุณ Paradox ใช่มั้ย

ไม่มีใครพูดถึงว่าทำไมโซลูชั่นเหล่านี้ถึงใช้งานได้ พวกเขาเป็นเพราะส่วนใหญ่ของการใช้งานค่าเบราว์เซอร์ในวัตถุจะถูกเก็บไว้ในลำดับที่พวกเขาถูกเพิ่ม นั่นเป็นเหตุผลที่ถ้าคุณสร้างวัตถุใหม่จากรายการของคีย์ที่เรียงลำดับมันจะส่งคืนผลลัพธ์ที่คาดหวัง

และฉันคิดว่าเราสามารถเพิ่มโซลูชันอีกหนึ่งวิธี - วิธีการทำงาน ES5:

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

รุ่น ES2015 ขึ้นไป (จัดรูปแบบเป็น "หนึ่งซับ"):

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

คำอธิบายสั้น ๆ ของตัวอย่างข้างต้น (ตามที่ถามในความคิดเห็น):

Object.keysจะให้รายชื่อของกุญแจในวัตถุที่จัดเตรียม ( objหรือo) จากนั้นเราจะเรียงลำดับโดยใช้อัลกอริทึมการเรียงลำดับเริ่มต้นถัดไป.reduceจะใช้ในการแปลงอาร์เรย์นั้นกลับเป็นวัตถุ แต่คราวนี้มีการเรียงลำดับคีย์ทั้งหมด

พวกฉันตกใจเป็นรูปเป็นร่าง! แน่นอนว่าคำตอบทั้งหมดค่อนข้างเก่า แต่ก็ไม่มีใครพูดถึงเสถียรภาพในการเรียงลำดับ! ดังนั้นทนกับฉันฉันจะพยายามอย่างดีที่สุดเพื่อตอบคำถามตัวเองและไปที่รายละเอียดที่นี่ ดังนั้นฉันจะขอโทษตอนนี้มันจะเป็นจำนวนมากที่จะอ่าน

เนื่องจากเป็นปี 2018 ฉันจะใช้ ES6 เท่านั้น Polyfills จึงมีอยู่ใน MDN docs ซึ่งฉันจะเชื่อมโยงในส่วนที่กำหนด

ตอบคำถาม:

หากคีย์ของคุณเป็นตัวเลขเท่านั้นคุณสามารถใช้Object.keys()ร่วมกับArray.prototype.reduce()เพื่อส่งคืนวัตถุที่เรียงลำดับได้อย่างปลอดภัย:

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

อย่างไรก็ตามหากคุณกำลังทำงานกับสตริงฉันขอแนะนำให้ผูกมัดArray.prototype.sort()กับสิ่งนี้ทั้งหมด:

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

หากมีคนสงสัยว่าการลดราคาทำอย่างไร:

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

หากจำเป็นนี่คือคำอธิบายสำหรับสายการบินเดียว:

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

• เอกสารสำหรับการลด: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce
• เหตุใดจึงต้องใช้วงเล็บในงบการส่งคืน JavaScript: http://jamesknelson.com/javascript-return-parenthesis/

ทำไมการเรียงลำดับค่อนข้างซับซ้อน:

ในระยะสั้นObject.keys()จะส่งกลับอาร์เรย์ที่มีคำสั่งเดียวกับที่เราได้รับกับวงปกติ:

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

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

Object.keys () ส่งคืนอาร์เรย์ที่มีองค์ประกอบเป็นสตริงที่สอดคล้องกับคุณสมบัติที่นับได้ที่พบโดยตรงกับวัตถุ การเรียงลำดับของคุณสมบัติเหมือนกับที่กำหนดโดยการวนลูปมากกว่าคุณสมบัติของวัตถุด้วยตนเอง

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

Sidenote - คุณสามารถใช้Object.keys()กับอาร์เรย์ได้เช่นกันโปรดจำไว้ว่าดัชนีจะถูกส่งคืน:

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

แต่มันไม่ง่ายอย่างที่แสดงในตัวอย่างวัตถุในโลกแห่งความจริงอาจมีตัวเลขและตัวอักษรหรือแม้แต่สัญลักษณ์ (โปรดอย่าทำ)

นี่คือตัวอย่างที่มีทั้งหมดในวัตถุเดียว:

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

ทีนี้ถ้าเราใช้Array.prototype.sort()กับอาเรย์ข้างบนการเปลี่ยนแปลงเอาท์พุต:

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

นี่คือคำพูดจากเอกสาร:

sort () วิธีการเรียงลำดับองค์ประกอบของอาร์เรย์ในสถานที่และส่งกลับอาร์เรย์ การเรียงลำดับไม่จำเป็นต้องมีเสถียรภาพ ลำดับการเรียงเริ่มต้นเป็นไปตามจุดรหัส Unicode ของสตริง

ไม่สามารถรับประกันความซับซ้อนของเวลาและพื้นที่ของการจัดเรียงได้เนื่องจากขึ้นอยู่กับการใช้งาน

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

คุณต้องตรวจสอบให้แน่ใจว่าหนึ่งในนั้นส่งคืนผลลัพธ์ที่ต้องการสำหรับคุณ ในตัวอย่าง reallife คนมักจะรวมสิ่งต่าง ๆ โดยเฉพาะอย่างยิ่งถ้าคุณใช้ข้อมูลที่แตกต่างกันเช่น API และฐานข้อมูลเข้าด้วยกัน

ดังนั้นเรื่องใหญ่คืออะไร

มีสองบทความที่โปรแกรมเมอร์ทุกคนควรเข้าใจคือ

อัลกอริธึมแบบแทนที่ :

ในวิทยาการคอมพิวเตอร์อัลกอริทึมแบบแทนที่คืออัลกอริธึมที่แปลงอินพุตโดยไม่มีโครงสร้างข้อมูลเสริม อย่างไรก็ตามอนุญาตให้มีพื้นที่เก็บข้อมูลจำนวนเล็กน้อยสำหรับตัวแปรเสริม โดยทั่วไปอินพุตจะถูกเขียนทับโดยเอาต์พุตเมื่ออัลกอริทึมทำงาน อัลกอริธึมแบบเข้าแทนที่จะอัปเดตลำดับอินพุตผ่านการแทนที่หรือการเปลี่ยนองค์ประกอบเท่านั้น อัลกอริทึมที่ไม่ได้อยู่ในสถานที่บางครั้งเรียกว่าไม่ได้อยู่ในสถานที่หรือนอกสถานที่

ดังนั้นโดยทั่วไปอาร์เรย์เก่าของเราจะถูกเขียนทับ! สิ่งนี้สำคัญถ้าคุณต้องการเก็บอาเรย์เก่าด้วยเหตุผลอื่น ดังนั้นจงเก็บเรื่องนี้ไว้ในใจ

ขั้นตอนวิธีการเรียงลำดับ

อัลกอริทึมการเรียงลำดับที่เสถียรจัดเรียงองค์ประกอบที่เหมือนกันในลำดับเดียวกันกับที่ปรากฏในอินพุต เมื่อเรียงลำดับข้อมูลบางประเภทจะมีการตรวจสอบข้อมูลบางส่วนเท่านั้นเมื่อพิจารณาลำดับการจัดเรียง ตัวอย่างเช่นในตัวอย่างการเรียงลำดับบัตรทางด้านขวาการ์ดจะถูกเรียงลำดับตามระดับของบัตรและชุดไพ่จะถูกละเว้น สิ่งนี้ทำให้เกิดความเป็นไปได้ของรายการดั้งเดิมที่เรียงลำดับอย่างถูกต้องหลายรายการ อัลกอริธึมการเรียงลำดับที่เสถียรเลือกหนึ่งในสิ่งเหล่านี้ตามกฎต่อไปนี้: หากรายการสองรายการเปรียบเทียบเท่ากันเช่นสองไพ่ 5 ใบลำดับที่สัมพันธ์กันของพวกเขาจะถูกเก็บรักษาไว้เพื่อที่ว่าหากมีใครมาก่อน มาก่อนอื่น ๆ ในการส่งออก

ตัวอย่างของการเรียงไพ่ที่มีเสถียรภาพ เมื่อการ์ดถูกจัดเรียงตามลำดับที่มีการจัดเรียงที่เสถียรทั้งสอง 5s จะต้องอยู่ในลำดับเดียวกันในเอาต์พุตที่เรียงลำดับซึ่งพวกเขาอยู่ในขั้นต้นเมื่อพวกเขาเรียงลำดับด้วยการเรียงที่ไม่เสถียรที่ 5s อาจจบลงในทางตรงกันข้าม เรียงลำดับผลลัพธ์

นี่แสดงให้เห็นว่าการเรียงลำดับนั้นถูกต้อง แต่เปลี่ยนไป ดังนั้นในโลกแห่งความจริงแม้ว่าการเรียงลำดับจะถูกต้องเราต้องแน่ใจว่าเราได้รับสิ่งที่เราคาดหวัง! นี่เป็นสิ่งที่สำคัญอย่างยิ่ง สำหรับตัวอย่าง JavaScript เพิ่มเติมให้ดูที่ Array.prototype.sort () - docs: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort

มันใช้งานได้สำหรับฉัน

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

มันคือ 2019 และเรามีวิธีแก้ปัญหานี้ 2019 :)

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

นี่คือ 1 ซับ

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

นี่เป็นคำถามเก่า แต่จากคำตอบของ Mathias Bynens ฉันได้สร้างเวอร์ชั่นสั้น ๆ เพื่อจัดเรียงวัตถุปัจจุบันโดยไม่มีค่าใช้จ่ายมากนัก

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

หลังจากการประมวลผลรหัสวัตถุ "unordered" เองจะมีคีย์เรียงตามตัวอักษร

การใช้ lodash จะทำงานได้:

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

แค่คิดอาหาร

สมมติว่ามันอาจเป็นประโยชน์ในการดีบักเกอร์ VisualStudio ซึ่งแสดงคุณสมบัติของวัตถุที่ไม่ได้เรียงลำดับ

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

รุ่นขีดล่าง :

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

หากคุณไม่เชื่อถือเบราว์เซอร์ของคุณเพื่อรักษาลำดับของคีย์ฉันขอแนะนำให้ใช้อาร์เรย์ของคีย์ - ค่าจับคู่อาร์เรย์

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

อาจเป็นรูปแบบที่สง่างามกว่านี้อีกเล็กน้อย:

 /**
     * 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 และไวยากรณ์ ES6 + เดียวกัน:

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

เรียงลำดับแบบเรียกซ้ำสำหรับวัตถุและอาร์เรย์ที่ซ้อนกัน

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

ดังที่ได้กล่าวไปแล้ววัตถุจะไม่ได้เรียง

อย่างไรก็ตาม ...

คุณอาจพบว่าสำนวนนี้มีประโยชน์:

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

var kv = [];

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

kv.sort()

จากนั้นคุณสามารถทำซ้ำผ่าน kv และทำสิ่งที่คุณต้องการ

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

นี่เป็นเวอร์ชั่นที่ใช้ Clean lod-based ซึ่งทำงานกับวัตถุที่ซ้อนกัน

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

มันจะสะอาดกว่านี้หาก lodash มีtoObject()วิธีการ ...

เพียงใช้ lodash เพื่อคลายซิปแผนที่และ sort โดยค่าแรกของคู่และ zip อีกครั้งมันจะส่งคืนคีย์การเรียงลำดับ

หากคุณต้องการให้ค่า sortby เปลี่ยนดัชนีคู่เป็น1แทน0

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

เรียงลำดับคีย์แบบเรียกซ้ำขณะที่คงการอ้างอิงไว้

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

ตัวอย่าง:

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

นี่เป็นโซลูชันที่มีน้ำหนักเบาสำหรับทุกสิ่งที่ฉันต้องการสำหรับการเรียงลำดับ 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;
    }, {});
}

ใช้รหัสนี้ถ้าคุณมีวัตถุที่ซ้อนกันหรือถ้าคุณมีอาร์เรย์ที่ซ้อนกัน 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;
};

สารละลาย:

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

คำอธิบาย:

รันไทม์จาวาสคริปต์จำนวนมากเก็บค่าไว้ภายในวัตถุตามลำดับที่ถูกเพิ่มเข้าไป

ในการจัดเรียงคุณสมบัติของวัตถุด้วยปุ่มคุณสามารถใช้ฟังก์ชันObject.keysซึ่งจะส่งกลับอาร์เรย์ของคีย์ อาร์เรย์ของคีย์นั้นสามารถจัดเรียงโดยArray.prototype.sort ()วิธีการที่จะเรียงลำดับองค์ประกอบของอาร์เรย์ในสถานที่ (ไม่จำเป็นต้องกำหนดให้กับตัวแปรใหม่)

เมื่อคีย์ถูกเรียงคุณสามารถเริ่มใช้หนึ่งต่อหนึ่งเพื่อเข้าถึงเนื้อหาของวัตถุเก่าเพื่อเติมวัตถุใหม่ (ซึ่งตอนนี้ถูกจัดเรียง)

ด้านล่างเป็นตัวอย่างของขั้นตอน (คุณสามารถทดสอบในเบราว์เซอร์เป้าหมายของคุณ):

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

หมายเหตุ: Object.keysเป็นวิธี ECMAScript 5.1 แต่นี่คือ polyfill สำหรับเบราว์เซอร์รุ่นเก่า:

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

ฉันถ่ายโอน Java enums ไปยังวัตถุจาวาสคริปต์

วัตถุเหล่านี้ส่งคืนอาร์เรย์ที่ถูกต้องสำหรับฉัน หากคีย์วัตถุเป็นชนิดผสม (สตริง, int, char) จะมีปัญหา

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

ตัวอย่างข้อมูลที่ง่ายและอ่านง่ายโดยใช้ lodash

คุณต้องใส่กุญแจในเครื่องหมายคำพูดเฉพาะเมื่อโทร sortBy ไม่จำเป็นต้องอยู่ในเครื่องหมายคำพูดในข้อมูลเอง

_.sortBy(myObj, "key")

นอกจากนี้พารามิเตอร์ที่สองในการแมปผิด มันควรจะเป็นฟังก์ชั่น แต่การใช้ถอนจะง่ายกว่า

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

มีโครงการที่ยอดเยี่ยมโดย @sindresorhus เรียกว่า sort-keys ที่ทำงานได้ยอดเยี่ยม

คุณสามารถตรวจสอบซอร์สโค้ดได้ที่นี่:

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

หรือคุณสามารถใช้กับ npm:

$ npm install --save sort-keys

นี่คือตัวอย่างรหัสจาก 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}

คำตอบของจาวาสคริปต์เพียวเพื่อจัดเรียงวัตถุ นี่เป็นคำตอบเดียวที่ฉันรู้ว่าจะจัดการกับจำนวนลบ ฟังก์ชั่นนี้ใช้สำหรับการเรียงลำดับวัตถุที่เป็นตัวเลข

อินพุต 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;
}

ผลลัพธ์จะเป็นวัตถุที่เรียงลำดับตามตัวเลขเหล่านั้นด้วยปุ่มใหม่เริ่มต้นที่ 0

เพียงแค่ทำให้มันง่ายขึ้นและทำให้ชัดเจนขึ้นคำตอบจาก 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]);
}

ไม่แน่ใจว่านี่ตอบคำถาม แต่นี่คือสิ่งที่ฉันต้องการ

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

เรียกว่า:

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

หนึ่งบรรทัด:

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

วิธีที่ดีที่สุดที่จะทำคือ

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

คุณสามารถแปลงวัตถุที่มีลักษณะคล้ายอาเรย์เป็นอาเรย์แรกแล้วใช้. reverse ():

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

ช่องว่างที่ท้ายถ้าสาเหตุเนื่องจากดัชนีแรกของคุณคือ 1 แทน 0 คุณสามารถลบช่องว่างด้วย. ความยาว - หรือ. pop ()

อีกวิธีหนึ่งถ้าคุณต้องการยืม. กลับและเรียกมันบนวัตถุเดียวกันนั้นจะต้องเป็นวัตถุที่เหมือนอาร์เรย์ นั่นคือมันต้องการคุณสมบัติที่มีความยาว:

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

โปรดทราบว่ามันจะส่งคืนวัตถุออบเจ็กต์ที่มีลักษณะเหมือนอาร์เรย์อย่างเต็มรูปแบบดังนั้นมันจะไม่เป็นอาร์เรย์จริง จากนั้นคุณสามารถใช้การลบเพื่อลบคุณสมบัติความยาว