Mam dwie tablice:

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

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

Więc chcę wyjść jako ['n', 'z', 'a', 'u', 'b', 'd'];

Zasadniczo porządek originoraarray posortowany przez kolejność mentaly.

Mogę wyskoczyć elementy z oryginalnej tablicy opartej na drugiej tablicy, a następnie może je dołączyć z przodu, a to da mi pożądane rozwiązanie, ale nie na pewno, jeśli byłoby skuteczne, czy jest to lepszy sposób, aby to zrobić za pomocą {{x0 }};

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);
1
Abhijeet 26 czerwiec 2017, 10:45

4 odpowiedzi

Najlepsza odpowiedź

Jeśli potrzebujesz stabilnego sortowania (tj. Chcesz, aby elementy nie są w tablicy sortOrder, aby zachować oryginalne zamówienie), możesz połączyć dwa mapy sortowania za pomocą Object.assign i przesunięcie.

Aby upewnić się, że naszym sortowanie jest stabilny, łączymy dwie mapy: - mapa oryginalnych indeksów, zaczynając od długości danych i przechodzącej do 1 - mapę zdefiniowanych indeksów, przesunięto długością danych

// 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)
  )
);
1
user3297291 26 czerwiec 2017, 09:34

W przypadku dużych manipulacji danych można użyć mapowania obiektów

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);
2
Gautam 8 styczeń 2019, 17:24

Możesz użyć obiektu dla pozycji elementów lub pobrać wartość domyślną zero do obliczania delta.

Z delta zera, stabilny rodzaj nie jest przyznawany.

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

Dla stabilnego rodzaju można użyć Sortowanie z mapą z obiektem, który utrzymuje indeks i grupę dla wartości z priorytetem. Wewnątrz grupy kolejność sortowania jest utrzymywana przez indeks oryginalnej tablicy.

// 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);
2
Nina Scholz 27 czerwiec 2017, 06:29

Możesz utworzyć funkcję sortowania na podstawie indeksu dopasowania w tablicy sortOrder.

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;
}
2
George 26 czerwiec 2017, 07:56