値によるオブジェクトプロパティの並べ替え


696

次のようなJavaScriptオブジェクトがある場合:

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

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

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

4
「並べ替え」だけでなく、数値を並べ替えることも重要です。数値はJavascripts Array.sort()メソッドの影響を受けません。つまり、プロパティをソートするためのメソッドを見つけるだけでなく、数値を比較するための独自の関数を記述する必要があります。
サンプソン

106
答えを読む前に:答えはいいえです。ECMAScriptでは、オブジェクトプロパティの順序は標準ではありません。JavaScriptオブジェクトの要素の順序について決して想定してはいけません。オブジェクトは、プロパティの順不同のコレクションです。以下の回答は、配列を使用してソートされたプロパティを「使用」する方法を示していますが、実際にはオブジェクト自体のプロパティの順序を変更することはありません。だから、いいえ、それは不可能です。プロパティが事前にソートされたオブジェクトを作成しても、それらが将来同じ順序で表示されるとは限りません。読む :)。
Govind Rai

3
@GovindRaiはまだですが、実際のフロントエンドアプリケーションでは、IDをキーとしてオブジェクトコレクションをループします。HTMLテンプレートに変換する場合、順序は重要です。あなたはそれらに順序がないと言います、私は彼らがconsole.logging現在のブラウザでそれらを見るときに私が見る正確な順序があると言います。そして、その注文は再注文される可能性があります。あなたがそれらをループするとすぐに、彼らは秩序を持っています。
ProblemsOfSumit

7
@GovindRai:仕様で指定された順序でプロパティにアクセスする手段追加されました。それは良い考えですか?ほとんど間違いなくそうではありません。:-)しかし、それはES2015の時点では存在しています。
TJクラウダー2016

7
2019年の訪問者:このかろうじてupvotedチェックObject.entriesES2017以来の芸術の最もクリーンで読みやすい状態であるベースの答えを:stackoverflow.com/a/37607084/245966
jakub.g

回答:


705

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

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

24
「再構築できます」を「配列を使用してキーの順序を維持し、オブジェクトから値をプルできる」に再公式化できますか?ご存知のように、これは非標準であるだけでなく、この誤った仮定は、現在のChromeだけでなく、より多くのブラウザーによって破られているため、ユーザーに試してみるよう勧めない方がよいでしょう。
Oleg

32
これは、コードのよりコンパクトなバージョンです。Object.keys(maxSpeed).sort(function(a、b){return-(maxSpeed [a]-maxSpeed [b])});
TheBrain

6
@TheBrain:気になる場合keys()は、追加するだけで、IE9 +(およびその他の最新のブラウザー)でのみサポートされます。またkeys()、要素のプロトタイプチェーンから列挙可能なプロパティを除外します(for..inとは異なります)。
MrWhite 2012年

31
_.pairsオブジェクトを[[key1、value1]、[key2、value2]]に変換します。次に、sortを呼び出します。次に_.object、それを呼び出して元に戻します。
Funkodebat 2014

2
私のプロジェクトでは、きれいにマージするためにオブジェクトキーが必要ですが、メタデータがUIを駆動するため、明示的な並べ替えも必要です。プロトタイプチェーンのクロールを回避するために、hasOwnPropertyチェックを追加しただけで、同様のアプローチに従いました。JShackernoon.com/…の
Nathan Agersea

416

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

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


22
これは値ではなくキーでソートしているようですが、これは質問で求められているものではありませんか?
マイケル

27
値でソートされ、キーが表示されます。ただし、キーのみが出力されるため、出力すると値のカウントが失われます。
ハンナ

6
JavaScriptではオブジェクトプロパティの順序が保証されていないため、並べ替えはオブジェクトではなく配列に行う必要があります(これは「連想配列」と呼ばれます)。
クリストファーマイヤーズ2015年

6
忘れずに。keysSorted配列です!オブジェクトではありません!
グリーン

17
.map(key => list[key]);ソートの最後に追加すると、キーだけでなくオブジェクト全体が返されます
James Moran

182

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

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/


1
名前で並べ替えるとsubstr、最初の文字が出力されません。他DianaDebra未定義の順序を持っています。また、byDateソートでは実際にはを使用しますがnum、は使用しませんborn
Lawrence Dol、2014年

これは見た目は良いですが、文字列を比較する場合はそのまま使用できますx.localeCompare(y)
Jemar Jones

2
@JemarJones localCompareは非常に便利な関数のように見えます!IE 10以下、Safari Mobile 9以下など、すべてのブラウザーでサポートされるわけではないことに注意してください。
inorganik

@inorganikはい、これらのブラウザをサポートする必要がある人のための非常に良いメモ
ジョーンズ

1
これは、(いくつかのプロパティを持つオブジェクト)を求めOPないオブジェクトの配列である
ジョアンピメンテルFerreiraの

62

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

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()変換を両方から削除できます。


1
オブジェクトの配列はどうですか?[{name:Will}、{name:Bill}、{name:Ben}]
ハンコック

1
こんにちは、この比較にlocaleCompare関数を使用できます。上記の回答に追加しました。
スタノ

素晴らしいソリューション。文字列ソートには戻りが必要です
pfwd

@Stano正しいシンプルなソリューション。本当にありがとう。
Abrar Hossain

48

ECMAScript 2017はを紹介しObject.values / Object.entriesます。名前が示すように、前者はオブジェクトのすべての値を配列に集約し、後者はオブジェクト全体を配列の[key, value]配列に集約します。dict.values()と同等のPython と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]]

これはおそらく質問のタイトルにどのように答えSorting JavaScript Object by property valueますか?元のオブジェクトを変更し、そこから新しい配列を作成するのではないので、あなたは私が考える質問を誤解しました。
vsync

2
@vsyncこの回答では、受け入れられた回答と同じ結果が得られますが、コードは少なく、一時変数はありません。
ダレン・クック

3
FWIW、この回答はクリーンなafであり、私を助けた唯一のものです。
NetOperator Wibby

つまり、ffだけではなく、つまりchromeでも、オブジェクトを自動的にソートします。wtf
fb

これはキーを保持しないことに注意してください。
Vael Victus

40

参照用の@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
 }), {})

ここでお試しください!


1
動作しませんvar myObj = {"1": {"Value": 40}, "2": {"Value": 10}, "3": {"Value": 30}, "4": {"Value": 20}};
ロハニル

5
OPの質問とこの回答には、ネストされたオブジェクトが含まれていません@Rohanilおそらく、反対票ではなく別の質問をしたいと思うでしょう。さまざまなタイプのネストされたオブジェクトには、明らかにこのソリューションが提供する以上のものが必要です
Jason J. Nathan

注:更新は実際には機能しません。少なくともどこにでもありませんentries。標準によると、オブジェクトはプロパティの順序付けられていないコレクションです。つまり、プロパティ値などで並べ替えた後で新しいオブジェクトを作成しようとすると、プロパティキーの順序が再び未定義になります。たとえば、Chromeはデフォルトでプロパティキーを順序付けしているため、それらを異なる方法で順序付けしようとしても無駄です。唯一のチャンスは、注文の設定に基づいて「インデックス」を取得し、それに応じて元のオブジェクトをトラバースすることです。
ZorgoZ 2018年

はい@ZorgoZ、あなたは正しいです、そして多くの人々がこの投稿でそれを言及しました。ほとんどの場合、この関数は、別の型(JSONなど)に変換する前、または別のreduce関数の前に変換として使用します。その後オブジェクトを変更することが目的の場合、予期しない結果が生じる可能性があります。エンジン全体でこの機能を使用して成功しました。
ジェイソンJ.ネイサン

注:使用したくない sort()Object.entries()
Solvitieg

36

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

注文する必要がある場合は、配列とArray.prototype.sortメソッドを使用します。


4
これについてかなりの議論があったことに注意してください。ほとんどの実装では、要素が追加された順序でリストが保持されます。IIRC、Chromeではありません。Chromeを他の実装に合わせる必要があるかどうかについての議論がありました。私の考えでは、JavaScriptオブジェクトはハッシュであり、順序を想定するべきではありません。Pythonも同じ議論を経て、新しい順序付けされたハッシュのようなリストが最近導入されたと思います。ほとんどのブラウザーでは、オブジェクトを再作成し、ソートされた値によって要素を追加することで、必要なことを実行できます。しかし、そうすべきではありません。
Nosredna 2009

編集。Chromeは通常、順序を維持しますが、常にそうとは限りません。そして、関連するChromiumバグは次のとおり
p

6
そのバグレポートは正当化されておらず、文書化されていない動作に依存しているのはバグのある人です。ECMASCriptセクション8.6をお読みください。「オブジェクトはプロパティの順序付けられていないコレクションです」と明記されています。いくつかの実装ではそのように見えないことに気づき、その実装固有の動作に依存し始めた人は誰もが大きな間違いを犯し、非難を自分から離れようとするべきではありません。Chromeチームに所属していた場合、そのバグレポートに「無効なWontFix」のマークを付けます。
NickFitz 2009

8
EcmaScript 5は、実際に列挙の順序を挿入の順序と定義しています。定義がない場合は、ES3の仕様のバグと見なされます。EcmaScriptの仕様では、誰もが正気とは思わない動作が定義されていることに注意してください。たとえば、仕様の動作では、多くの場合、実行時に構文エラーがスローされ、continue、break、++、-、constなどが正しく使用されません。そのコードに到達する前に例外をスローするエンジンは仕様が間違っている
olliej 2009

4
@olliej-私はこれが正しいとは思いません。仕様には、「プロパティを列挙するメカニズムと順序(最初のアルゴリズムのステップ6.a、2番目のアルゴリズムのステップ7.a)は指定されていません」と記載されています。これは最終ドラフトのPDFの92ページにあります。
ホイットニーランド

25

OK、ご存知かもしれませんが、javascriptには配列をソートするsort()関数がありますが、オブジェクトには何もありません...

したがって、その場合、キーの配列を取得して並べ替える必要があります。これは、APIがほとんどの場合に配列内のオブジェクトを提供する理由です。配列には、オブジェクトリテラルよりも多くのネイティブ関数を使用できるためです。クイックsolotionは、オブジェクトキーの配列を返す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}

この方法でも、メインオブジェクトは変更されず、実際には新しいオブジェクトが取得されます。

また、以下の画像を作成して、関数のステップをより明確にするために、少し変更して自分のやり方で機能させる必要がある場合に備えています。

プロパティ値によるJavaScriptオブジェクトの並べ替え


4
これは、値ではなくキーでソートされます。
ROROROOROROR 2017

@ROROROOROROR、それはそれらがそれほど異なっていないのでそれがどのように機能するかを示すだけですが、すべて良いです、私は値によるソートも追加します
Alireza

1
値による並べ替えは正しくなく、データセットです。に変更c: 3するc: 13と、バラバラになります。
VtoCorleone 2017年

1
@VtoCorleoneこれは単なる自然なソートエラーです。1が最初に来るので、提示されているアルゴリズムの欠陥ではありません。
Michael Ryan Soileau

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

シンプルでパーフェクト!これは質問に答えます。ありがとう。
Ajay Singh

JavaScriptではキーの順序は保証されていないため、キーが整数などの場合、これは失敗します
ParoX

正確に、ParoX。キーが整数型の場合、これは正しく機能しません。
ジョンウォンジン'29

8

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

ES6(ES2015)でも:オブジェクトプロパティに順序があります(または、視点に応じて、定義された順序でアクセスする方法があります)。プロパティ名が文字列であり、配列インデックスのように見えない場合、順序はオブジェクトに追加された順序です。この順序はされないから尊敬されるように指定しfor-inたりObject.keysされてから尊敬されるように定義されたObject.getOwnPropertyNamesプロパティ名の配列にアクセスするための、その他の新しい方法。したがって、これは別のオプションです。
TJクラウダー2016

しかし、「ソート」操作はどこにありますか?それらはまったくソートされていません
Green

@Greenここで強調したいのは、Map実際に並べ替えられた順序で格納できるデータ構造がある(データを並べ替え、ループしてマップに格納する)ことです。オブジェクト。
julianljk 2017

6

高度な配列またはオブジェクトの並べ替えには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

とても短くて簡単です!

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

5

私は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
}

4

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


2

これは、実際に順序付けられたオブジェクトとしてそれを処理する簡単な方法かもしれません。それがどれほど遅いかわからない。また、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
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}]


2

念のために、@ 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
あなたはその中で課題を返しています、それmapforEachより良いでしょう
DiegoRBaquero

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

1

多くの類似した便利な関数: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

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

次にもう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
    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 }

1

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

1

入力はオブジェクト、出力はオブジェクト、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));

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

1

ソートを使用した私のソリューション:

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

コードをコードとしてフォーマットしてください
Itamar Mushkin

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>

1
Stackoverflowへようこそ。あなたが提供した答えに加えて、これが問題を修正する理由と方法の簡単な説明を提供することを検討してください。
jtate

0

これを解決する別の方法:-

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は結果配列を持ちます


0

ありがとう、@ 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

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

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

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;
}
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.