const result = sortingArr.map((i) => {
    const pos = itemsArray.findIndex(j => j[1] === i);
    const item = itemsArray[pos];
    itemsArray.splice(pos, 1);
    return item;
  });

如果使用本机数组排序函数，则可以传入一个自定义比较器，以便在对数组排序时使用。如果第一个值小于第二个值，比较器应该返回一个负数;如果它们相等，则返回零;如果第一个值大于第二个值，则返回正数。

所以如果我正确理解了你给出的例子，你可以这样做:

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

itemsArray.sort(sortFunc);

我必须为从API接收到的JSON有效负载这样做，但它不是我想要的顺序。

数组作为参考数组，你想要排序的第二个数组:

var columns = [
    {last_name: "last_name"},
    {first_name: "first_name"},
    {book_description: "book_description"},
    {book_id: "book_id"},
    {book_number: "book_number"},
    {due_date: "due_date"},
    {loaned_out: "loaned_out"}
];

我把它们作为对象是因为它们最终会有其他属性。

创建数组:

 var referenceArray= [];
 for (var key in columns) {
     for (var j in columns[key]){
         referenceArray.push(j);
     }
  }

与数据库中的结果集一起使用。我不知道它的效率如何，但由于我使用的列的数量很少，它工作得很好。

result.forEach((element, index, array) => {                            
    var tr = document.createElement('tr');
    for (var i = 0; i < referenceArray.length - 1; i++) {
        var td = document.createElement('td');
        td.innerHTML = element[referenceArray[i]];
        tr.appendChild(td);

    }
    tableBody.appendChild(tr);
}); 

喜欢的东西:

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

下面是一个较短的代码，但它破坏了排序数组:

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

案例1:原始问题(没有图书馆)

还有很多其他有用的答案。：）

案例2:原始问题(Lodash.js或Underscore.js)

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

情形3:把Array1当作Array2来排序

我猜大多数人来这里是为了寻找PHP的array_multisort(我做过)，所以我想我也会把这个答案贴出来。这里有几个选项:

1. 有一个现有的JS实现array_multisort()。感谢@Adnan在评论中指出这一点。不过，它相当大。

2. 自己写。(JSFiddle演示)

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或Underscore.js(都是关注性能的流行的小型库)提供了帮助函数，允许您这样做:

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

.．.这将(1)将sortArray分组为[index, value]对，(2)根据值对它们排序(你也可以在这里提供一个回调)，(3)将每个对替换为itemArray中该对起源于索引处的项。

我希望我能帮助到一些人，但是如果你试图通过第一个数组的键上的另一个数组对一个对象数组进行排序，例如，你想对这个对象数组进行排序:

const foo = [
  {name: 'currency-question', key: 'value'},
  {name: 'phone-question', key: 'value'},
  {name: 'date-question', key: 'value'},
  {name: 'text-question', key: 'value'}
];        

通过这个数组:

const bar = ['text-question', 'phone-question', 'currency-question', 'date-question'];

你可以这样做:

foo.sort((a, b) => bar.indexOf(a.name) - bar.indexOf(b.name));