속성 값을 기준으로 JavaScript 개체 정렬
다음과 같은 JavaScript 객체가있는 경우 :
var list = {
"you": 100,
"me": 75,
"foo": 116,
"bar": 15
};
값을 기준으로 속성을 정렬하는 방법이 있습니까? 그래서 나는
list = {
"bar": 15,
"me": 75,
"you": 100,
"foo": 116
};
배열로 이동하고 해당 배열을 정렬 한 다음 해당 배열을 용도에 맞게 사용하십시오. 해결책은 다음과 같습니다.
var maxSpeed = {
car: 300,
bike: 60,
motorbike: 200,
airplane: 1000,
helicopter: 400,
rocket: 8 * 60 * 60
};
var sortable = [];
for (var vehicle in maxSpeed) {
sortable.push([vehicle, maxSpeed[vehicle]]);
}
sortable.sort(function(a, b) {
return a[1] - b[1];
});
//[["bike", 60], ["motorbike", 200], ["car", 300],
//["helicopter", 400], ["airplane", 1000], ["rocket", 28800]]
배열이 있으면 원하는 순서대로 배열에서 객체를 다시 빌드하여 설정 한 작업을 정확하게 수행 할 수 있습니다. 그것은 내가 아는 모든 브라우저에서 작동하지만 구현상의 특성에 따라 달라지며 언제든지 중단 될 수 있습니다. JavaScript 개체의 요소 순서에 대해 가정해서는 안됩니다.
var objSorted = {}
sortable.forEach(function(item){
objSorted[item[0]]=item[1]
})
전체 데이터 구조를 복제하거나 연관 배열이 필요한 배열을 사용하고 싶지 않습니다.
다음은 bonna와 동일한 작업을 수행하는 또 다른 방법입니다.
var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
keysSorted = Object.keys(list).sort(function(a,b){return list[a]-list[b]})
console.log(keysSorted); // bar,me,you,foo객체는 원하는만큼의 속성을 가질 수 있으며 객체를 배열에 넣는 경우 원하는 객체 속성 (숫자 또는 문자열)별로 정렬하도록 선택할 수 있습니다. 다음 배열을 고려하십시오.
var arrayOfObjects = [
{
name: 'Diana',
born: 1373925600000, // Mon, Jul 15 2013
num: 4,
sex: 'female'
},
{
name: 'Beyonce',
born: 1366832953000, // Wed, Apr 24 2013
num: 2,
sex: 'female'
},
{
name: 'Albert',
born: 1370288700000, // Mon, Jun 3 2013
num: 3,
sex: 'male'
},
{
name: 'Doris',
born: 1354412087000, // Sat, Dec 1 2012
num: 1,
sex: 'female'
}
];
생년월일, 가장 오래된 날짜순으로 정렬
// use slice() to copy the array and not just make a reference
var byDate = arrayOfObjects.slice(0);
byDate.sort(function(a,b) {
return a.born - b.born;
});
console.log('by date:');
console.log(byDate);
이름으로 분류하다
var byName = arrayOfObjects.slice(0);
byName.sort(function(a,b) {
var x = a.name.toLowerCase();
var y = b.name.toLowerCase();
return x < y ? -1 : x > y ? 1 : 0;
});
console.log('by name:');
console.log(byName);
완전성을 위해이 함수는 정렬 된 객체 속성 배열 을 반환 합니다.
function sortObject(obj) {
var arr = [];
for (var prop in obj) {
if (obj.hasOwnProperty(prop)) {
arr.push({
'key': prop,
'value': obj[prop]
});
}
}
arr.sort(function(a, b) { return a.value - b.value; });
//arr.sort(function(a, b) { a.value.toLowerCase().localeCompare(b.value.toLowerCase()); }); //use this to sort as strings
return arr; // returns array
}
var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
var arr = sortObject(list);
console.log(arr); // [{key:"bar", value:15}, {key:"me", value:75}, {key:"you", value:100}, {key:"foo", value:116}]
위의 코드가있는 Jsfiddle은 여기에 있습니다 . 이 솔루션은 이 문서를 기반으로 합니다 .
문자열 정렬을위한 업데이트 된 바이올린이 여기에 있습니다. 대소 문자 구분 문자열 비교를 위해 추가 .toLowerCase () 변환을 모두 제거 할 수 있습니다.
JavaScript 객체는 정의에 따라 정렬되지 않습니다 ( ECMAScript 언어 사양 , 섹션 8.6 참조). 언어 사양은 객체의 속성을 연속으로 두 번 반복하면 두 번째에도 동일한 순서로 나올 것이라고 보장하지 않습니다.
주문이 필요한 경우 배열과 Array.prototype.sort 메서드를 사용하십시오.
참조를위한 @marcusR의 답변 의 "화살표"버전
var myObj = {"you": 100, "me": 75, "foo": 116, "bar": 15};
keysSorted = Object.keys(myObj).sort((a,b) => myObj[a]-myObj[b])
alert(keysSorted); // bar,me,you,foo
업데이트 : 2017 년 4 월 - myObj위에 정의 된 정렬 된 개체를 반환합니다 .
Object
.keys(myObj)
.sort((a, b) => myObj[a]-myObj[b])
.reduce((_sortedObj, key) => ({
..._sortedObj,
[key]: myObj[key]
}), {})
업데이트 : 2018 년 10 월 -Object.entries 버전
Object
.entries(myObj)
.sort()
.reduce((_sortedObj, [k,v]) => ({
..._sortedObj,
[k]: v
}), {})
ECMAScript 2017은 Object.values / Object.entries. 이름에서 알 수 있듯이 전자는 개체의 모든 값을 배열로 집계하고 후자는 전체 개체를 배열의 [key, value]배열 로 집계 합니다. Python의 dict.values()및 dict.items().
이 기능을 사용하면 해시를 정렬 된 개체로 훨씬 쉽게 정렬 할 수 있습니다. 현재로서는 자바 스크립트 플랫폼의 일부만 지원 하지만 Firefox 47 이상에서 사용해 볼 수 있습니다.
let obj = {"you": 100, "me": 75, "foo": 116, "bar": 15};
let entries = Object.entries(obj);
// [["you",100],["me",75],["foo",116],["bar",15]]
let sorted = entries.sort((a, b) => a[1] - b[1]);
// [["bar",15],["me",75],["you",100],["foo",116]]
OK , 아시다시피, 자바 스크립트가 일종의 () 정렬 배열로 기능하지만, 객체에 대한 아무것도 ...
따라서이 경우 어떻게 든 키의 배열을 가져 와서 정렬해야합니다. 그래서 api가 대부분의 시간에 객체를 배열로 제공하는 이유입니다. Array는 객체 리터럴보다 더 많은 기본 함수를 가지고 있기 때문입니다. 빠른 솔로 션은 객체 키의 배열을 반환하는 Object.key 를 사용하고 있습니다. 아래에서 작업을 수행하는 ES6 함수를 만들고 자바 스크립트에서 네이티브 sort () 및 reduce () 함수를 사용합니다.
function sortObject(obj) {
return Object.keys(obj)
.sort().reduce((a, v) => {
a[v] = obj[v];
return a; }, {});
}
이제 다음과 같이 사용할 수 있습니다.
let myObject = {a: 1, c: 3, e: 5, b: 2, d: 4};
let sortedMyObject = sortObject(myObject);
sortedMyObject를 확인하면 다음과 같이 키별로 정렬 된 결과를 볼 수 있습니다.
{a: 1, b: 2, c: 3, d: 4, e: 5}
또한 이렇게하면 메인 오브젝트는 건드리지 않고 실제로 새로운 오브젝트를 얻습니다.
또한 아래 이미지를 만들어 기능 단계를보다 명확하게 만들었습니다.
var list = {
"you": 100,
"me": 75,
"foo": 116,
"bar": 15
};
function sortAssocObject(list) {
var sortable = [];
for (var key in list) {
sortable.push([key, list[key]]);
}
// [["you",100],["me",75],["foo",116],["bar",15]]
sortable.sort(function(a, b) {
return (a[1] < b[1] ? -1 : (a[1] > b[1] ? 1 : 0));
});
// [["bar",15],["me",75],["you",100],["foo",116]]
var orderedList = {};
for (var idx in sortable) {
orderedList[sortable[idx][0]] = sortable[idx][1];
}
return orderedList;
}
sortAssocObject(list);
// {bar: 15, me: 75, you: 100, foo: 116}
ES6으로 업데이트 : 반복 할 정렬 된 개체가있는 경우 (이것이 개체 속성을 정렬하려는 이유입니다) Map 개체를 사용할 수 있습니다 .
당신은 정렬 된 순서대로 (키, 값) 쌍을 삽입 할 수 있습니다 다음 일을 for..of반복하는 것입니다 보장 당신이 그들을 삽입 순서대로 루프를 가진
var myMap = new Map();
myMap.set(0, "zero");
myMap.set(1, "one");
for (var [key, value] of myMap) {
console.log(key + " = " + value);
}
// 0 = zero
// 1 = one
나는 slebetman이 제공 한 솔루션을 따르고 있지만 (모든 세부 사항을 읽으십시오) 개체가 중첩되지 않았기 때문에 조정되었습니다.
// First create the array of keys/values so that we can sort it:
var sort_array = [];
for (var key in list) {
sort_array.push({key:key,value:list[key]});
}
// Now sort it:
sort_array.sort(function(x,y){return x.value - y.value});
// Now process that object with it:
for (var i=0;i<sort_array.length;i++) {
var item = list[sort_array[i].key];
// now do stuff with each item
}
고급 배열 또는 객체 정렬을위한 Underscore.js 또는 Lodash.js
var data={
"models": {
"LTI": [
"TX"
],
"Carado": [
"A",
"T",
"A(пасс)",
"A(груз)",
"T(пасс)",
"T(груз)",
"A",
"T"
],
"SPARK": [
"SP110C 2",
"sp150r 18"
],
"Autobianchi": [
"A112"
]
}
};
var arr=[],
obj={};
for(var i in data.models){
arr.push([i, _.sortBy(data.models[i],function (el){return el;})]);
}
arr=_.sortBy(arr,function (el){
return el[0];
});
_.map(arr,function (el){return obj[el[0]]=el[1];});
console.log(obj);
이것은 실제 주문 된 객체로 처리하는 간단한 방법 일 수 있습니다. 얼마나 느린 지 잘 모르겠습니다. while 루프를 사용하면 더 좋을 수도 있습니다.
Object.sortByKeys = function(myObj){
var keys = Object.keys(myObj)
keys.sort()
var sortedObject = Object()
for(i in keys){
key = keys[i]
sortedObject[key]=myObj[key]
}
return sortedObject
}
그런 다음이 반전 기능을 http://nelsonwells.net/2011/10/swap-object-key-and-values-in-javascript/ 에서 찾았습니다.
Object.invert = function (obj) {
var new_obj = {};
for (var prop in obj) {
if(obj.hasOwnProperty(prop)) {
new_obj[obj[prop]] = prop;
}
}
return new_obj;
};
그래서
var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
var invertedList = Object.invert(list)
var invertedOrderedList = Object.sortByKeys(invertedList)
var orderedList = Object.invert(invertedOrderedList)
누군가가 @Markus R 및 @James Moran 주석의 코드 참조를 사용하여 객체 (키 및 값 포함)를 유지하려는 경우 다음을 사용하십시오.
var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
var newO = {};
Object.keys(list).sort(function(a,b){return list[a]-list[b]})
.map(key => newO[key] = list[key]);
console.log(newO); // {bar: 15, me: 75, you: 100, foo: 116}
여러 for 루프가없는 값 정렬 (키별로 정렬하려면 정렬 콜백의 인덱스가 "0"으로 변경됨)
const list = {
"you": 100,
"me": 75,
"foo": 116,
"bar": 15
};
let sorted = Object.fromEntries(
Object.entries(list).sort( (a,b) => a[1] - b[1] )
)
console.log('Sorted object: ', sorted) 유사하고 유용한 많은 기능 : https://github.com/shimondoodkin/groupbyfunctions/
function sortobj(obj)
{
var keys=Object.keys(obj);
var kva= keys.map(function(k,i)
{
return [k,obj[k]];
});
kva.sort(function(a,b){
if(a[1]>b[1]) return -1;if(a[1]<b[1]) return 1;
return 0
});
var o={}
kva.forEach(function(a){ o[a[0]]=a[1]})
return o;
}
function sortobjkey(obj,key)
{
var keys=Object.keys(obj);
var kva= keys.map(function(k,i)
{
return [k,obj[k]];
});
kva.sort(function(a,b){
k=key; if(a[1][k]>b[1][k]) return -1;if(a[1][k]<b[1][k]) return 1;
return 0
});
var o={}
kva.forEach(function(a){ o[a[0]]=a[1]})
return o;
}
값별로 정렬 된 개체 (DESC)
function sortObject(list) {
var sortable = [];
for (var key in list) {
sortable.push([key, list[key]]);
}
sortable.sort(function(a, b) {
return (a[1] > b[1] ? -1 : (a[1] < b[1] ? 1 : 0));
});
var orderedList = {};
for (var i = 0; i < sortable.length; i++) {
orderedList[sortable[i][0]] = sortable[i][1];
}
return orderedList;
}
여기에 또 하나의 예가 있습니다.
function sortObject(obj) {
var arr = [];
var prop;
for (prop in obj) {
if (obj.hasOwnProperty(prop)) {
arr.push({
'key': prop,
'value': obj[prop]
});
}
}
arr.sort(function(a, b) {
return a.value - b.value;
});
return arr; // returns array
}
var list = {
car: 300,
bike: 60,
motorbike: 200,
airplane: 1000,
helicopter: 400,
rocket: 8 * 60 * 60
};
var arr = sortObject(list);
console.log(arr);a = { b: 1, p: 8, c: 2, g: 1 }
Object.keys(a)
.sort((c,b) => {
return a[b]-a[c]
})
.reduce((acc, cur) => {
let o = {}
o[cur] = a[cur]
acc.push(o)
return acc
} , [])
출력 = [{p : 8}, {c : 2}, {b : 1}, {g : 1}]
var list = {
"you": 100,
"me": 75,
"foo": 116,
"bar": 15
};
var tmpList = {};
while (Object.keys(list).length) {
var key = Object.keys(list).reduce((a, b) => list[a] > list[b] ? a : b);
tmpList[key] = list[key];
delete list[key];
}
list = tmpList;
console.log(list); // { foo: 116, you: 100, me: 75, bar: 15 }
매우 짧고 간단합니다!
var sortedList = {};
Object.keys(list).sort((a,b) => list[a]-list[b]).forEach((key) => {
sortedList[key] = list[key]; });
이것을 해결하는 또 다른 방법 :-
var res = [{"s1":5},{"s2":3},{"s3":8}].sort(function(obj1,obj2){
var prop1;
var prop2;
for(prop in obj1) {
prop1=prop;
}
for(prop in obj2) {
prop2=prop;
}
//the above two for loops will iterate only once because we use it to find the key
return obj1[prop1]-obj2[prop2];
});
// res 는 결과 배열을 갖습니다.
감사합니다. @Nosredna에 계속 답변하십시오.
이제 객체를 배열로 변환 한 다음 배열을 정렬해야한다는 것을 이해했습니다. 이것은 문자열로 배열 (또는 배열로 변환 된 객체)을 정렬하는 데 유용합니다.
Object {6: Object, 7: Object, 8: Object, 9: Object, 10: Object, 11: Object, 12: Object}
6: Object
id: "6"
name: "PhD"
obe_service_type_id: "2"
__proto__: Object
7: Object
id: "7"
name: "BVC (BPTC)"
obe_service_type_id: "2"
__proto__: Object
//Sort options
var sortable = [];
for (var vehicle in options)
sortable.push([vehicle, options[vehicle]]);
sortable.sort(function(a, b) {
return a[1].name < b[1].name ? -1 : 1;
});
//sortable => prints
[Array[2], Array[2], Array[2], Array[2], Array[2], Array[2], Array[2]]
0: Array[2]
0: "11"
1: Object
id: "11"
name: "AS/A2"
obe_service_type_id: "2"
__proto__: Object
length: 2
__proto__: Array[0]
1: Array[2]
0: "7"
1: Object
id: "7"
name: "BVC (BPTC)"
obe_service_type_id: "2"
__proto__: Object
length: 2
이 시도. 심지어 당신이 정렬하려는 속성을 가지고 있지 않은 객체도 처리 될 것입니다.
객체와 함께 속성을 보내서 호출하십시오.
var sortObjectByProperty = function(property,object){
console.time("Sorting");
var sortedList = [];
emptyProperty = [];
tempObject = [];
nullProperty = [];
$.each(object,function(index,entry){
if(entry.hasOwnProperty(property)){
var propertyValue = entry[property];
if(propertyValue!="" && propertyValue!=null){
sortedList.push({key:propertyValue.toLowerCase().trim(),value:entry});
}else{
emptyProperty.push(entry);
}
}else{
nullProperty.push(entry);
}
});
sortedList.sort(function(a,b){
return a.key < b.key ? -1 : 1;
//return a.key < b.key?-1:1; // Asc
//return a.key < b.key?1:-1; // Desc
});
$.each(sortedList,function(key,entry){
tempObject[tempObject.length] = entry.value;
});
if(emptyProperty.length>0){
tempObject.concat(emptyProperty);
}
if(nullProperty.length>0){
tempObject.concat(nullProperty);
}
console.timeEnd("Sorting");
return tempObject;
}
나는 이것을 위해 플러그인을 만들었고, 정렬되지 않은 객체 인 1 개의 arg를 받아들이고, prop 값으로 정렬 된 객체를 반환합니다. 이것은 다음과 같은 모든 2 차원 객체에서 작동합니다 {"Nick": 28, "Bob": 52}.
var sloppyObj = {
'C': 78,
'A': 3,
'B': 4
};
// Extend object to support sort method
function sortObj(obj) {
"use strict";
function Obj2Array(obj) {
var newObj = [];
for (var key in obj) {
if (!obj.hasOwnProperty(key)) return;
var value = [key, obj[key]];
newObj.push(value);
}
return newObj;
}
var sortedArray = Obj2Array(obj).sort(function(a, b) {
if (a[1] < b[1]) return -1;
if (a[1] > b[1]) return 1;
return 0;
});
function recreateSortedObject(targ) {
var sortedObj = {};
for (var i = 0; i < targ.length; i++) {
sortedObj[targ[i][0]] = targ[i][1];
}
return sortedObj;
}
return recreateSortedObject(sortedArray);
}
var sortedObj = sortObj(sloppyObj);
alert(JSON.stringify(sortedObj));
다음은 예상대로 작동하는 함수의 데모입니다. http://codepen.io/nicholasabrams/pen/RWRqve?editors=001
query-js 를 사용하면 다음 과 같이 할 수 있습니다.
list.keys().select(function(k){
return {
key: k,
value : list[k]
}
}).orderBy(function(e){ return e.value;});
여기 에서 query-js에 대한 소개 기사를 찾을 수 있습니다.
위의 답변을 찾을 수 없으며 SMALL 일 수 있으며 중첩 된 객체 (배열 아님)를 지원 하므로 내 자신의 것을 작성했습니다. :) 문자열과 정수 모두에서 작동합니다.
function sortObjectProperties(obj, sortValue){
var keysSorted = Object.keys(obj).sort(function(a,b){return obj[a][sortValue]-obj[b][sortValue]});
var objSorted = {};
for(var i = 0; i < keysSorted.length; i++){
objSorted[keysSorted[i]] = obj[keysSorted[i]];
}
return objSorted;
}
용법:
/* sample object with unsorder properties, that we want to sort by
their "customValue" property */
var objUnsorted = {
prop1 : {
customValue : 'ZZ'
},
prop2 : {
customValue : 'AA'
}
}
// call the function, passing object and property with it should be sorted out
var objSorted = sortObjectProperties(objUnsorted, 'customValue');
// now console.log(objSorted) will return:
{
prop2 : {
customValue : 'AA'
},
prop1 : {
customValue : 'ZZ'
}
}
여기에 객체를 정렬하고 정렬 된 객체를 얻는 방법이 있습니다.
let sortedObject = {}
sortedObject = Object.keys(yourObject).sort((a, b) => {
return yourObject[a] - yourObject[b]
}).reduce((prev, curr, i) => {
prev[i] = yourObject[curr]
return prev
}, {});
요구 사항에 따라 정렬 기능을 사용자 지정할 수 있습니다.
function sortObjByValue(list){
var sortedObj = {}
Object.keys(list)
.map(key => [key, list[key]])
.sort((a,b) => a[1] > b[1] ? 1 : a[1] < b[1] ? -1 : 0)
.forEach(data => sortedObj[data[0]] = data[1]);
return sortedObj;
}
sortObjByValue(list);
Github Gist 링크
TypeScript
다음 함수는 값 또는 값의 속성별로 개체를 정렬합니다. TypeScript를 사용하지 않는 경우 유형 정보를 제거하여 JavaScript로 변환 할 수 있습니다.
/**
* Represents an associative array of a same type.
*/
interface Dictionary<T> {
[key: string]: T;
}
/**
* Sorts an object (dictionary) by value or property of value and returns
* the sorted result as a Map object to preserve the sort order.
*/
function sort<TValue>(
obj: Dictionary<TValue>,
valSelector: (val: TValue) => number | string,
) {
const sortedEntries = Object.entries(obj)
.sort((a, b) =>
valSelector(a[1]) > valSelector(b[1]) ? 1 :
valSelector(a[1]) < valSelector(b[1]) ? -1 : 0);
return new Map(sortedEntries);
}
용법
var list = {
"one": { height: 100, weight: 15 },
"two": { height: 75, weight: 12 },
"three": { height: 116, weight: 9 },
"four": { height: 15, weight: 10 },
};
var sortedMap = sort(list, val => val.height);
JavaScript 객체의 키 순서는 보장되지 않으므로 Map정렬 순서를 유지 하는 객체 로 결과를 정렬하고 반환합니다 .
다시 Object로 변환하려면 다음을 수행하십시오.
var sortedObj = {} as any;
sortedMap.forEach((v,k) => { sortedObj[k] = v });
참고 URL : https://stackoverflow.com/questions/1069666/sorting-javascript-object-by-property-value
'Nice programing' 카테고리의 다른 글
| MongoDB를 통해 CouchDB를 사용하거나 그 반대의 경우 (0) | 2020.10.02 |
|---|---|
| JavaScript 함수를 매개 변수로 전달 (0) | 2020.10.02 |
| 자바 스크립트로 오디오를 재생 하시겠습니까? (0) | 2020.10.02 |
| 모의 메서드가 전달 된 인수를 반환하도록 만들기 (0) | 2020.10.02 |
| 벡터에 벡터 추가 (0) | 2020.10.02 |