webdevqa.jp.net

プロパティ値によるJavaScriptオブジェクトのソート

次のようなJavaScriptオブジェクトがあるとします。

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

値に基づいてプロパティを並べ替える方法はありますか?だから私はに終わる

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

それらを配列に移動し、その配列をソートしてから、目的の配列に使用してください。これが解決策です。

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オブジェクトの要素の順序については絶対に想定しないでください。

584
Nosredna

データ構造全体を複製したり、連想配列が必要な場所に配列を使用したりしたくはありません。

これは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
355
Markus R

オブジェクトには任意の数のプロパティを含めることができ、オブジェクトを配列に配置する場合は、必要なオブジェクトプロパティ(数値または文字列)で並べ替えることを選択できます。この配列を考えます:

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/

164
inorganik

完全を期すために、この関数はオブジェクトプロパティの ソートされた配列 を返します。

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()変換を削除することができます。

59
Stano

JavaScriptオブジェクトは定義によって順序付けられていません( ECMAScript言語仕様 、セクション8.6を参照)。言語の仕様では、オブジェクトのプロパティを連続して2回繰り返しても、2回目に同じ順序で出力されることは保証されていません。

順序付けが必要な場合は、配列とArray.prototype.sortメソッドを使用してください。

36
NickFitz

参考のために@marcusRの " - "バージョンの answer

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

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

ここで試してみてください。

28
Jason J. Nathan

ECMAScript 2017では Object.values / Object.entries が導入されました。名前が示すとおり、前者はオブジェクトのすべての値を配列に集約し、後者はオブジェクト全体を[key, value]配列の配列に集約します。 Pythonの 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]]
22
kiding

_ ok _ 、ご存知かもしれませんが、javascriptには sort() という関数があり、配列をソートすることはできますが、objectには何もありません...

その場合、どういうわけかキーの配列を取得して並べ替える必要があります。これは、apiがオブジェクトリテラルよりも多くのネイティブ関数を使用できるためです。簡単な解決策はオブジェクトキーの配列を返す Object.key を使うことです。私はあなたのために仕事をする ES6 関数を作成します、それはネイティブの sort( )JavaScriptの および 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}

このようにしても、メインオブジェクトには触れずに、実際に新しいオブジェクトを取得します。

あなたがあなたのやり方でそれを働かせるためにそれを少し変える必要がある場合に備えて、私はまた機能ステップをより明確にするために下の画像を作成します:

Sorting a javascript object by property value

21
Alireza
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}
8
Vasil Nikolov

高度な配列ソートまたはオブジェクトソート用の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);

デモ

6
Roman Yudin

ES6での更新:繰り返しオブジェクトをソートする必要がある場合(オブジェクトプロパティをソートする必要があると思う理由)、 Map オブジェクトを使用できます。

(キー、値)のペアをソートされた順序で挿入し、for..ofループを実行すると、guaranteeを使用してそれらの順序でループさせることができますそれらを挿入しました

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
6
julianljk

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
}
5
bonna

これは、実際の順序付きオブジェクトとして扱うための簡単な方法です。それがどれくらい遅いかわからない。 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)
2
Carson Wright

念のため、@ 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}
2
esneyderp

多くの類似した便利な機能: 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;
}
1
Shimon Doodkin

値でソートされたオブジェクト(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;
}
1
victorhazbun

もう1つ例を挙げましょう。

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

query-js を使うと、このようにすることができます。

list.keys().select(function(k){
    return {
        key: k,
        value : list[k]
    }
}).orderBy(function(e){ return e.value;});

Query-js here についての紹介記事があります。

0
Rune FS

これを解決するためのもう一つの方法: -

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

//は結果の配列を持つ

0
vivek_nk

とても短くてシンプル!

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

これを試して。あなたのオブジェクトでも、ソートしようとしているものに基づいたプロパティを持っていない場合でも処理されます。

オブジェクトを使ってプロパティを送信して呼び出すだけです。

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;
}
0
Vali Shah
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の要旨 リンク

0
Ankit Sinha

これは、オブジェクトをソートして、ソートされたオブジェクトを取得する方法です。

let sortedObject = {}
sortedObject = Object.keys(yourObject).sort((a, b) => {
                        return yourObject[a] - yourObject[b] 
                    }).reduce((prev, curr, i) => {
                        prev[i] = yourObject[curr]
                        return prev
                    }, {});

あなたの要件に従ってあなたのソート機能をカスタマイズすることができます

0
Ashutosh Ranjan
    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 }
0
Milad Aslani

複数の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) 
0
dino4udo

_ 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'
       } 
    }
0
Paul Walczewski

このためにプラグインを作成しました。ソートされていないオブジェクトである1 argを受け入れ、prop値でソートされたオブジェクトを返します。これは{"Nick": 28, "Bob": 52}...のようなすべての2次元オブジェクトに働きます。

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

0
Alpha G33k

ありがとう、続けて回答してください@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
0
Fury