Javascript - Array basierend auf einem anderen Array sortieren

Question

Ist es möglich, ein Array, das wie folgt aussieht, zu sortieren und neu anzuordnen?

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 IDs, die ich verfolgen könnte. Ich müsste die Priorität der Elemente-Array, um die sortingArr so nah wie möglich entsprechen.

Aktualisierung:

Hier ist die Ausgabe, nach der ich suche:

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

Haben Sie eine Idee, wie man das machen kann?

Answer 1

Warum nicht etwas 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 Javascript

Answer 2

function sortFunc(a, b) {
  var sortingArr = ["A", "B", "C"];
  return sortingArr.indexOf(a.type) - sortingArr.indexOf(b.type);
}

const itemsArray = [
  {
    type: "A",
  },
  {
    type: "C",
  },
  {
    type: "B",
  },
];
console.log(itemsArray);
itemsArray.sort(sortFunc);
console.log(itemsArray);

Answer 3

ES6

const arrayMap = itemsArray.reduce(
  (accumulator, currentValue) => ({
    ...accumulator,
    [currentValue[1]]: currentValue,
  }),
  {}
);
const result = sortingArr.map(key => arrayMap[key]);

Weitere Beispiele mit verschiedenen Eingabefeldern

Answer 4

Für den Fall, dass Sie dies mit einem Array von Objekten tun müssen, hier ist eine Anpassung von @Durgpal Singhs großartiger Antwort:

const itemsArray = [
  { name: 'Anne', id: 'a' },
  { name: 'Bob', id: 'b' },
  { name: 'Henry', id: 'b' },
  { name: 'Andrew', id: 'd' },
  { name: 'Jason', id: 'c' },
  { name: 'Thomas', id: 'b' }
]

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

Object.keys(itemsArray).sort((a, b) => {
  return sortingArr.indexOf(itemsArray[a].id) - sortingArr.indexOf(itemsArray[b].id);
})

Answer 5

Ich würde ein zwischengeschaltetes Objekt verwenden ( itemsMap ), wodurch eine quadratische Komplexität vermieden wird:

function createItemsMap(itemsArray) { // {"a": ["Anne"], "b": ["Bob", "Henry"], …}
  var itemsMap = {};
  for (var i = 0, item; (item = itemsArray[i]); ++i) {
    (itemsMap[item[1]] || (itemsMap[item[1]] = [])).push(item[0]);
  }
  return itemsMap;
}

function sortByKeys(itemsArray, sortingArr) {
  var itemsMap = createItemsMap(itemsArray), result = [];
  for (var i = 0; i < sortingArr.length; ++i) {
    var key = sortingArr[i];
    result.push([itemsMap[key].shift(), key]);
  }
  return result;
}

Siehe http://jsfiddle.net/eUskE/