基于javascript中的另一个数组对数组进行排序

我有两个阵列：

const originalArray = ['a', 'n', 'u', 'b', 'd', 'z'];

const sortOrder = ['n', 'z'];

所以我希望输出为

['n'，'z'，'a'，'u'，'b'，'d']

基本上，原始数组的顺序是按第二个数组的顺序排序的

我可以根据第二个数组从原始数组中弹出元素，然后将它们追加到前面，这将为我提供所需的解决方案，但不确定这是否有效，或者是否有更好的方法使用
array.sort（fxn）

您可以根据
sortOrder
数组中的匹配索引创建排序函数


const originalArray=['a'，n'，'u'，'b'，'d'，'z']；
常量排序器=['n'，'z']；
函数sortarray（a，b）{
var indexOfA=排序器indexOf（a），
indexOfB=排序器indexOf（b）；
如果（indexOfA==-1）{
indexOfA=sortOrder.length+1；
}
如果（indexOfB==-1）{
indexOfB=排序器长度+1；
}
if（indexOfAindexOfB）{
返回1；
}
返回0；
}
原始数组排序（Sortarray）；
控制台日志（原始阵列）
。作为控制台包装器{
最大高度：100%！重要；
排名：0；
}
您可以根据
sortOrder
数组中的匹配索引创建排序函数


const originalArray=['a'，n'，'u'，'b'，'d'，'z']；
常量排序器=['n'，'z']；
函数sortarray（a，b）{
var indexOfA=排序器indexOf（a），
indexOfB=排序器indexOf（b）；
如果（indexOfA==-1）{
indexOfA=sortOrder.length+1；
}
如果（indexOfB==-1）{
indexOfB=排序器长度+1；
}
if（indexOfAindexOfB）{
返回1；
}
返回0；
}
原始数组排序（Sortarray）；
控制台日志（原始阵列）
。作为控制台包装器{
最大高度：100%！重要；
排名：0；
}
您可以使用对象作为项目的位置，或者使用默认值零来计算增量

如果增量为零，则不授予稳定排序


const数组=['a'，'n'，'u'，'b'，'d'，'z']，
排序器=['n'，'z']，
顺序=sortOrder.reduce（（r，a，i，aa）=>（r[a]=-aa.length+i，r），{}）；
sort（（a，b）=>（顺序[a]| 0）-（顺序[b]| 0））；
console.log（数组）；
控制台日志（订单）
。作为控制台包装{max height:100%！important；top:0；}
您可以使用对象作为项目的位置，或者使用默认值零来计算增量

如果增量为零，则不授予稳定排序


const数组=['a'，'n'，'u'，'b'，'d'，'z']，
排序器=['n'，'z']，
顺序=sortOrder.reduce（（r，a，i，aa）=>（r[a]=-aa.length+i，r），{}）；
sort（（a，b）=>（顺序[a]| 0）-（顺序[b]| 0））；
console.log（数组）；
控制台日志（订单）
.as console wrapper{max height:100%！important；top:0；}
如果需要稳定排序（即，您希望不在
排序器
数组中的元素保持其原始顺序），可以使用
对象组合两个排序映射。分配
和偏移量

因此，为了确保我们的排序是稳定的，我们结合了两个映射：
-原始索引的映射，从数据长度开始，到1
-定义索引的映射，按数据长度偏移


//创建一个包含整数排序索引的映射
//基于索引的数组中的每个值
常量排序映射=（参考，偏移量=0）=>
ref.REDUCT（（映射，x，i）=>
赋值（映射，{[x]：（ref.length-i）+offset}）
, {});
//返回一个函数，该函数根据映射中的值进行排序
const sortWithMap=map=>（a，b）=>
（地图[b]| | 0）-（地图[a]| | 0）；
const originalArray=“abcdefghijlmnopqrstuvwxyz”。拆分（“”）；
常量排序器=['n'，'z']；
const sortToOrder=（顺序，数据）=>data.sort(
sortWithMap（sortMap（订单））
);
const sortToOrderStable=（顺序，数据）=>data.sort(
sortWithMap（Object.assign）(
sortMap（数据），
sortMap（顺序、数据、长度）
)));
console.log（“稳定：”，
JSON.stringify(
SortotOrderStable（sortOrder，原始阵列）
)
);
log（“默认值：”，
JSON.stringify(
sortOrder（sortOrder，Originalaray）
)
);
如果需要稳定排序（即，希望不在
排序器
数组中的元素保持其原始顺序），可以使用
对象组合两个排序映射。分配
和偏移量

因此，为了确保我们的排序是稳定的，我们结合了两个映射：
-原始索引的映射，从数据长度开始，到1
-定义索引的映射，按数据长度偏移


//创建一个包含整数排序索引的映射
//基于索引的数组中的每个值
常量排序映射=（参考，偏移量=0）=>
ref.REDUCT（（映射，x，i）=>
赋值（映射，{[x]：（ref.length-i）+offset}）
, {});
//返回一个函数，该函数根据映射中的值进行排序
const sortWithMap=map=>（a，b）=>
（地图[b]| | 0）-（地图[a]| | 0）；
const originalArray=“abcdefghijlmnopqrstuvwxyz”。拆分（“”）；
常量排序器=['n'，'z']；
const sortToOrder=（顺序，数据）=>data.sort(
sortWithMap（sortMap（订单））
);
const sortToOrderStable=（顺序，数据）=>data.sort(
sortWithMap（Object.assign）(
sortMap（数据），
sortMap（顺序、数据、长度）
)));
console.log（“稳定：”，
JSON.stringify(
SortotOrderStable（sortOrder，原始阵列）
)
);
log（“默认值：”，
JSON.stringify(
sortOrder（sortOrder，Originalaray）
)
);对于大型数据数组处理，我们可以使用对象映射

var originalArray = ['a', 'n', 'u', 'b', 'd', 'z'],
sortOrder = ['n', 'z'];
var result = {};
var finalResponse = [];

// loop over item array which have to sort
originalArray.forEach(function(elem) {
  // if element not persent in result object then create map with true flag set
  if(!result[elem]){
    result[elem] = true
  }
});

// loop over sort order to check element exist in given array
sortOrder.forEach(function(elem) {
  //if element exist then push to array data and set flag to false for element matched.
  if(result[elem]){
    finalResponse.push(elem);
    result[elem] = false
  }
});

// loop over final object data and find all element with true value
for(var key in result) {
  if(result[key]){
   finalResponse.push(key);
  }
}
console.log('final response ',finalResponse);

对于大型数据数组处理，我们可以使用对象映射

var originalArray = ['a', 'n', 'u', 'b', 'd', 'z'],
sortOrder = ['n', 'z'];
var result = {};
var finalResponse = [];

// loop over item array which have to sort
originalArray.forEach(function(elem) {
  // if element not persent in result object then create map with true flag set
  if(!result[elem]){
    result[elem] = true
  }
});

// loop over sort order to check element exist in given array
sortOrder.forEach(function(elem) {
  //if element exist then push to array data and set flag to false for element matched.
  if(result[elem]){
    finalResponse.push(elem);
    result[elem] = false
  }
});

// loop over final object data and find all element with true value
for(var key in result) {
  if(result[key]){
   finalResponse.push(key);
  }
}
console.log('final response ',finalResponse);

sortOrder
中的项目顺序是否相关？为
array.sort
编写一个比较函数非常简单，只需将
sortOrder
中的项目排序到最前面；保证其他项目的稳定排序更为复杂。是的，保持项目的顺序不在s中是相关的