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


1334

AJAXを使用して次のオブジェクトを取得し、配列に格納しました。

var homes = [
    {
        "h_id": "3",
        "city": "Dallas",
        "state": "TX",
        "zip": "75201",
        "price": "162500"
    }, {
        "h_id": "4",
        "city": "Bevery Hills",
        "state": "CA",
        "zip": "90210",
        "price": "319250"
    }, {
        "h_id": "5",
        "city": "New York",
        "state": "NY",
        "zip": "00010",
        "price": "962500"
    }
];

JavaScriptのみを使用して、priceプロパティでオブジェクトを昇順 または 降順で並べ替える関数を作成するにはどうすればよいですか?


最も簡単な方法は、ブラウザとノードの両方でネイティブに動作する同形ソート配列モジュールを使用して、あらゆるタイプの入力、計算フィールド、カスタムソート順をサポートすることです。
ロイド

回答:


1674

家を価格の昇順で並べ替えます。

homes.sort(function(a, b) {
    return parseFloat(a.price) - parseFloat(b.price);
});

またはES6バージョンの後:

homes.sort((a, b) => parseFloat(a.price) - parseFloat(b.price));

いくつかのドキュメントはここにあります


184
string1.localeCompare(string2)文字列の比較に使用できます
bradvido 2014年

62
localeCompare()大文字と小文字区別されないことに注意してください。大文字と小文字を区別する場合は、を使用できます(string1 > string2) - (string1 < string2)。ブール値は、差を計算するために整数0および1に強制変換されます。
Don Kirkby、2015年

2
更新をありがとう、@ Pointy、この問題に遭遇したことを覚えていませんが、おそらくここ数年で動作が変更されました。いずれにせよ、localeCompare()ドキュメントでは、大文字と小文字の区別、数値の並べ替え、その他のオプションが必要かどうかを明示的に指定できることが示されています。
Don Kirkby 2017

2
@ sg28 MDNの説明を誤解していると思います。ソート機能が信頼できないと言っているのではなく、安定していないと言っています。なぜこれが混乱を招くのか理解できますが、それが使用に適していないという主張ではありません。ソートアルゴリズムのコンテキストでは、安定という用語には特定の意味があります。つまり、リスト内の「等しい」要素は、入力と同じ順序でソートされます。これは、不安定な(つまり、まだ使用できる状態になっていない)コードのアイデアとはまったく関係ありません。
Stobor

1
都市などの特定の文字列値で並べ替える場合は、次の
ホルヘヴァルヴェルト2018年

675

これは、再利用可能な並べ替え関数を作成し、任意のフィールドで並べ替えることができる、より柔軟なバージョンです。

const sort_by = (field, reverse, primer) => {

  const key = primer ?
    function(x) {
      return primer(x[field])
    } :
    function(x) {
      return x[field]
    };

  reverse = !reverse ? 1 : -1;

  return function(a, b) {
    return a = key(a), b = key(b), reverse * ((a > b) - (b > a));
  }
}


//Now you can sort by any field at will...

const homes=[{h_id:"3",city:"Dallas",state:"TX",zip:"75201",price:"162500"},{h_id:"4",city:"Bevery Hills",state:"CA",zip:"90210",price:"319250"},{h_id:"5",city:"New York",state:"NY",zip:"00010",price:"962500"}];

// Sort by price high to low
console.log(homes.sort(sort_by('price', true, parseInt)));

// Sort by city, case-insensitive, A-Z
console.log(homes.sort(sort_by('city', false, (a) =>  a.toUpperCase()
)));


7
nickb-コードを誤解しています。sort_byO(1)で実行され、リスト内の項目を比較するために組み込みの並べ替え(O(N log N))で使用される関数を返します。全体の複雑さはO(n log n)* O(1)で、これはO(n log n)、またはクイックソートと同じになります。
トリプティク、2011年

1
これに関して私が抱えている問題の1つは、reverse = falseの場合、数値を1,2,3,4 ...として並べ替えるが、文字列はz、y、x ...として並べ替える
Abby

4
小さな機能強化:var key = primer ? function (x) { return primer(x[field]); } : function (x) { return x[field]; }
ErikE、

6
一方で[1,-1][+!!reverse]ルックスはクール、それを行うのは恐ろしいことです。ユーザーがメソッドを適切に呼び出せない場合は、彼を罰し、どうにかしてそれを理解しようとしないでください。
IngoBürk

2
ソースデータを準備した方がよいのではないでしょうか。ソースデータに微調整が必​​要な場合、これにより連続して解析が行われます。
Gerrit Brink、2015年

134

それをソートするには、2つの引数を取るコンパレーター関数を作成する必要があります。次に、そのコンパレーター関数を使用して次のようにソート関数を呼び出します。

// a and b are object elements of your array
function mycomparator(a,b) {
  return parseInt(a.price, 10) - parseInt(b.price, 10);
}
homes.sort(mycomparator);

昇順で並べ替える場合は、マイナス記号の両側の式を切り替えます。


3
そしてここで、実際の代わりに言ってのトピックを説明した資料「それはあまりにも複雑だが、あなたはとにかくそれを理解できないだろう、」です:developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/...
ローランドILLIG

51

誰かがそれを必要とする場合の文字列ソートのために、

const dataArr = {

  "hello": [{
    "id": 114,
    "keyword": "zzzzzz",
    "region": "Sri Lanka",
    "supportGroup": "administrators",
    "category": "Category2"
  }, {
    "id": 115,
    "keyword": "aaaaa",
    "region": "Japan",
    "supportGroup": "developers",
    "category": "Category2"
  }]

};
const sortArray = dataArr['hello'];

console.log(sortArray.sort((a, b) => {
  if (a.region < b.region)
    return -1;
  if (a.region > b.region)
    return 1;
  return 0;
}));


38

ES6準拠のブラウザを使用している場合は、次を使用できます。

昇順と降順の違いは、比較関数によって返される値の符号です。

var ascending = homes.sort((a, b) => Number(a.price) - Number(b.price));
var descending = homes.sort((a, b) => Number(b.price) - Number(a.price));

これが実際のコードスニペットです。

var homes = [{
  "h_id": "3",
  "city": "Dallas",
  "state": "TX",
  "zip": "75201",
  "price": "162500"
}, {
  "h_id": "4",
  "city": "Bevery Hills",
  "state": "CA",
  "zip": "90210",
  "price": "319250"
}, {
  "h_id": "5",
  "city": "New York",
  "state": "NY",
  "zip": "00010",
  "price": "962500"
}];

homes.sort((a, b) => Number(a.price) - Number(b.price));
console.log("ascending", homes);

homes.sort((a, b) => Number(b.price) - Number(a.price));
console.log("descending", homes);


22

あなたはそれをJavascriptでソートしたいですよね?あなたが欲しいのはsort()機能です。この場合、コンパレーター関数を作成してに渡す必要があるため、sort()次のようになります。

function comparator(a, b) {
    return parseInt(a["price"], 10) - parseInt(b["price"], 10);
}

var json = { "homes": [ /* your previous data */ ] };
console.log(json["homes"].sort(comparator));

コンパレータは、配列内のネストされた各ハッシュの1つを取得し、「price」フィールドをチェックして、どちらが高いかを判断します。


21

私はGitHubをお勧めします:Array sortBy- シュワルツ変換sortByを使用するメソッドの最良の実装

しかし今のところ、このアプローチGist:sortBy-old.jsを試してみましょう。
プロパティでオブジェクトを配置できる配列を並べ替えるメソッドを作成してみましょう。

並べ替え関数の作成

var sortBy = (function () {
  var toString = Object.prototype.toString,
      // default parser function
      parse = function (x) { return x; },
      // gets the item to be sorted
      getItem = function (x) {
        var isObject = x != null && typeof x === "object";
        var isProp = isObject && this.prop in x;
        return this.parser(isProp ? x[this.prop] : x);
      };

  /**
   * Sorts an array of elements.
   *
   * @param  {Array} array: the collection to sort
   * @param  {Object} cfg: the configuration options
   * @property {String}   cfg.prop: property name (if it is an Array of objects)
   * @property {Boolean}  cfg.desc: determines whether the sort is descending
   * @property {Function} cfg.parser: function to parse the items to expected type
   * @return {Array}
   */
  return function sortby (array, cfg) {
    if (!(array instanceof Array && array.length)) return [];
    if (toString.call(cfg) !== "[object Object]") cfg = {};
    if (typeof cfg.parser !== "function") cfg.parser = parse;
    cfg.desc = !!cfg.desc ? -1 : 1;
    return array.sort(function (a, b) {
      a = getItem.call(cfg, a);
      b = getItem.call(cfg, b);
      return cfg.desc * (a < b ? -1 : +(a > b));
    });
  };

}());

ソートされていないデータの設定

var data = [
  {date: "2011-11-14T16:30:43Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T17:22:59Z", quantity: 2, total: 90,  tip: 0,   type: "Tab"},
  {date: "2011-11-14T16:28:54Z", quantity: 1, total: 300, tip: 200, type: "visa"},
  {date: "2011-11-14T16:53:41Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T16:48:46Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T17:25:45Z", quantity: 2, total: 200, tip: 0,   type: "cash"},
  {date: "2011-11-31T17:29:52Z", quantity: 1, total: 200, tip: 100, type: "Visa"},
  {date: "2011-11-14T16:58:03Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T16:20:19Z", quantity: 2, total: 190, tip: 100, type: "tab"},
  {date: "2011-11-01T16:17:54Z", quantity: 2, total: 190, tip: 100, type: "tab"},
  {date: "2011-11-14T17:07:21Z", quantity: 2, total: 90,  tip: 0,   type: "tab"},
  {date: "2011-11-14T16:54:06Z", quantity: 1, total: 100, tip: 0,   type: "Cash"}
];

それを使う

次のように配列を配置し"date"ますString

// sort by @date (ascending)
sortBy(data, { prop: "date" });

// expected: first element
// { date: "2011-11-01T16:17:54Z", quantity: 2, total: 190, tip: 100, type: "tab" }

// expected: last element
// { date: "2011-11-31T17:29:52Z", quantity: 1, total: 200, tip: 100, type: "Visa"}

大文字と小文字を区別したくない場合は、parserコールバックを設定します。

// sort by @type (ascending) IGNORING case-sensitive
sortBy(data, {
    prop: "type",
    parser: (t) => t.toUpperCase()
});

// expected: first element
// { date: "2011-11-14T16:54:06Z", quantity: 1, total: 100, tip: 0, type: "Cash" }

// expected: last element
// { date: "2011-11-31T17:29:52Z", quantity: 1, total: 200, tip: 100, type: "Visa" }

"date"フィールドをDateタイプとして変換したい場合:

// sort by @date (descending) AS Date object
sortBy(data, {
    prop: "date",
    desc: true,
    parser: (d) => new Date(d)
});

// expected: first element
// { date: "2011-11-31T17:29:52Z", quantity: 1, total: 200, tip: 100, type: "Visa"}

// expected: last element
// { date: "2011-11-01T16:17:54Z", quantity: 2, total: 190, tip: 100, type: "tab" }

ここであなたはコードで遊ぶことができます: jsbin.com/lesebi

彼のフィードバックによる@Ozeshのおかげで、偽の値を持つプロパティに関連する問題が修正されました。


これは、フィールドがnullのときに壊れるようです。
TSNev 2016

場合にはあなたが数字をソートしていて、オブジェクトの配列の間で「0」に遭遇、あなたは上記のコードブレークことに気づくかもしれません...ここではそのための迅速な修正です:var checkNaN = function (value) { return Number.isNaN(Number(value)) ? 0 : value; } リターン機能(配列、O){:続きます.... a = _getItem.call(o、a); a = checkNaN(a); b = _getItem.call(o、b); b = checkNaN(b); return o.desc *(a <b?-1:+(a> b)); });
Ozesh

18

lodash.sortByを使用しますcommonjsを使用する手順cdnのスクリプトinclude-tagを HTMLの上部に配置することもできます)

var sortBy = require('lodash.sortby');
// or
sortBy = require('lodash').sortBy;

降順

var descendingOrder = sortBy( homes, 'price' ).reverse();

昇順

var ascendingOrder = sortBy( homes, 'price' );

1
またはconst sortBy = require('lodash/sortBy'); let calendars = sortBy(calendarListResponse.items, cal => cal.summary);
mpen 2016年

loadashが最近その名前のOrderByによって変更されたかどうかはわかりませんimport { orderBy } from 'lodash'; ... ... return orderBy ( rows, 'fieldName' ).reverse();
montelof

8

これは、単純な1行のvalueof()ソート関数によって実現できたはずです。デモを表示するには、以下のコードスニペットを実行してください。

var homes = [
    {
        "h_id": "3",
        "city": "Dallas",
        "state": "TX",
        "zip": "75201",
        "price": "162500"
    }, {
        "h_id": "4",
        "city": "Bevery Hills",
        "state": "CA",
        "zip": "90210",
        "price": "319250"
    }, {
        "h_id": "5",
        "city": "New York",
        "state": "NY",
        "zip": "00010",
        "price": "962500"
    }
];

console.log("To sort descending/highest first, use operator '<'");

homes.sort(function(a,b) { return a.price.valueOf() < b.price.valueOf();});

console.log(homes);

console.log("To sort ascending/lowest first, use operator '>'");

homes.sort(function(a,b) { return a.price.valueOf() > b.price.valueOf();});

console.log(homes);


8

私はパーティーに少し遅れましたが、以下は並べ替えのロジックです。

function getSortedData(data, prop, isAsc) {
    return data.sort((a, b) => {
        return (a[prop] < b[prop] ? -1 : 1) * (isAsc ? 1 : -1)
    });
}

6

OPが数値の配列をソートすることを望んでいたことは承知していますが、この質問は文字列に関する同様の質問に対する回答としてマークされています。そのため、上記の回答では、大文字と小文字が重要なテキストの配列を並べ替えることは考慮されていません。ほとんどの回答は文字列値を受け取り、それらを大文字/小文字に変換してから、何らかの方法で並べ替えます。私が遵守する要件は単純です:

  • アルファベット順に並べ替え
  • 同じ単語の大文字の値は小文字の値の前に来る必要があります
  • 同じ文字(A / a、B / b)の値はグループ化する必要があります

私が期待しているのは[ A, a, B, b, C, c ]、上記の答えが返されることA, B, C, a, b, cです。私は実際、これよりもずっと頭を悩ませました(それが、少なくとも1人の人に役立つことを期待してこれを投稿している理由です)。localeCompareマークされた回答のコメントで2人のユーザーが関数に言及している間、私は周りを検索しながら関数に偶然出会うまでそれを知りませんでした。String.prototype.localeCompare()のドキュメントを読んだ後、これを思いついた:

var values = [ "Delta", "charlie", "delta", "Charlie", "Bravo", "alpha", "Alpha", "bravo" ];
var sorted = values.sort((a, b) => a.localeCompare(b, undefined, { caseFirst: "upper" }));
// Result: [ "Alpha", "alpha", "Bravo", "bravo", "Charlie", "charlie", "Delta", "delta" ]

これは、小文字の値の前に大文字の値をソートするように関数に指示します。localeCompare関数の2番目のパラメーターはロケールを定義することですが、そのままにしundefinedておくと、自動的にロケールが計算されます。

これは、オブジェクトの配列をソートする場合も同様に機能します。

var values = [
    { id: 6, title: "Delta" },
    { id: 2, title: "charlie" },
    { id: 3, title: "delta" },
    { id: 1, title: "Charlie" },
    { id: 8, title: "Bravo" },
    { id: 5, title: "alpha" },
    { id: 4, title: "Alpha" },
    { id: 7, title: "bravo" }
];
var sorted = values
    .sort((a, b) => a.title.localeCompare(b.title, undefined, { caseFirst: "upper" }));

5

JavaScript sortメソッドをコールバック関数で使用できます。

function compareASC(homeA, homeB)
{
    return parseFloat(homeA.price) - parseFloat(homeB.price);
}

function compareDESC(homeA, homeB)
{
    return parseFloat(homeB.price) - parseFloat(homeA.price);
}

// Sort ASC
homes.sort(compareASC);

// Sort DESC
homes.sort(compareDESC);

4

上記のすべての回答の集大成です。

フィドルの検証:http : //jsfiddle.net/bobberino/4qqk3/

var sortOn = function (arr, prop, reverse, numeric) {

    // Ensure there's a property
    if (!prop || !arr) {
        return arr
    }

    // Set up sort function
    var sort_by = function (field, rev, primer) {

        // Return the required a,b function
        return function (a, b) {

            // Reset a, b to the field
            a = primer(a[field]), b = primer(b[field]);

            // Do actual sorting, reverse as needed
            return ((a < b) ? -1 : ((a > b) ? 1 : 0)) * (rev ? -1 : 1);
        }

    }

    // Distinguish between numeric and string to prevent 100's from coming before smaller
    // e.g.
    // 1
    // 20
    // 3
    // 4000
    // 50

    if (numeric) {

        // Do sort "in place" with sort_by function
        arr.sort(sort_by(prop, reverse, function (a) {

            // - Force value to a string.
            // - Replace any non numeric characters.
            // - Parse as float to allow 0.02 values.
            return parseFloat(String(a).replace(/[^0-9.-]+/g, ''));

        }));
    } else {

        // Do sort "in place" with sort_by function
        arr.sort(sort_by(prop, reverse, function (a) {

            // - Force value to string.
            return String(a).toUpperCase();

        }));
    }


}

*(rev?-1:1)の意味は何ですか?
TechTurtle 2017

これは、順序を逆にする(昇順と降順)ことです。rev引数がtrueの場合、rev部分は通常の結果を反転するだけです。それ以外の場合は、何もしない1で乗算します。設定すると、結果に-1が乗算され、結果が反転します。
ボブは2017

3

配列をソートするには、コンパレーター関数を定義する必要があります。この関数は、希望するソートパターンまたは順序(昇順または降順)によって常に異なります。

配列を昇順または降順で並べ替え、オブジェクトまたは文字列または数値を含む関数をいくつか作成してみましょう。

function sorterAscending(a,b) {
    return a-b;
}

function sorterDescending(a,b) {
    return b-a;
}

function sorterPriceAsc(a,b) {
    return parseInt(a['price']) - parseInt(b['price']);
}

function sorterPriceDes(a,b) {
    return parseInt(b['price']) - parseInt(b['price']);
}

ソート番号(アルファベット順および昇順):

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();

ソート番号(アルファベット順および降順):

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();
fruits.reverse();

番号を並べ替える(数値および昇順):

var points = [40,100,1,5,25,10];
points.sort(sorterAscending());

並べ替え番号(数値順および降順):

var points = [40,100,1,5,25,10];
points.sort(sorterDescending());

上記のように、希望のキーを持つ配列でsorterPriceAscおよびsorterPriceDesメソッドを使用します。

homes.sort(sorterPriceAsc()) or homes.sort(sorterPriceDes())

3

私はある種の評価と複数のフィールドの並べ替えも行いました:

arr = [
    {type:'C', note:834},
    {type:'D', note:732},
    {type:'D', note:008},
    {type:'F', note:474},
    {type:'P', note:283},
    {type:'P', note:165},
    {type:'X', note:173},
    {type:'Z', note:239},
];

arr.sort(function(a,b){        
    var _a = ((a.type==='C')?'0':(a.type==='P')?'1':'2');
    _a += (a.type.localeCompare(b.type)===-1)?'0':'1';
    _a += (a.note>b.note)?'1':'0';
    var _b = ((b.type==='C')?'0':(b.type==='P')?'1':'2');
    _b += (b.type.localeCompare(a.type)===-1)?'0':'1';
    _b += (b.note>a.note)?'1':'0';
    return parseInt(_a) - parseInt(_b);
});

結果

[
    {"type":"C","note":834},
    {"type":"P","note":165},
    {"type":"P","note":283},
    {"type":"D","note":8},
    {"type":"D","note":732},
    {"type":"F","note":474},
    {"type":"X","note":173},
    {"type":"Z","note":239}
]

3

単一の配列を並べ替えるだけでは少しやり過ぎですが、このプロトタイプ関数を使用すると、構文を使用して、ネストされたキーを含め、任意のキーでJavascript配列を昇順または降順で並べ替えることができdotます。

(function(){
    var keyPaths = [];

    var saveKeyPath = function(path) {
        keyPaths.push({
            sign: (path[0] === '+' || path[0] === '-')? parseInt(path.shift()+1) : 1,
            path: path
        });
    };

    var valueOf = function(object, path) {
        var ptr = object;
        for (var i=0,l=path.length; i<l; i++) ptr = ptr[path[i]];
        return ptr;
    };

    var comparer = function(a, b) {
        for (var i = 0, l = keyPaths.length; i < l; i++) {
            aVal = valueOf(a, keyPaths[i].path);
            bVal = valueOf(b, keyPaths[i].path);
            if (aVal > bVal) return keyPaths[i].sign;
            if (aVal < bVal) return -keyPaths[i].sign;
        }
        return 0;
    };

    Array.prototype.sortBy = function() {
        keyPaths = [];
        for (var i=0,l=arguments.length; i<l; i++) {
            switch (typeof(arguments[i])) {
                case "object": saveKeyPath(arguments[i]); break;
                case "string": saveKeyPath(arguments[i].match(/[+-]|[^.]+/g)); break;
            }
        }
        return this.sort(comparer);
    };    
})();

使用法:

var data = [
    { name: { first: 'Josh', last: 'Jones' }, age: 30 },
    { name: { first: 'Carlos', last: 'Jacques' }, age: 19 },
    { name: { first: 'Carlos', last: 'Dante' }, age: 23 },
    { name: { first: 'Tim', last: 'Marley' }, age: 9 },
    { name: { first: 'Courtney', last: 'Smith' }, age: 27 },
    { name: { first: 'Bob', last: 'Smith' }, age: 30 }
]

data.sortBy('age'); // "Tim Marley(9)", "Carlos Jacques(19)", "Carlos Dante(23)", "Courtney Smith(27)", "Josh Jones(30)", "Bob Smith(30)"

ドット構文または配列構文によるネストされたプロパティによる並べ替え:

data.sortBy('name.first'); // "Bob Smith(30)", "Carlos Dante(23)", "Carlos Jacques(19)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"
data.sortBy(['name', 'first']); // "Bob Smith(30)", "Carlos Dante(23)", "Carlos Jacques(19)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"

複数のキーによるソート:

data.sortBy('name.first', 'age'); // "Bob Smith(30)", "Carlos Jacques(19)", "Carlos Dante(23)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"
data.sortBy('name.first', '-age'); // "Bob Smith(30)", "Carlos Dante(23)", "Carlos Jacques(19)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"

レポをフォークすることができますhttps : //github.com/eneko/Array.sortBy


sortByの簡潔な構文のため、私はこの答えをとても気に入っています。使いやすい–ネストされたフィールドでも–優れたコード可読性を維持しながら。ありがとうございました!
Manfred Urban

3

ECMAScript 6を使用すると、StoBorの答えをさらに簡潔にすることができます。

homes.sort((a, b) => a.price - b.price)

3

価格の降順:

homes.sort((x,y) => {return y.price - x.price})

価格の昇順:

homes.sort((x,y) => {return x.price - y.price})


2

これは、本「JavaScript:The Good Parts」のエレガントな実装のわずかに変更されたバージョンです。

:のこのバージョンby安定していますます。次の連鎖ソートを実行しながら、最初のソートの順序を保持します。

isAscendingパラメータを追加しました。また、それをES6、作者の推奨に従って、標準および「新しい」良品に。

複数のプロパティで昇順、降順、およびチェーンソートをソートできます。

const by = function (name, minor, isAscending=true) {
    const reverseMutliplier = isAscending ? 1 : -1;
    return function (o, p) {
        let a, b;
        let result;
        if (o && p && typeof o === "object" && typeof p === "object") {
            a = o[name];
            b = p[name];
            if (a === b) {
                return typeof minor === 'function' ? minor(o, p) : 0;
            }
            if (typeof a === typeof b) {
                result = a < b ? -1 : 1;
            } else {
                result = typeof a < typeof b ? -1 : 1;
            }
            return result * reverseMutliplier;
        } else {
            throw {
                name: "Error",
                message: "Expected an object when sorting by " + name
            };
        }
    };
};

let s = [
    {first: 'Joe',   last: 'Besser'},
    {first: 'Moe',   last: 'Howard'},
    {first: 'Joe',   last: 'DeRita'},
    {first: 'Shemp', last: 'Howard'},
    {first: 'Larry', last: 'Fine'},
    {first: 'Curly', last: 'Howard'}
];

// Sort by: first ascending, last ascending
s.sort(by("first", by("last")));    
console.log("Sort by: first ascending, last ascending: ", s);     // "[
//     {"first":"Curly","last":"Howard"},
//     {"first":"Joe","last":"Besser"},     <======
//     {"first":"Joe","last":"DeRita"},     <======
//     {"first":"Larry","last":"Fine"},
//     {"first":"Moe","last":"Howard"},
//     {"first":"Shemp","last":"Howard"}
// ]

// Sort by: first ascending, last descending
s.sort(by("first", by("last", 0, false)));  
console.log("sort by: first ascending, last descending: ", s);    // "[
//     {"first":"Curly","last":"Howard"},
//     {"first":"Joe","last":"DeRita"},     <========
//     {"first":"Joe","last":"Besser"},     <========
//     {"first":"Larry","last":"Fine"},
//     {"first":"Moe","last":"Howard"},
//     {"first":"Shemp","last":"Howard"}
// ]


{"first":"Curly","last":"Howard", "property" : {"id" : "1"}}配列のタイプをIDでソートできますか?
Sahu V Kumar 2017

はい。関数を少し変更して、新しいパラメータ、たとえばnestedNameを取り込む必要があります。次にby、name = "property"、nestedName = "id" を使用して呼び出します
mythicalcoder

2

要素値の通常の配列の場合のみ:

function sortArrayOfElements(arrayToSort) {
    function compareElements(a, b) {
        if (a < b)
            return -1;
        if (a > b)
            return 1;
        return 0;
    }

    return arrayToSort.sort(compareElements);
}

e.g. 1:
var array1 = [1,2,545,676,64,2,24]
output : [1, 2, 2, 24, 64, 545, 676]

var array2 = ["v","a",545,676,64,2,"24"]
output: ["a", "v", 2, "24", 64, 545, 676]

オブジェクトの配列の場合:

function sortArrayOfObjects(arrayToSort, key) {
    function compareObjects(a, b) {
        if (a[key] < b[key])
            return -1;
        if (a[key] > b[key])
            return 1;
        return 0;
    }

    return arrayToSort.sort(compareObjects);
}

e.g. 1: var array1= [{"name": "User4", "value": 4},{"name": "User3", "value": 3},{"name": "User2", "value": 2}]

output : [{"name": "User2", "value": 2},{"name": "User3", "value": 3},{"name": "User4", "value": 4}]

2

関数を作成し、以下のコードを使用して入力に基づいて並べ替えます

var homes = [{

    "h_id": "3",
    "city": "Dallas",
    "state": "TX",
    "zip": "75201",
    "price": "162500"

 }, {

    "h_id": "4",
    "city": "Bevery Hills",
    "state": "CA",
    "zip": "90210",
    "price": "319250"

 }, {

    "h_id": "5",
    "city": "New York",
    "state": "NY",
    "zip": "00010",
    "price": "962500"

 }];

 function sortList(list,order){
     if(order=="ASC"){
        return list.sort((a,b)=>{
            return parseFloat(a.price) - parseFloat(b.price);
        })
     }
     else{
        return list.sort((a,b)=>{
            return parseFloat(b.price) - parseFloat(a.price);
        });
     }
 }

 sortList(homes,'DESC');
 console.log(homes);

2

string1.localeCompare(string2)を使用して文字列を比較できます

this.myArray.sort((a,b) => { 
    return a.stringProp.localeCompare(b.stringProp);
});

localCompare大文字小文字が区別されることに注意してください


1

複数の配列オブジェクトフィールドでのソート用。にフィールド名を入力してくださいarrpropよう配列にから、ソート["a","b","c"] する2番目のパラメーターにarrsource実際のソースを渡します。

function SortArrayobject(arrprop,arrsource){
arrprop.forEach(function(i){
arrsource.sort(function(a,b){
return ((a[i] < b[i]) ? -1 : ((a[i] > b[i]) ? 1 : 0));
});
});
return arrsource;
}

1

あなたは2つの機能が必要になります

function desc(a, b) {
 return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
}

function asc(a, b) {
  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
}

次に、これを任意のオブジェクトプロパティに適用できます。

 data.sort((a, b) => desc(parseFloat(a.price), parseFloat(b.price)));

let data = [
    {label: "one", value:10},
    {label: "two", value:5},
    {label: "three", value:1},
];

// sort functions
function desc(a, b) {
 return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
}

function asc(a, b) {
 return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
}

// DESC
data.sort((a, b) => desc(a.value, b.value));

document.body.insertAdjacentHTML(
 'beforeend', 
 '<strong>DESCending sorted</strong><pre>' + JSON.stringify(data) +'</pre>'
);

// ASC
data.sort((a, b) => asc(a.value, b.value));

document.body.insertAdjacentHTML(
 'beforeend', 
 '<strong>ASCending sorted</strong><pre>' + JSON.stringify(data) +'</pre>'
);


0

私は最近、あなたがそれを使いたいのなら、あなたのためにこれを管理するためのユニバーサル関数を書きました。

/**
 * Sorts an object into an order
 *
 * @require jQuery
 *
 * @param object Our JSON object to sort
 * @param type Only alphabetical at the moment
 * @param identifier The array or object key to sort by
 * @param order Ascending or Descending
 *
 * @returns Array
 */
function sortItems(object, type, identifier, order){

    var returnedArray = [];
    var emptiesArray = []; // An array for all of our empty cans

    // Convert the given object to an array
    $.each(object, function(key, object){

        // Store all of our empty cans in their own array
        // Store all other objects in our returned array
        object[identifier] == null ? emptiesArray.push(object) : returnedArray.push(object);

    });

    // Sort the array based on the type given
    switch(type){

        case 'alphabetical':

            returnedArray.sort(function(a, b){

                return(a[identifier] == b[identifier]) ? 0 : (

                    // Sort ascending or descending based on order given
                    order == 'asc' ? a[identifier] > b[identifier] : a[identifier] < b[identifier]

                ) ? 1 : -1;

            });

            break;

        default:

    }

    // Return our sorted array along with the empties at the bottom depending on sort order
    return order == 'asc' ? returnedArray.concat(emptiesArray) : emptiesArray.concat(returnedArray);

}

0
homes.sort(function(a, b){
  var nameA=a.prices.toLowerCase(), nameB=b.prices.toLowerCase()
  if (nameA < nameB) //sort string ascending
    return -1 
  if (nameA > nameB)
    return 1
  return 0 //default return value (no sorting)
})

0

こんにちは、この記事を読んだ後、私のニーズに合わせてsortComparatorを作成しました。複数のjson属性を比較する機能があり、それを共有したいと思います。

このソリューションは昇順の文字列のみを比較しますが、ソリューションをサポートするように各属性に対して簡単に拡張できます:逆順、他のデータ型、ロケールの使用、キャストなど

var homes = [{

    "h_id": "3",
    "city": "Dallas",
    "state": "TX",
    "zip": "75201",
    "price": "162500"

}, {

    "h_id": "4",
    "city": "Bevery Hills",
    "state": "CA",
    "zip": "90210",
    "price": "319250"

}, {

    "h_id": "5",
    "city": "New York",
    "state": "NY",
    "zip": "00010",
    "price": "962500"

}];

// comp = array of attributes to sort
// comp = ['attr1', 'attr2', 'attr3', ...]
function sortComparator(a, b, comp) {
    // Compare the values of the first attribute
    if (a[comp[0]] === b[comp[0]]) {
        // if EQ proceed with the next attributes
        if (comp.length > 1) {
            return sortComparator(a, b, comp.slice(1));
        } else {
            // if no more attributes then return EQ
            return 0;
        }
    } else {
        // return less or great
        return (a[comp[0]] < b[comp[0]] ? -1 : 1)
    }
}

// Sort array homes
homes.sort(function(a, b) {
    return sortComparator(a, b, ['state', 'city', 'zip']);
});

// display the array
homes.forEach(function(home) {
    console.log(home.h_id, home.city, home.state, home.zip, home.price);
});

結果は

$ node sort
4 Bevery Hills CA 90210 319250
5 New York NY 00010 962500
3 Dallas TX 75201 162500

そして別の種類

homes.sort(function(a, b) {
    return sortComparator(a, b, ['city', 'zip']);
});

結果として

$ node sort
4 Bevery Hills CA 90210 319250
3 Dallas TX 75201 162500
5 New York NY 00010 962500

0

簡単なコード:

    var homes = [
        {
            "h_id": "3",
            "city": "Dallas",
            "state": "TX",
            "zip": "75201",
            "price": "162500"
        }, {
            "h_id": "4",
            "city": "Bevery Hills",
            "state": "CA",
            "zip": "90210",
            "price": "319250"
        }, {
            "h_id": "5",
            "city": "New York",
            "state": "NY",
            "zip": "00010",
            "price": "962500"
        }
    ];

    let sortByPrice = homes.sort(function (a, b) 
    {
      return parseFloat(b.price) - parseFloat(a.price);
    });

    for (var i=0; i<sortByPrice.length; i++)
    {
      document.write(sortByPrice[i].h_id+' '+sortByPrice[i].city+' '
       +sortByPrice[i].state+' '
       +sortByPrice[i].zip+' '+sortByPrice[i].price);
      document.write("<br>");
    }


0
 function compareValues(key, order = 'asc') {
  return function innerSort(a, b) {
    if (!a.hasOwnProperty(key) || !b.hasOwnProperty(key)) {
      // property doesn't exist on either object
      return 0;
    }

    const varA = (typeof a[key] === 'string')
      ? a[key].toUpperCase() : a[key];
    const varB = (typeof b[key] === 'string')
      ? b[key].toUpperCase() : b[key];

    let comparison = 0;
    if (varA > varB) {
      comparison = 1;
    } else if (varA < varB) {
      comparison = -1;
    }
    return (
      (order === 'desc') ? (comparison * -1) : comparison
    );
  };
}

http://yazilimsozluk.com/sort-array-in-javascript-by-asc-or-desc

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