값을 기준으로 객체 속성 정렬

다음과 같은 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);

http://jsfiddle.net/xsM5s/16/

완전성을 위해이 함수는 정렬 된 객체 속성 배열 을 반환 합니다.

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 () 변환을 모두 제거 할 수 있습니다.

ECMAScript 2017에서 소개 Object.values / Object.entries합니다. 이름에서 알 수 있듯이 전자는 객체의 모든 값을 배열로 집계하고 후자는 전체 객체를 배열 배열로 집계 [key, value]합니다. 파이썬의 동등 dict.values()하고 dict.items().

이 기능을 사용하면 해시를 정렬 된 객체로 훨씬 쉽게 정렬 할 수 있습니다. 현재로서는 JavaScript 플랫폼 중 일부만 지원 하지만 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]]

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

여기 사용해보십시오!

JavaScript 객체는 정의에 따라 순서가 다릅니다 ( ECMAScript 언어 사양 , 섹션 8.6 참조). 언어 사양은 객체의 속성을 두 번 연속 반복 할 경우 동일한 순서로 두 번째로 나올 것이라고 보장하지도 않습니다.

주문해야 할 것이 있으면 배열과 Array.prototype.sort 메소드를 사용하십시오.

OK , 당신은 자바 스크립트가있다 알 수 있습니다 ) (종류 정렬 배열로 기능하지만, 객체에 대한 아무것도 ...

이 경우 어쨌든 키 배열을 가져 와서 정렬해야합니다. 왜냐하면 배열이 객체 리터럴보다 더 많은 기본 기능을 가지고 있기 때문에 api가 배열에 객체를 가장 많이주는 이유는 빠른 솔로는 Object.key 를 사용 하여 객체 키 배열을 반환합니다. 아래 에서 ES6 함수를 생성 하여 작업을 수행합니다 .Javascript에서 기본 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

고급 배열 또는 객체 정렬을위한 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);

데모

매우 짧고 간단합니다!

var sortedList = {};
Object.keys(list).sort((a,b) => list[a]-list[b]).forEach((key) => {
    sortedList[key] = list[key]; });

나는 다음과 같은 오전 에 의해 주어진 솔루션 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
}

여러 for-loop가없는 값 정렬 (키로 정렬하여 정렬 콜백에서 색인을 "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) 

이것은 실제 순서의 객체로 처리하는 간단한 방법 일 수 있습니다. 얼마나 느린 지 잘 모르겠습니다. 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)

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

누군가가 @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}

let toSort = {a:2323, b: 14, c: 799} 
let sorted = Object.entries(toSort ).sort((a,b)=> a[1]-b[1]) 

산출:

[ [ "b", 14 ], [ "c", 799 ], [ "a", 2323 ] ]

많은 유사하고 유용한 기능 : 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);

    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 }

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

입력은 객체, 출력은 객체, lodash & js 내장 lib를 사용하고 내림차순 또는 오름차순 옵션을 사용하며 입력 객체를 변경하지 않습니다.

예 : 입력 및 출력

{
  "a": 1,
  "b": 4,
  "c": 0,
  "d": 2
}
{
  "b": 4,
  "d": 2,
  "a": 1,
  "c": 0
}

구현

const _ = require('lodash');

const o = { a: 1, b: 4, c: 0, d: 2 };


function sortByValue(object, descending = true) {
  const { max, min } = Math;
  const selector = descending ? max : min;

  const objects = [];
  const cloned = _.clone(object);

  while (!_.isEmpty(cloned)) {
    const selectedValue = selector(...Object.values(cloned));
    const [key, value] = Object.entries(cloned).find(([, value]) => value === selectedValue);

    objects.push({ [key]: value });
    delete cloned[key];
  }

  return _.merge(...objects);
}

const o2 = sortByValue(o);
console.log(JSON.stringify(o2, null, 2));

const arrayOfObjects = [
{name: 'test'},
{name: 'test2'}
]

const order = ['test2', 'test']

const setOrder = (arrayOfObjects, order) =>
    arrayOfObjects.sort((a, b) => {
        if (order.findIndex((i) => i === a.name) < order.findIndex((i) => i === b.name)) {
            return -1;
        }

        if (order.findIndex((i) => i === a.name) > order.findIndex((i) => i === b.name)) {
            return 1;
        }

        return 0;
    });

정렬 내 솔루션 :

let list = {
    "you": 100, 
    "me": 75, 
    "foo": 116, 
    "bar": 15
};

let sorted = Object.entries(list).sort((a,b) => a[1] - b[1]);

for(let element of sorted) {
    console.log(element[0]+ ": " + element[1]);
}

<pre>
function sortObjectByVal(obj){  
var keysSorted = Object.keys(obj).sort(function(a,b){return obj[b]-obj[a]});
var newObj = {};
for(var x of keysSorted){
    newObj[x] = obj[x];
}
return newObj;

}
var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
console.log(sortObjectByVal(list));
</pre>

이것을 해결하는 또 다른 방법 :-

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