Javascriptは2つのフィールドで配列をソートします

88 
grouperArray.sort(function (a, b) {
    var aSize = a.gsize;
    var bSize = b.gsize;
    var aLow = a.glow;
    var bLow = b.glow;
    console.log(aLow + " | " + bLow);      
    return (aSize < bSize) ? -1 : (aSize > bSize) ? 1 : 0;
});

したがって、上記のコードは配列をgsize（最小から最大）で並べ替えます。それはうまくいきます。しかし、gsizeが同じである場合は、グローで並べ替えてください。

ありがとう。

javascript  arrays 
— マーク
ソース
ソート関数は、正、負、またはゼロの結果に反応します。したがって、「returnaSize--bSize」と書くだけです。よりシンプルで読みやすいコードになります。

回答:

107 
grouperArray.sort(function (a, b) {
    var aSize = a.gsize;
    var bSize = b.gsize;
    var aLow = a.glow;
    var bLow = b.glow;
    console.log(aLow + " | " + bLow);

    if(aSize == bSize)
    {
        return (aLow < bLow) ? -1 : (aLow > bLow) ? 1 : 0;
    }
    else
    {
        return (aSize < bSize) ? -1 : 1;
    }
});
— クリス・エバール
ソース
170 
grouperArray.sort(function (a, b) {   
    return a.gsize - b.gsize || a.glow - b.glow;
});

短いバージョン

— anmorozov23
ソース
素晴らしいショートカット！私は一緒に..より複雑なソリューションを入れて助けたstackoverflow.com/questions/6101475/...
— ジョセフ・ポワリエ
3
素敵できれい！それが数字に対してのみ機能する唯一のもの。
— AfanasiiKurakin19年
ここでロジックを説明できますか？！。それは私のために働きましたsort an array with a key's value firstそしてそれからsort the result with another key's value
— KTM
1
@KTMロジックは次のようになります。両方のgsizeが等しい場合、条件の最初の部分は0に等しく、これはfalseと見なされ、条件の2番目の部分が実行されます。
— Scalpweb
@Scalpwebええ:)これは、任意の数のキーを持つ配列を1つずつソートするために機能しますか？！ナイストリック
— KTM
14

これは少し前に尋ねられたことに気づきましたが、私は自分の解決策を追加しようと思いました。

この関数は、ソートメソッドを動的に生成します。並べ替え可能な各子プロパティ名に+/-を付けて、昇順または降順を示すだけです。非常に再利用可能であり、まとめたデータ構造について何も知る必要はありません。ばかげた証拠にすることができますが、必要ではないようです。

function getSortMethod(){
    var _args = Array.prototype.slice.call(arguments);
    return function(a, b){
        for(var x in _args){
            var ax = a[_args[x].substring(1)];
            var bx = b[_args[x].substring(1)];
            var cx;

            ax = typeof ax == "string" ? ax.toLowerCase() : ax / 1;
            bx = typeof bx == "string" ? bx.toLowerCase() : bx / 1;

            if(_args[x].substring(0,1) == "-"){cx = ax; ax = bx; bx = cx;}
            if(ax != bx){return ax < bx ? -1 : 1;}
        }
    }
}

使用例：

items.sort（getSortMethod（ '-price'、 '+ priority'、 '+ name'））;

これは最初にitems最低でソートされprice、同点は最高のアイテムに行きpriorityます。それ以上の結びつきはアイテムによって壊れますname

ここで、itemsは次のような配列です。 

var items = [
    { name: "z - test item", price: "99.99", priority: 0, reviews: 309, rating: 2 },
    { name: "z - test item", price: "1.99", priority: 0, reviews: 11, rating: 0.5 },
    { name: "y - test item", price: "99.99", priority: 1, reviews: 99, rating: 1 },
    { name: "y - test item", price: "0", priority: 1, reviews: 394, rating: 3.5 },
    { name: "x - test item", price: "0", priority: 2, reviews: 249, rating: 0.5 } ...
];

ライブデモ：http： //gregtaff.com/misc/multi_field_sort/

編集：Chromeの問題を修正しました。

— ニルトン
ソース
これは素晴らしいです
— Azure
天才の答え！
— マリウス
typescriptの場合（取得しない場合error TS2554: Expected 0 arguments, but got ..）は、次の構文を使用します：stackoverflow.com/a/4116634/5287221
— Chananel P
6

私は期待して三項演算子は、((aSize < bSize) ? -1 : (aSize > bSize) ? 1 : 0;)あなたが混乱しています。あなたはそれをよりよく理解するためにリンクをチェックするべきです。

それまでは、コードが完全に吹き飛ばされたif / elseです。

grouperArray.sort(function (a, b) {
    if (a.gsize < b.gsize)
    {
        return -1;
    }
    else if (a.gsize > b.gsize)
    {
        return 1;
    }
    else
    {
        if (a.glow < b.glow)
        {
            return -1;
        }
        else if (a.glow > b.glow)
        {
            return 1;
        }
        return 0;
    }
});
— ジョングリーン
ソース
6

これは、任意の数のフィールドで機能する、より一般的なものが必要な場合の実装です。

Array.prototype.sortBy = function (propertyName, sortDirection) {

    var sortArguments = arguments;
    this.sort(function (objA, objB) {

        var result = 0;
        for (var argIndex = 0; argIndex < sortArguments.length && result === 0; argIndex += 2) {

            var propertyName = sortArguments[argIndex];
            result = (objA[propertyName] < objB[propertyName]) ? -1 : (objA[propertyName] > objB[propertyName]) ? 1 : 0;

            //Reverse if sort order is false (DESC)
            result *= !sortArguments[argIndex + 1] ? 1 : -1;
        }
        return result;
    });

}

基本的に、プロパティ名/並べ替え方向はいくつでも指定できます。

var arr = [{
  LastName: "Doe",
  FirstName: "John",
  Age: 28
}, {
  LastName: "Doe",
  FirstName: "Jane",
  Age: 28
}, {
  LastName: "Foo",
  FirstName: "John",
  Age: 30
}];

arr.sortBy("LastName", true, "FirstName", true, "Age", false);
//Will return Jane Doe / John Doe / John Foo

arr.sortBy("Age", false, "LastName", true, "FirstName", false);
//Will return John Foo / John Doe / Jane Doe
— The_Black_Smurf
ソース
3 
grouperArray.sort(function (a, b) {
  var aSize = a.gsize;
  var bSize = b.gsize;
  var aLow = a.glow;
  var bLow = b.glow;
  console.log(aLow + " | " + bLow);      
  return (aSize < bSize) ? -1 : (aSize > bSize) ? 1 : ( (aLow < bLow ) ? -1 : (aLow > bLow ) ? 1 : 0 );
});
— サイレックス
ソース
3 
grouperArray.sort(function (a, b) {
     var aSize = a.gsize;     
     var bSize = b.gsize;     
     var aLow = a.glow;
     var bLow = b.glow;
     console.log(aLow + " | " + bLow);
     return (aSize < bSize) ? -1 : (aSize > bSize) ? 1 : (aLow < bLow) ? -1 : (aLow > bLow) ? 1 : 0); });
— ティムウィリアムズ
ソース
3

これは、再帰を使用して1から無限までの任意の数の並べ替えフィールドで並べ替える実装です。並べ替える結果オブジェクトの配列であるresults配列と、並べ替えを定義する並べ替えオブジェクトの配列であるsorts配列を渡します。各ソートオブジェクトには、ソートするキー名の「select」キーと、「昇順」または「降順」を示す文字列である「order」キーが必要です。 

sortMultiCompare = (a, b, sorts) => {
    let select = sorts[0].select
    let order = sorts[0].order
    if (a[select] < b[select]) {
        return order == 'ascending' ? -1 : 1
    } 
    if (a[select] > b[select]) {
        return order == 'ascending' ? 1 : -1
    }
    if(sorts.length > 1) {
        let remainingSorts = sorts.slice(1)
        return this.sortMultiCompare(a, b, remainingSorts)
    }
    return 0
}

sortResults = (results, sorts) => {
    return results.sort((a, b) => {
        return this.sortMultiCompare(a, b, sorts)
    })
}

// example inputs
const results = [
    {
        "LastName": "Doe",
        "FirstName": "John",
        "MiddleName": "Bill"
    },
    {
        "LastName": "Doe",
        "FirstName": "Jane",
        "MiddleName": "Bill"
    },
    {
        "LastName": "Johnson",
        "FirstName": "Kevin",
        "MiddleName": "Bill"
    }
]

const sorts = [
    {
        "select": "LastName",
        "order": "ascending"
    },
    {
        "select": "FirstName",
        "order": "ascending"
    },
    {
        "select": "MiddleName",
        "order": "ascending"
    }    
]

// call the function like this:
let sortedResults = sortResults(results, sorts)
— ベンジャミンポートマン
ソース
2

複数のキーを使用してこれを行う動的な方法：

  • 並べ替えの各列/キーから一意の値をフィルタリングする
  • 整理するか、逆にする
  • indexOf（value）キーの値に基づいて、各オブジェクトに重み幅ゼロパッドを追加します
  • 計算された重みを使用して並べ替える

ここに画像の説明を入力してください

Object.defineProperty(Array.prototype, 'orderBy', {
value: function(sorts) { 
    sorts.map(sort => {            
        sort.uniques = Array.from(
            new Set(this.map(obj => obj[sort.key]))
        );

        sort.uniques = sort.uniques.sort((a, b) => {
            if (typeof a == 'string') {
                return sort.inverse ? b.localeCompare(a) : a.localeCompare(b);
            }
            else if (typeof a == 'number') {
                return sort.inverse ? (a < b) : (a > b ? 1 : 0);
            }
            else if (typeof a == 'boolean') {
                let x = sort.inverse ? (a === b) ? 0 : a? -1 : 1 : (a === b) ? 0 : a? 1 : -1;
                return x;
            }
            return 0;
        });
    });

    const weightOfObject = (obj) => {
        let weight = "";
        sorts.map(sort => {
            let zeropad = `${sort.uniques.length}`.length;
            weight += sort.uniques.indexOf(obj[sort.key]).toString().padStart(zeropad, '0');
        });
        //obj.weight = weight; // if you need to see weights
        return weight;
    }

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

    return this;
}
});

使用する：

// works with string, number and boolean
let sortered = your_array.orderBy([
    {key: "type", inverse: false}, 
    {key: "title", inverse: false},
    {key: "spot", inverse: false},
    {key: "internal", inverse: true}
]);

ここに画像の説明を入力してください

— レオナルドフィリペ
ソース
1

これは私が使用するものです

function sort(a, b) {
    var _a = "".concat(a.size, a.glow);
    var _b = "".concat(b.size, b.glow);
    return _a < _b;
}

2つの項目を文字列として連結すると、文字列値で並べ替えられます。必要に応じて、_aと_bをparseIntでラップして、数値になることがわかっている場合は、それらを数値として比較できます。

— ブロックループ
ソース
1

特定のアイテムに存在しない可能性のある優先度の並べ替えキーがある場合の解決策は次のとおりです。そのため、フォールバックキーで並べ替える必要があります。

入力データの例（id2は優先度ソートキーです）：

const arr = [
    {id: 1},
    {id: 2, id2: 3},
    {id: 4},
    {id: 3},
    {id: 10, id2: 2},
    {id: 7},
    {id: 6, id2: 1},
    {id: 5},
    {id: 9, id2: 2},
    {id: 8},
];

そして、出力は次のようになります。 

[ { id: 6, id2: 1 },
  { id: 9, id2: 2 },
  { id: 10, id2: 2 },
  { id: 2, id2: 3 },
  { id: 1 },
  { id: 3 },
  { id: 4 },
  { id: 5 },
  { id: 7 },
  { id: 8 } ]

コンパレータ機能は次のようになります。 

arr.sort((a,b) => {
  if(a.id2 || b.id2) {
    if(a.id2 && b.id2) {
      if(a.id2 === b.id2) {
        return a.id - b.id;
      }
      return a.id2 - b.id2;
    }
    return a.id2 ? -1 : 1;
  }
  return a.id - b.id
});

PS .id2の.idがゼロになる可能性がある場合は、を使用することを検討してください。typeof

— デリアズ
ソース
0 
grouperArray.sort(
  function(a,b){return a.gsize == b.gsize ? a.glow - b.glow : a.gsize - b.gsize}
);
— ic3b3rg
ソース
0 
grouperArray.sort(function (a, b) {
    var aSize = a.gsize;
    var bSize = b.gsize;
    if (aSize !== aSize)
        return aSize - bSize;
    return a.glow - b.glow;
});

テストされていませんが、うまくいくはずです。

— Xander
ソース
0

私の場合、通知リストをparam'important 'と' date 'で並べ替えます

  • ステップ1：通知を「重要」と「重要でない」でフィルタリングします

    let importantNotifications = notifications.filter(
        (notification) => notification.isImportant);

  let unImportantNotifications = notifications.filter(
        (notification) => !notification.isImportant);

  • ステップ2：日付で並べ替えます

      sortByDate = (notifications) => {
  return notifications.sort((notificationOne, notificationTwo) => {
    return notificationOne.date - notificationTwo.date;
  });
};

  • ステップ3：それらをマージする

    [
    ...this.sortByDate(importantNotifications),
    ...this.sortByDate(unImportantNotifications),
  ];
— PhạmHùng
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.