根据javascript中的另一个数组对数组进行排序

Question

I have two arrays:

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

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

so I want output as ['n', 'z', 'a', 'u', 'b', 'd'];

basically the order of originalArray sorted by the order of secondArray.

I can popOut the elements from the original array based on second array and then can append them in front and this will give me the desired solution, but not sure if that would be efficient or is there any better way to do it using array.sort(fxn) ;

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

const sortOrder = ['n', 'z'];
const reverseOrder = sortOrder.reverse();
for (let elem of reverseOrder) {
const indexofelem = originalArray.indexOf(elem);
 originalArray.unshift(originalArray.splice(indexofelem, 1)[0]);
}

console.log(originalArray);

Answer 1

You can create a sort function based on the matching index in the sortOrder array.

 const originalArray = ['a', 'n', 'u', 'b', 'd', 'z']; const sortOrder = ['n', 'z']; function sortArrays(a, b) { var indexOfA = sortOrder.indexOf(a), indexOfB = sortOrder.indexOf(b); if (indexOfA == -1) { indexOfA = sortOrder.length + 1; } if (indexOfB == -1) { indexOfB = sortOrder.length + 1; } if (indexOfA < indexOfB) { return -1; } if (indexOfA > indexOfB) { return 1; } return 0; } originalArray.sort(sortArrays); console.log(originalArray); 

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

Answer 2

You could use an object for the position of the items or take a default value of zero for calculating the delta.

With a delta of zero, a stable sort is not granted.

 const array = ['a', 'n', 'u', 'b', 'd', 'z'], sortOrder = ['n', 'z'], order = sortOrder.reduce((r, a, i, aa) => (r[a] = -aa.length + i, r), {}); array.sort((a, b) => (order[a] || 0) - (order[b] || 0)); console.log(array); console.log(order); 

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

For a stable sort, you could use sorting with map with an object, which keeps the index and the group for the values with priority. Inside of a group, the sort order is maintained by the index of the original array.

 // the array to be sorted var list = ['a', 'n', 'u', 'b', 'd', 'z'], sortOrder = ['n', 'z'], order = sortOrder.reduce((r, a, i, aa) => (r[a] = -aa.length + i, r), {}); // temporary array holds objects with position and sort-value var mapped = list.map(function (el, i) { return { index: i, group: order[el] || 0 }; }); // sorting the mapped array containing the reduced values mapped.sort(function (a, b) { return a.group - b.group || a.index - b.index; }); // container for the resulting order var result = mapped.map(function (el) { return list[el.index]; }); console.log(result); 

Answer 3

For large data array handling we can use object mapping

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

Answer 4

If you require a stable sort (ie you want the elements not in the sortOrder array to keep their original order), you can combine two sort maps using Object.assign and an offset.

So, to make sure our sort is stable, we combine two maps: - a map of the original indexes, starting at the length of the data and going to 1 - a map of the defined indexes, offset by the length of the data

 // Create a map that holds an integer sort index for // each value in an array based on its index const sortMap = (ref, offset = 0) => ref.reduce((map, x, i) => Object.assign(map, { [x]: (ref.length - i) + offset }) , {}); // Returns a function that sorts based on a value in a map const sortWithMap = map => (a, b) => (map[b] || 0) - (map[a] || 0); const originalArray = "abcdefghijlmnopqrstuvwxyz".split(""); const sortOrder = ['n', 'z']; const sortToOrder = (order, data) => data.sort( sortWithMap(sortMap(order)) ); const sortToOrderStable = (order, data) => data.sort( sortWithMap(Object.assign( sortMap(data), sortMap(order, data.length) ))); console.log("Stable:", JSON.stringify( sortToOrderStable(sortOrder, originalArray) ) ); console.log("Default:", JSON.stringify( sortToOrder(sortOrder, originalArray) ) );