根据一个数组对多个数组进行排序

如何解决根据一个数组对多个数组进行排序

我有一个javascript数组数组，每个内部数组的长度相等。我想按时间顺序对内部数组之一进行排序（其成员都是数字），并且我希望其他数组以相同的方式重新排序。例如

我们从这里开始：

[[2,3,1],["deux","trois","un"],["zwei","drei","eins"]]

我想要的结果是：

[[1,2,3],["un","deux","trois"],["eins","zwei","drei"]]

我在以下方面尝试了不同的变体，但没有运气：

arr.sort((a,b) => a[0] - b[0])

我得到的正是我所投入的东西！

解决方法

这应该可以解决问题，我们应该获取数字数组的新索引，然后将相同的新索引应用于非数字数组：

const arrays = [
  [2,3,1],["deux","trois","un"],["zwei","drei","eins"],];
const [arrNbrs] = arrays;

const newIndexes = [...arrNbrs].sort().map((nbr) => arrNbrs.indexOf(nbr));

const sortedArrays = arrays.map((subArray) =>
  subArray.map((_,index) => subArray[newIndexes[index]])
);

console.log("sortedArrays",sortedArrays);

,

您可以得到一个排序索引数组和map排序数组。

const
    arrays = [[2,"eins"]],sorted = arrays.map(
        (indices => a => indices.map(i => a[i]))
        ([...arrays[0].keys()].sort((a,b) => arrays[0][a] - arrays[0][b]))
    );

console.log(sorted);

.as-console-wrapper { max-height: 100% !important; top: 0; }

一个功能。

const
    sortNumbers = (a,b) => a - b,sortABC = (a,b) => a.localeCompare(b),sortArray = (arrays,index,fn) => {
        const
            source = arrays[index],indices = [...source.keys()].sort((a,b) => fn(source[a],source[b]));
        return arrays.map(a => indices.map(i => a[i]));
    },arrays = [[2,sorted0 = sortArray(arrays,sortNumbers),sorted1 = sortArray(arrays,1,sortABC);
    sorted2 = sortArray(arrays,2,sortABC);

console.log(sorted0);
console.log(sorted1);
console.log(sorted2);

.as-console-wrapper { max-height: 100% !important; top: 0; }

,

const test = [
  [3,2],["trois","deux","un","deux"],["drei","zwei","eins","zwei"]
];


function sortListsAccordingToReferenceList(
  listOfLists,listIndex,referenceComparator
) {
  function defaultComparator(a,b) {
    return (
      ((a.localeCompare) && (b.localeCompare))
        ? a.localeCompare(b)
        : (((a < b) && -1) || ((a > b) && 1) || 0)
    );
  }
  const comparator = (typeof referenceComparator === 'function')
    ? referenceComparator
    : defaultComparator;

  function compareReferenceItems(a,b) {
    return comparator(a.value,b.value);
  }
  const referenceList = listOfLists[listIndex];
  const lastIndexList = referenceList.map((item,idx) => ({

    lastIndex: idx,value: item

  })).sort(compareReferenceItems).map(referenceItem =>

    referenceItem.lastIndex
  );
  // console.log('lastIndexList : ',lastIndexList);

  // - in case of needing to return the
  //   mutated original array use this block ...
  // 
  // listOfLists.forEach((list,idx) => {
  // 
  //   const duplicates = Array.from(list);
  //   lastIndexList.forEach((lastIndex,idx) => {
  // 
  //     list[idx] = duplicates[lastIndex];
  //   });
  // });
  // return listOfLists; // return mutated original array.

  // - ... otherwise go with pure mappping.
  return listOfLists.map(list =>
    list.map((item,idx) => list[lastIndexList[idx]])
  ); 
}

console.log(
  'sort every array according to numeric sort order ...',sortListsAccordingToReferenceList(test,0)
);
console.log(
  'sort everything by French as lexicographic sort reference ...',1)
);
console.log(
  'sort everything by German as lexicographic sort reference ...',2)
);

console.log(
  'sort every array according to numeric custom sort order ...',(a,b) =>
    // comparator function for descending sort order
    (((a > b) && -1) || ((a < b) && 1) || 0)
  )
);

.as-console-wrapper { min-height: 100%!important; top: 0; }

,

不是单行，但更易于阅读

let nested = [
  [2,"eins"]
];
let srcArr;
nested = nested.map((arr,i) => {
  if (i === 0) { // the reference
    srcArr = arr.slice(0); // take a copy
    arr.sort((a,b) => a - b); // sort the nested one
    return arr;
  }
  return arr.map((item,i) => arr[
    srcArr.indexOf(nested[0][i]) // return in the order of the reference 
  ]);
})
console.log(nested)