Javascript - mengurutkan array berdasarkan array lain

Apakah mungkin untuk mengurutkan dan mengatur ulang array yang terlihat seperti ini:

itemsArray = [ 
    ['Anne', 'a'],
    ['Bob', 'b'],
    ['Henry', 'b'],
    ['Andrew', 'd'],
    ['Jason', 'c'],
    ['Thomas', 'b']
]

untuk mencocokkan pengaturan array ini:

sortingArr = [ 'b', 'c', 'b', 'b', 'a', 'd' ]

Sayangnya, saya tidak memiliki ID untuk melacak. Saya perlu memprioritaskan item-array agar sesuai dengan sortingArr sedekat mungkin.

Memperbarui:

Ini adalah output yang saya cari:

itemsArray = [    
    ['Bob', 'b'],
    ['Jason', 'c'],
    ['Henry', 'b'],
    ['Thomas', 'b']
    ['Anne', 'a'],
    ['Andrew', 'd'],
]

Adakah yang tahu bagaimana ini bisa dilakukan?

Sesuatu seperti:

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

Berikut kode yang lebih pendek, tetapi merusak sortingarray:

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

Satu baris jawaban.

itemsArray.sort(function(a, b){  
  return sortingArr.indexOf(a) - sortingArr.indexOf(b);
});

Jika Anda menggunakan fungsi pengurutan array asli, Anda bisa meneruskan pembanding khusus untuk digunakan saat mengurutkan array. Komparator harus mengembalikan angka negatif jika nilai pertama kurang dari yang kedua, nol jika mereka sama, dan angka positif jika nilai pertama lebih besar.

Jadi jika saya mengerti contoh yang Anda berikan dengan benar, Anda dapat melakukan sesuatu seperti:

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

itemsArray.sort(sortFunc);

Kasus 1: Pertanyaan Asli (Tidak Ada Perpustakaan)

Banyak jawaban lain yang berfungsi. :)

Kasus 2: Pertanyaan Asli (Lodash.js atau Underscore.js)

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

Kasus 3: Urutkan Array1 seolah-olah Array2

Saya menduga bahwa kebanyakan orang datang ke sini mencari yang setara dengan PHP's array_multisort (saya lakukan), jadi saya pikir saya akan memposting jawaban itu juga. Ada beberapa opsi:

1. Ada implementasi JS yang ada dari array_multisort () . Terima kasih kepada @Adnan karena menunjukkannya di komentar. Tapi ini cukup besar.

2. Tulis milik Anda sendiri. ( Demo 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 atau Underscore.js (keduanya populer, perpustakaan kecil yang berfokus pada kinerja) menawarkan fungsi pembantu yang memungkinkan Anda untuk melakukan ini:

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

... Yang akan (1) mengelompokkan sortArray menjadi [index, value]pasangan, (2) mengurutkannya berdasarkan nilai (Anda juga dapat memberikan panggilan balik di sini), (3) mengganti setiap pasangan dengan item dari itemArray pada indeks yang pasangan berasal dari.

ini mungkin terlambat tetapi, Anda juga dapat menggunakan beberapa versi kode yang dimodifikasi di bawah ini dalam gaya ES6. Kode ini untuk array seperti:

var arrayToBeSorted = [1,2,3,4,5];
var arrayWithReferenceOrder = [3,5,8,9];

Operasi yang sebenarnya:

arrayToBeSorted = arrayWithReferenceOrder.filter(v => arrayToBeSorted.includes(v));

Operasi aktual di ES5:

arrayToBeSorted = arrayWithReferenceOrder.filter(function(v) {
    return arrayToBeSorted.includes(v);
});

Harus menghasilkan arrayToBeSorted = [3,5]

Tidak menghancurkan array referensi.

Saya akan menggunakan objek perantara ( itemsMap), sehingga menghindari kompleksitas kuadratik:

function createItemsMap(itemsArray) { // {"a": ["Anne"], "b": ["Bob", "Henry"], …}
  var itemsMap = {};
  for (var i = 0, item; (item = itemsArray[i]); ++i) {
    (itemsMap[item[1]] || (itemsMap[item[1]] = [])).push(item[0]);
  }
  return itemsMap;
}

function sortByKeys(itemsArray, sortingArr) {
  var itemsMap = createItemsMap(itemsArray), result = [];
  for (var i = 0; i < sortingArr.length; ++i) {
    var key = sortingArr[i];
    result.push([itemsMap[key].shift(), key]);
  }
  return result;
}

Lihat http://jsfiddle.net/eUskE/

var sortedArray = [];
for(var i=0; i < sortingArr.length; i++) {
    var found = false;
    for(var j=0; j < itemsArray.length && !found; j++) {
        if(itemsArray[j][1] == sortingArr[i]) {
            sortedArray.push(itemsArray[j]);
            itemsArray.splice(j,1);
            found = true;
        }
    }
}

http://jsfiddle.net/s7b2P/

Urutan yang dihasilkan: Bob, Jason, Henry, Thomas, Anne, Andrew

Kenapa tidak seperti itu

//array1: array of elements to be sorted
//array2: array with the indexes

array1 = array2.map((object, i) => array1[object]);

Fungsi peta mungkin tidak tersedia di semua versi Javascript

let a = ['A', 'B', 'C' ]

let b = [3, 2, 1]

let c = [1.0, 5.0, 2.0]

// these array can be sorted by sorting order of b

const zip = rows => rows[0].map((_, c) => rows.map(row => row[c]))

const sortBy = (a, b, c) => {
  const zippedArray = zip([a, b, c])
  const sortedZipped = zippedArray.sort((x, y) => x[1] - y[1])

  return zip(sortedZipped)
}

sortBy(a, b, c)

Inilah yang saya cari dan saya lakukan untuk mengurutkan Array of Array berdasarkan Array lain:

Ini Aktif ^ 3 dan mungkin bukan praktik terbaik (ES6)

function sortArray(arr, arr1){
      return arr.map(item => {
        let a = [];
        for(let i=0; i< arr1.length; i++){
          for (const el of item) {
            if(el == arr1[i]){
              a.push(el);
            }   
            }
          }
          return a;
      });
    }
    
    const arr1 = ['fname', 'city', 'name'];
  const arr = [['fname', 'city', 'name'],
  ['fname', 'city', 'name', 'name', 'city','fname']];
  console.log(sortArray(arr,arr1));

Saya harus melakukan ini untuk muatan JSON yang saya terima dari API, tetapi itu tidak sesuai urutan yang saya inginkan.

Array menjadi array referensi, yang Anda inginkan array kedua diurutkan berdasarkan:

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

Saya melakukan ini sebagai objek karena ini akan memiliki properti lain pada akhirnya.

Array yang dibuat:

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

Digunakan ini dengan set hasil dari database. Saya tidak tahu seberapa efisien itu, tetapi dengan beberapa kolom yang saya gunakan, itu berfungsi dengan baik.

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

Untuk mendapatkan array yang dipesan baru, Anda bisa mengambil Mapdan mengumpulkan semua item dengan kunci yang diinginkan dalam array dan memetakan kunci yang diinginkan dengan mengambil elemen yang diayak dari grup yang diinginkan.

var itemsArray = [['Anne', 'a'], ['Bob', 'b'], ['Henry', 'b'], ['Andrew', 'd'], ['Jason', 'c'], ['Thomas', 'b']],
    sortingArr = [ 'b', 'c', 'b', 'b', 'a', 'd' ],
    map = itemsArray.reduce((m, a) => m.set(a[1], (m.get(a[1]) || []).concat([a])), new Map),
    result = sortingArr.map(k => (map.get(k) || []).shift());

console.log(result);

let sortedOrder = [ 'b', 'c', 'b', 'b' ]
let itemsArray = [ 
    ['Anne', 'a'],
    ['Bob', 'b'],
    ['Henry', 'b'],
    ['Andrew', 'd'],
    ['Jason', 'c'],
    ['Thomas', 'b']
]
a.itemsArray(function (a, b) {
    let A = a[1]
    let B = b[1]

    if(A != undefined)
        A = A.toLowerCase()

    if(B != undefined)
        B = B.toLowerCase()

    let indA = sortedOrder.indexOf(A)
    let indB = sortedOrder.indexOf(B)

    if (indA == -1 )
        indA = sortedOrder.length-1
    if( indB == -1)
        indB = sortedOrder.length-1

    if (indA < indB ) {
        return -1;
    } else if (indA > indB) {
        return 1;
    }
    return 0;
})

Solusi ini akan menambahkan objek di akhir jika kunci pengurutan tidak ada dalam array referensi

ini seharusnya bekerja:

var i,search, itemsArraySorted = [];
while(sortingArr.length) {
    search = sortingArr.shift();
    for(i = 0; i<itemsArray.length; i++) {
        if(itemsArray[i][1] == search) {
            itemsArraySorted.push(itemsArray[i]);
            break;
        }
    } 
}

itemsArray = itemsArraySorted;

Anda dapat mencoba metode ini.

const sortListByRanking = (rankingList, listToSort) => {
  let result = []

  for (let id of rankingList) {
    for (let item of listToSort) {
      if (item && item[1] === id) {
        result.push(item)
      }
    }
  }

  return result
}

ES6

const arrayMap = itemsArray.reduce(
  (accumulator, currentValue) => ({
    ...accumulator,
    [currentValue[1]]: currentValue,
  }),
  {}
);
const result = sortingArr.map(key => arrayMap[key]);

Lebih banyak contoh dengan berbagai input array

Jika Anda tiba di sini perlu melakukan ini dengan berbagai objek, berikut adalah adaptasi dari jawaban luar biasa @Durgpal Singh:

const itemsArray = [
  { name: 'Anne', id: 'a' },
  { name: 'Bob', id: 'b' },
  { name: 'Henry', id: 'b' },
  { name: 'Andrew', id: 'd' },
  { name: 'Jason', id: 'c' },
  { name: 'Thomas', id: 'b' }
]

const sortingArr = [ 'b', 'c', 'b', 'b', 'a', 'd' ]

Object.keys(itemsArray).sort((a, b) => {
  return sortingArr.indexOf(itemsArray[a].id) - sortingArr.indexOf(itemsArray[b].id);
})

Gunakan metode $ .inArray () dari jQuery. Anda kemudian dapat melakukan sesuatu seperti ini

var sortingArr = [ 'b', 'c', 'b', 'b', 'c', 'd' ];
var newSortedArray = new Array();

for(var i=sortingArr.length; i--;) {
 var foundIn = $.inArray(sortingArr[i], itemsArray);
 newSortedArray.push(itemsArray[foundIn]);
}

Gunakan persimpangan dua array.

Ex:

var sortArray = ['a', 'b', 'c',  'd', 'e'];

var arrayToBeSort = ['z', 's', 'b',  'e', 'a'];

_.intersection(sortArray, arrayToBeSort) 

=> ['a', 'b', 'e']

jika 'z dan' s 'di luar jangkauan array pertama, tambahkan di akhir hasil

Anda dapat melakukan sesuatu seperti ini:

function getSorted(itemsArray , sortingArr ) {
  var result = [];
  for(var i=0; i<arr.length; i++) {
    result[i] = arr[sortArr[i]];
  }
  return result;
}

Anda dapat mengujinya di sini .

Catatan: ini mengasumsikan array yang Anda berikan berukuran sama, Anda perlu menambahkan beberapa pemeriksaan tambahan jika ini tidak terjadi.

lihat tautan

lihat