JavaScriptオブジェクトをキーでソートする
JavaScriptオブジェクトをキーでソートする必要があります。
したがって、次のとおりです。
{ 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' }
になるでしょう：
{ 'a' : 'dsfdsfsdf', 'b' : 'asdsad', 'c' : 'masdas' }
この質問に対する他の回答は時代遅れであり、実装の現実と一致することはなく、ES6/ES2015仕様が公開されたため、 official /が正しくなくなりました。
Axel Rauschmayerによる Exploring ES6 のproperty iteration orderのセクションを参照してください ：
プロパティキーを反復処理するすべてのメソッドは、同じ順序で繰り返します。
- 最初に、数値順にソートされたすべての配列インデックス。
- 次に、作成された順序でのすべての文字列キー（インデックスではない）。
- 次に、作成された順序ですべてのシンボル。
はい、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"}'ES5エンジンとの互換性のために、varの代わりにconstを使用します。
JavaScriptオブジェクト1 注文されていません。並べ替えようとしても意味がありません。オブジェクトのプロパティを反復処理したい場合は、キーをソートしてから関連する値を取得できます。
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オブジェクトのようなものはない 。
多くの人が "オブジェクトはソートできない" と述べていますが、その後彼らはあなたにうまくいく解決策を与えています。パラドックスでしょ？
これらのソリューションが機能している理由は誰にもわかりません。ブラウザの実装のほとんどでオブジェクトの値が追加された順に格納されているからです。ソートされたキーのリストから新しいオブジェクトを作成した場合、期待どおりの結果が得られるのはそのためです。
そして、もう1つ解決策を追加できると思います - ES5機能的方法：
function sortObject(obj) {
return Object.keys(obj).sort().reduce(function (result, key) {
result[key] = obj[key];
return result;
}, {});
}
上記のES2015バージョン（「ワンライナー」にフォーマット）：
function sortObject(o) {
return Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {});
}
上記の例の簡単な説明（コメント欄）
Object.keysは提供されたオブジェクトのキーのリスト（objまたはo）を与えているので、デフォルトのソートアルゴリズムを使ってそれらをソートしています。次に.reduceを使ってその配列をオブジェクトに戻します。
これは私のために働く
/**
* 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;
};
みんな私は比喩的にショックを受けています！確かにすべての答えはやや古くなっていますが、ソートの安定性については誰も言及していませんでした。だから私と一緒に負担します私は質問自体に答え、ここで詳細に入るために最善を尽くします。それで、私は今それが読むことがたくさんあるであろう今謝罪するつもりです。
2018年なので、私はES6のみを使用します。PolyfillsはすべてMDNのドキュメントで入手できます。これについては特定の部分でリンクします
質問への回答：
キーが数字だけの場合は、ソートされたオブジェクトを返すために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のreturn文に括弧を使用する理由： 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（）は、その要素がobjectで直接見つかる列挙可能なプロパティに対応する文字列である配列を返します。プロパティの順序は、オブジェクトのプロパティを手動でループ処理した場合と同じです。
傍注 - 配列でもObject.keys()を使用できます。インデックスが返されることに注意してください。
// simple array
const arr = ['a', 'b', 'c'];
console.log(Object.keys(arr)); // console: ['0', '1', '2']
しかし、それはそれらの例で示されるほど簡単ではありません、現実世界のオブジェクトは数字とアルファベット文字またはシンボルさえ含むかもしれません（それをしないでください）。
これは、1つのオブジェクトにそれらすべてが含まれている例です。
// 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コードポイントに従います。
この種の時間と空間の複雑さは実装に依存するため保証できません。
あなたはそれらの1つがあなたのために望ましい出力を返すことを確認しなければなりません。実際の例では、特にAPIとデータベースのような異なる情報入力を一緒に使用する場合、人々は物事を混同する傾向があります。
だから大したことは何ですか？
すべてのプログラマが理解すべき2つの記事があります。
コンピュータサイエンスでは、インプレースアルゴリズムは補助データ構造を使用せずに入力を変換するアルゴリズムです。ただし、補助変数用に少量の追加記憶域スペースが許可されます。アルゴリズムが実行されると、通常、入力は出力によって上書きされます。インプレースアルゴリズムは、要素の置換または交換によってのみ入力シーケンスを更新します。インプレースではないアルゴリズムは、インプレースまたはアウトオブプレースとも呼ばれます。
だから基本的に私たちの古い配列は上書きされます！他の理由で古い配列を保持したい場合、これは重要です。だからこれを覚えておいてください。
安定ソートアルゴリズムは、入力に現れるのと同じ順序で同一の要素をソートします。ある種のデータをソートするときは、ソート順を決定するときにデータの一部だけが調べられます。たとえば、右のカードの並べ替えの例では、カードはランクによって並べ替えられており、スーツは無視されています。これにより、元のリストの複数の異なる正しくソートされたバージョンの可能性が可能になります。 2つの5つのカードのように、2つの項目が等しいと比較された場合、それらの相対的な順序は保持され、入力で一方が他方の前に来た場合も同様になります。出力では他のものよりも前に来ます。
トランプの安定ソートの例カードが安定ソートでランク順にソートされている場合、2つの5は元のソート順で同じ順序で並んでいる必要があります。非安定ソートでソートされている場合、5は反対になる可能性があります。ソートされた出力の順序.
これはソートは正しいが変更されたことを示しています。したがって、実際の世界では、ソートが正しい場合でも、期待どおりの結果が得られるようにする必要があります。これも非常に重要です。これも念頭に置いてください。その他のJavaScriptの例については、Array.prototype.sort（）を参照してください。 - docs： https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort
これは古い質問ですが、Mathias Bynensの答えから手がかりとして、 current オブジェクトをソートするための短いバージョンを作成しました。
Object.keys(unordered).sort().forEach(function(key) {
var value = unordered[key];
delete unordered[key];
unordered[key] = value;
});
コードの実行後、「順序付けされていない」オブジェクト自体はアルファベット順にソートされたキーを持ちます。
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();
思考のためだけの食べ物。
これが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), {} ));順序付けされていないオブジェクトのプロパティを表示する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]})
もう少しエレガントな形にすることもできます。
/**
* 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 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)=>{
acc[key]=obj[key];
return acc;
},{});
}
sortObjectKeys({
telephone: '069911234124',
name: 'Lola',
access: true,
});
入れ子になったオブジェクトと配列に対する再帰的ソート
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!'
}
},
]
});
2019年で、これを解決するために2019年の方法があります。
Object.fromEntries(Object.entries({b: 3, a:8, c:1}).sort())
すでに述べたように、オブジェクトは順不同です。
しかしながら...
この慣用句は便利です。
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' ] ]
Lodashを使ってmapとsortByのペアの最初の値を解凍するだけで、再びソートされたキーが返されます。
Sortbyの値を変えたい場合は、ペアのインデックスを 0 ではなく 1 に変更してください。
var o = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' };
console.log(_(o).toPairs().sortBy(0).fromPairs().value())
これは入れ子になったオブジェクトで動作するクリーンなlodashベースのバージョンです。
/**
* 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()メソッドを持っていたらもっときれいになるでしょう ...
解決策：
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});
説明：
多くのJavaScriptランタイムは、値を追加された順にオブジェクト内に格納します。
キーでオブジェクトのプロパティをソートするには、キーの配列を返す Object.keys 関数を使用できます。キーの配列は配列の要素をその場でソートする Array.prototype.sort（） メソッドでソートすることができます（新しい変数に割り当てる必要はありません）。
キーがソートされたら、古いオブジェクトの内容にアクセスして新しいオブジェクトを埋めるためにキーを1つずつ使い始めることができます（これでソートされます）。
以下はその手順の一例です（ターゲットのブラウザでテストできます）。
/**
* 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のメソッドですが、こちらは古いブラウザ用のポリフィルです。
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 enumをjavascriptオブジェクトに移しました。
これらのオブジェクトは私にとって正しい配列を返しました。オブジェクトキーが混合型（string、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"]
参照を保持しながらキーを再帰的にソートします。
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}
Lodashを使ったシンプルで読みやすいスニペット。
SortByを呼び出すときにのみ、キーを引用符で囲む必要があります。データ自体を引用符で囲む必要はありません。
_.sortBy(myObj, "key")
また、マップする2番目のパラメータが間違っています。それは関数であるべきですが、pluckを使うほうが簡単です。
_.map( _.sortBy(myObj, "key") , "value");
オブジェクトをネストしている場合、または配列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;
};
ソートキーと呼ばれる@sindresorhusによる素晴らしいプロジェクトがあり、それは素晴らしい動作をします。
あなたはここでそのソースコードをチェックすることができます：
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}
単純化して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]);
}オブジェクトをソートするための純粋なJavaScriptの回答。これが私が知っているのは負の数を処理する唯一の答えです。この関数は数値オブジェクトをソートするためのものです。
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から始まる番号でソートされたオブジェクトになります。
Object.keys(unordered).sort().reduce(
(acc,curr) => ({...acc, [curr]:unordered[curr]})
, {}
)
これが質問に答えるかどうかわからないが、これは私が必要としていたものです。
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) { ... } )
1行：
Object.entries(unordered)
.sort(([keyA], [keyB]) => keyA > keyB)
.reduce((obj, [key,value]) => Object.assign(obj, {[key]: value}), {})