키별로 JavaScript 개체 정렬
JavaScript 객체를 키별로 정렬해야 합니다.
그 때문에, 다음과 같은 것이 있습니다.
{ 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' }
다음과 같이 됩니다.
{ 'a' : 'dsfdsfsdf', 'b' : 'asdsad', 'c' : 'masdas' }
이 질문에 대한 다른 답변은 구식이며, 구현 현실과 일치하는 적이 없으며, ES6/ES2015 사양이 발표되었기 때문에 공식적으로 잘못된 답변이 되었습니다.
Axel Rauschmayer의 ES6 탐색에서 속성 반복 순서에 대한 섹션을 참조하십시오.
속성 키로 반복하는 모든 메서드는 동일한 순서로 수행됩니다.
- 먼저 모든 배열 인덱스를 숫자로 정렬합니다.
- 다음으로 모든 문자열 키(인덱스가 아닌)가 작성된 순서대로 표시됩니다.
- 그리고 모든 심볼이 생성된 순서대로 표시됩니다.
따라서 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().reduce(
(obj, key) => {
obj[key] = unordered[key];
return obj;
},
{}
);
console.log(JSON.stringify(ordered));
// → '{"a":"baz","b":"foo","c":"bar"}'varconstES5를 사용하다
JavaScript1 객체의 순서가 매겨지지 않았습니다.그들을 분류하려고 하는 것은 무의미하다.개체의 속성에서 반복하려면 키를 정렬한 다음 관련 값을 검색할 수 있습니다.
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]);
}팬시티를 사용한 대체 구현:
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 오브젝트 같은 건 없어요
많은 사람들이 "사물을 분류할 수 없다"고 언급했지만, 그 후 그들은 당신에게 효과가 있는 해결책을 제공하고 있다.역설적이죠?
아무도 왜 그 솔루션이 효과가 있는지에 대해 언급하지 않았습니다.이는 대부분의 경우 브라우저의 객체 구현 값이 추가된 순서대로 저장되기 때문입니다.따라서 정렬된 키 목록에서 새 개체를 만들면 예상된 결과가 반환됩니다.
그리고 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만 사용하므로, 모든 폴리필은 MDN 문서에서 이용할 수 있으며, 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().
}, {});
필요한 경우 1개의 라이너에 대한 설명이 여기에 있습니다.
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()는 객체에서 직접 발견된 열거 가능한 속성에 대응하는 문자열 요소를 포함하는 배열을 반환합니다.속성 순서는 객체의 속성을 수동으로 루프할 때와 동일합니다.
- 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 코드 포인트에 따라 결정됩니다.
구현에 의존하기 때문에 이러한 종류의 시간과 공간의 복잡성은 보장할 수 없습니다.
이들 중 하나가 원하는 출력을 반환하는지 확인해야 합니다.재분배 예에서는 API 및 데이터베이스와 같은 다른 정보 입력을 함께 사용하는 경우 특히 사람들이 혼동하는 경향이 있습니다.
그게 어때서요?
모든 프로그래머가 이해해야 할 두 가지 기사가 있습니다.
임플레이스 알고리즘:
컴퓨터 과학에서 내부 알고리즘은 보조 데이터 구조를 사용하지 않고 입력을 변환하는 알고리즘입니다.그러나 보조 변수에는 소량의 추가 저장 공간이 허용됩니다.일반적으로 알고리즘이 실행될 때 입력이 출력에 의해 덮어씁니다.임플레이스 알고리즘은 요소의 교체 또는 교환을 통해서만 입력 시퀀스를 업데이트합니다.배치되지 않은 알고리즘은 배치되지 않은 알고리즘 또는 배치되지 않은 알고리즘이라고도 합니다.
따라서 기본적으로 이전 어레이를 덮어씁니다.다른 이유로 이전 어레이를 유지하려는 경우 이 기능이 중요합니다.그러니 명심하세요.
안정된 정렬 알고리즘은 입력에 표시되는 것과 같은 순서로 동일한 요소를 정렬합니다.일부 데이터를 정렬할 때 정렬 순서를 결정할 때 데이터의 일부만 검사됩니다.예를 들어, 오른쪽의 카드 정렬 예에서는 카드가 등급별로 정렬되어 있고, 수트는 무시되고 있습니다.그러면 원래 목록의 여러 버전이 올바르게 정렬될 수 있습니다.안정된 정렬 알고리즘은 다음 규칙에 따라 이들 중 하나를 선택합니다.두 개의 5개의 카드와 같이 2개의 항목이 동등하게 비교될 경우 상대적인 순서가 유지되므로 입력에서 한쪽이 다른 쪽보다 앞서는 경우에도 출력에서 우선됩니다.
트럼프의 안정된 정렬의 예.카드가 안정된 정렬로 랭크별로 정렬된 경우, 2개의 5s는 원래 정렬된 출력과 동일한 순서로 유지되어야 합니다.안정적이지 않은 정렬로 정렬된 경우 정렬된 출력에서는 5s가 반대 순서로 정렬될 수 있습니다.
정렬은 맞지만 변경되었음을 나타냅니다.따라서 실제 세계에서는 정렬이 정확하더라도 우리가 기대하는 것을 반드시 얻어야 합니다!이것 또한 매우 중요합니다.JavaScript의 자세한 예에 대해서는 Array.protype.sort() - docs:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort 를 참조해 주세요.
지금은 2019년이고, 이 문제를 해결할 수 있는 2019년 방법이 있습니다:)
Object.fromEntries(Object.entries({b: 3, a:8, c:1}).sort())
ES6 - 라이너 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), {} ));난 이거면 돼
/**
* 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;
};
이것은 오래된 질문이지만, Mathias Bynens의 답변에서 힌트를 얻어 오버헤드 없이 현재 객체를 정렬하기 위한 간단한 버전을 만들었습니다.
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();
생각할 거리야.
정렬되지 않은 개체 속성을 표시하는 Visual Studio 디버거에서 유용할 수 있다고 가정합니다.
(function(s) {
var t = {};
Object.keys(s).sort().forEach(function(k) {
t[k] = s[k]
});
return t
})({
b: 2,
a: 1,
c: 3
});
인라인 버전과 동일합니다.
(function(s){var t={};Object.keys(s).sort().forEach(function(k){t[k]=s[k]});return t})({b:2,a:1,c:3})
30개 이상의 답변이 나왔는데 이 문제에 대한 완전한 해결책을 제시하지 못한 것에 대해 저는 매우 놀랐습니다.얕은 솔루션을 가진 사람도 있고 깊이가 있지만 결함이 있는 사람도 있습니다(정의되지 않으면 충돌하고 기능 또는 기호는 json에 있습니다).
완전한 솔루션은 다음과 같습니다.
function sortObject(unordered, sortArrays = false) {
if (!unordered || typeof unordered !== 'object') {
return unordered;
}
if (Array.isArray(unordered)) {
const newArr = unordered.map((item) => sortObject(item, sortArrays));
if (sortArrays) {
newArr.sort();
}
return newArr;
}
const ordered = {};
Object.keys(unordered)
.sort()
.forEach((key) => {
ordered[key] = sortObject(unordered[key], sortArrays);
});
return ordered;
}
const json = {
b: 5,
a: [2, 1],
d: {
b: undefined,
a: null,
c: false,
d: true,
g: '1',
f: [],
h: {},
i: 1n,
j: () => {},
k: Symbol('a')
},
c: [
{
b: 1,
a: 1
}
]
};
console.log(sortObject(json, true));
밑줄 버전:
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
}));P.S. 및 ES6+ 구문도 동일합니다.
function ksort( src ) {
const keys = Object.keys( src );
keys.sort();
return keys.reduce(( target, key ) => {
target[ key ] = src[ key ];
return target;
}, {});
};
여기 한 줄의 솔루션이 있습니다(가장 효율적이지는 않지만, 이 예시와 같이 얇은 객체에 대해서는 엉성한 루프를 사용하기보다는 네이티브 JS 함수를 사용하는 것이 좋습니다).
const unordered = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' }
const ordered = Object.fromEntries(Object.entries(unordered).sort())
console.log(ordered); // a->b->c// if keys are char/string
const sortObject = (obj) => Object.fromEntries(Object.entries(obj).sort( ));
let obj = { c: 3, a: 1 };
obj = sortObject(obj)
// if keys are numbers
const sortObject = (obj) => Object.fromEntries(Object.entries(obj).sort( (a,b)=>a-b ));
let obj = { 3: 'c', 1: 'a' };
obj = sortObject(obj)
재귀 정렬, 중첩된 개체 및 배열
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!'
}
},
]
});
다음은 중첩된 개체와 함께 작동하는 깨끗한 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;
};
로다쉬가 방법이 있다면 더 깨끗할 텐데...
Object.keys(unordered).sort().reduce(
(acc,curr) => ({...acc, [curr]:unordered[curr]})
, {}
)
이미 언급했듯이 오브젝트는 순서가 매겨져 있지 않습니다.
하지만...
다음과 같은 용어가 도움이 될 수 있습니다.
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' ] ]
@sindresorhus에 의한 sort-keys라는 훌륭한 프로젝트가 있습니다.
소스코드는 이쪽에서 확인할 수 있습니다.
https://github.com/sindresorhus/sort-keys
또는 npm과 함께 사용할 수 있습니다.
$ npm install --save sort-keys
여기 그의 레미에서 나온 코드 예도 있다.
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가 있는 경우 이 코드를 사용합니다.
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;
};
lodash를 사용하여 맵을 압축 해제하고 정렬하면 쌍의 첫 번째 값을 입력한 후 다시 zip을 누르면 정렬된 키가 반환됩니다.
값 정렬 기준 쌍 인덱스를 0이 아닌 1로 변경하려는 경우
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}
이것은 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;
}, {});
}
솔루션:
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 런타임은 값이 추가된 순서대로 개체 내부에 저장됩니다.
오브젝트의 속성을 키를 기준으로 정렬하려면 오브젝트를 사용할 수 있습니다.키 배열을 반환하는 키 기능을 수행합니다.다음으로 배열 요소를 정렬하는 Array.protype.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);
}주의: 오브젝트.키는 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;
};
}
자바 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"]
한 줄:
Object.entries(unordered)
.sort(([keyA], [keyB]) => keyA > keyB)
.reduce((obj, [key,value]) => Object.assign(obj, {[key]: value}), {})
const sortObjectByKeys = (object) => Object.fromEntries(
Object.entries(object).sort(([k1], [k2]) => k1 < k2 ? -1 : 1)
)
const object = {b: 'asdsad', c: 'masdas', a: 'dsfdsfsdf' }
const orderedObject = sortObjectByKeys(object)
console.log(orderedObject)개체를 정렬하기 위한 순수 JavaScript 응답입니다.음수를 처리할 수 있는 답변은 이것밖에 없습니다.숫자 객체를 정렬하기 위한 기능입니다.
입력 obj = {1000: {}, -syslog: {}, 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부터 시작하는 새 키가 있는 숫자를 기준으로 정렬된 개체입니다.
언급URL : https://stackoverflow.com/questions/5467129/sort-javascript-object-by-key
'itsource' 카테고리의 다른 글
| Java는 Currying을 지원합니까? (0) | 2022.10.26 |
|---|---|
| python과 return matches의 두 목록을 비교하려면 어떻게 해야 합니까? (0) | 2022.10.26 |
| foreach 루프의 어레이 값 수정 (0) | 2022.10.25 |
| 인코딩 대신 이스케이프를 사용해야 하는 경우URI / 인코딩요구성분? (0) | 2022.10.25 |
| jQuery에 요소가 있는지 확인합니다. (0) | 2022.10.25 |