Javascript – Array basierend auf einem anderen Array sortieren

Ist es möglich, ein Array zu sortieren und neu anzuordnen, das so aussieht:

itemsArray = [ 
    ['Anne', 'a'],
    ['Bob', 'b'],
    ['Henry', 'b'],
    ['Andrew', 'd'],
    ['Jason', 'c'],
    ['Thomas', 'b']
]

um die Anordnung dieses Arrays anzupassen:

sortingArr = [ 'b', 'c', 'b', 'b', 'a', 'd' ]

Leider habe ich keine Ausweise, um den Überblick zu behalten. Ich müsste das Items-Array so priorisieren, dass es dem sortingArr so gut wie möglich entspricht.

Aktualisieren:

Hier ist die Ausgabe, die ich suche:

itemsArray = [    
    ['Bob', 'b'],
    ['Jason', 'c'],
    ['Henry', 'b'],
    ['Thomas', 'b']
    ['Anne', 'a'],
    ['Andrew', 'd'],
]

Irgendeine Idee, wie das gemacht werden kann?

One-Line-Antwort.

itemsArray.sort(function(a, b){  
  return sortingArr.indexOf(a) - sortingArr.indexOf(b);
});

Oder noch kürzer:

itemsArray.sort((a, b) => sortingArr.indexOf(a) - sortingArr.indexOf(b));

Etwas wie:

items = [ 
    ['Anne', 'a'],
    ['Bob', 'b'],
    ['Henry', 'b'],
    ['Andrew', 'd'],
    ['Jason', 'c'],
    ['Thomas', 'b']
]

sorting = [ 'b', 'c', 'b', 'b', 'c', 'd' ];
result = []

sorting.forEach(function(key) {
    var found = false;
    items = items.filter(function(item) {
        if(!found && item[1] == key) {
            result.push(item);
            found = true;
            return false;
        } else 
            return true;
    })
})

result.forEach(function(item) {
    document.writeln(item[0]) /// Bob Jason Henry Thomas Andrew
})

Hier ist ein kürzerer Code, aber er zerstört die sorting Array:

result = items.map(function(item) {
    var n = sorting.indexOf(item[1]);
    sorting[n] = '';
    return [n, item]
}).sort().map(function(j) { return j[1] })

Wenn Sie die native Array-Sortierfunktion verwenden, können Sie einen benutzerdefinierten Komparator übergeben, der beim Sortieren des Arrays verwendet wird. Der Komparator sollte eine negative Zahl zurückgeben, wenn der erste Wert kleiner als der zweite ist, Null, wenn sie gleich sind, und eine positive Zahl, wenn der erste Wert größer ist.

Also, wenn ich das Beispiel, das Sie geben, richtig verstehe, könnten Sie so etwas tun:

function sortFunc(a, b) {
  var sortingArr = [ 'b', 'c', 'b', 'b', 'c', 'd' ];
  return sortingArr.indexOf(a[1]) - sortingArr.indexOf(b[1]);
}

itemsArray.sort(sortFunc);

Fall 1: Ursprüngliche Frage (keine Bibliotheken)

Viele andere Antworten, die funktionieren. 🙂

Fall 2: Ursprüngliche Frage (Lodash.js oder Underscore.js)

var groups = _.groupBy(itemArray, 1);
var result = _.map(sortArray, function (i) { return groups[i].shift(); });

Fall 3: Sortieren Sie Array1, als ob es Array2 wäre

Ich vermute, dass die meisten Leute hierher gekommen sind, um nach einem Äquivalent zu PHPs array_multisort zu suchen (ich habe es getan), also dachte ich, ich würde diese Antwort auch posten. Es gibt ein paar Optionen:

1. Es gibt eine bestehende JS-Implementierung von array_multisort(). Danke an @Adnan für den Hinweis in den Kommentaren. Es ist allerdings ziemlich groß.

2. Schreiben Sie Ihre eigenen. (JSFiddle-Demo)

function refSort (targetData, refData) {
  // Create an array of indices [0, 1, 2, ...N].
  var indices = Object.keys(refData);

  // Sort array of indices according to the reference data.
  indices.sort(function(indexA, indexB) {
    if (refData[indexA] < refData[indexB]) {
      return -1;
    } else if (refData[indexA] > refData[indexB]) {
      return 1;
    }
    return 0;
  });

  // Map array of indices to corresponding values of the target array.
  return indices.map(function(index) {
    return targetData[index];
  });
}

3. Lodash.js oder Unterstrich.js (beides beliebte, kleinere Bibliotheken, die sich auf die Leistung konzentrieren) bieten Hilfsfunktionen, mit denen Sie dies tun können:

    var result = _.chain(sortArray)
      .pairs()
      .sortBy(1)
      .map(function (i) { return itemArray[i[0]]; })
      .value();

… in die (1) das sortArray gruppiert wird [index, value] Paare, (2) sortieren Sie sie nach dem Wert (Sie können hier auch einen Rückruf angeben), (3) ersetzen Sie jedes der Paare durch das Element aus dem itemArray an dem Index, aus dem das Paar stammt.

Dies ist wahrscheinlich zu spät, aber Sie könnten auch eine modifizierte Version des folgenden Codes im ES6-Stil verwenden. Dieser Code ist für Arrays wie:

var arrayToBeSorted = [1,2,3,4,5];
var arrayWithReferenceOrder = [3,5,8,9];

Der eigentliche Betrieb:

arrayToBeSorted = arrayWithReferenceOrder.filter(v => arrayToBeSorted.includes(v));

Die eigentliche Operation in ES5:

arrayToBeSorted = arrayWithReferenceOrder.filter(function(v) {
    return arrayToBeSorted.includes(v);
});

Sollte dazu führen arrayToBeSorted = [3,5]

Zerstört das Referenz-Array nicht.

Warum nicht sowas wie

//array1: array of elements to be sorted
//array2: array with the indexes

array1 = array2.map((object, i) => array1[object]);

Die Kartenfunktion ist möglicherweise nicht in allen Versionen von verfügbar Javascript