Javascript - diziyi başka bir diziye göre sırala

Şuna benzer bir diziyi sıralamak ve yeniden düzenlemek mümkün müdür:

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

bu dizinin düzeniyle eşleşmek için:

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

Maalesef, izlenecek hiçbir kimliğim yok. Mümkün olduğunca yakın sortingArr eşleştirmek için items-array öncelik gerekir.

Güncelleme:

İşte aradığım çıktı:

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

Bunun nasıl yapılabileceği hakkında bir fikrin var mı?

Gibi bir şey:

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

İşte daha kısa bir kod, ancak sortingdiziyi yok eder :

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

Tek Satır yanıtı.

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

Yerel dizi sıralama işlevini kullanırsanız, diziyi sıralarken kullanılacak özel bir karşılaştırıcıyı iletebilirsiniz. İlk değer ikinciden küçükse karşılaştırıcı negatif, eşitse sıfır ve ilk değer büyükse pozitif bir sayı döndürmelidir.

Eğer doğru şekilde verdiğiniz örneği anlarsam, şöyle bir şey yapabilirsiniz:

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

itemsArray.sort(sortFunc);

Durum 1: Orijinal Soru (Kitaplık Yok)

İşe yarayan diğer cevaplar. :)

Durum 2: Orijinal Soru (Lodash.js veya Underscore.js)

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

Durum 3: Dizi1'i, Dizi2 gibi sırala

Çoğu kişi burada PHP dizi_multisort (ben yaptım) eşdeğer aramaya geldiğini tahmin ediyorum, bu yüzden ben de bu cevap göndereceğini düşündüm. Birkaç seçenek var:

1. array_multisort () öğesinin var olan bir JS uygulaması var . @Adnan'a yorumlarda işaret ettiği için teşekkürler. Yine de oldukça büyük.

2. Kendiniz yazın. ( JSFiddle demosu )

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 veya Underscore.js (hem performansa odaklanan hem popüler, daha küçük kütüphaneler) bunu yapmanızı sağlayan yardımcı işlevler sunar:

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

... Hangi (1) sortArray öğesini [index, value]çiftler halinde gruplandıracak , (2) bunları değere göre sıralayacaktır (burada bir geri arama da sağlayabilirsiniz), (3) çiftlerin her birini dizindeki itemArray öğesindeki öğeyle değiştirin çifti kökenlidir.

bu muhtemelen çok geç, ancak aşağıdaki kodun bazı değiştirilmiş sürümlerini ES6 stilinde de kullanabilirsiniz. Bu kod aşağıdaki gibi diziler içindir:

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

Gerçek işlem:

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

ES5'teki gerçek işlem:

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

Sonuç vermeli arrayToBeSorted = [3,5]

Referans dizisini yok etmez.

Bu itemsMapnedenle ikinci dereceden karmaşıklığı önleyerek bir aracı nesne ( ) kullanırdım :

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

Bkz. 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/

Sonuç emri: Bob, Jason, Henry, Thomas, Anne, Andrew

Neden böyle bir şey olmasın

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

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

Harita işlevi tüm sürümlerinde bulunmayabilir 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)

Aradığım şey buydu ve başka bir Diziye dayalı bir Dizi Dizisi sıralamak için yaptım:

Açık ^ 3 ve en iyi uygulama olmayabilir (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));

Bunu bir API'den aldığım JSON yükü için yapmak zorunda kaldım, ama istediğim sırada değildi.

Dizi başvuru dizisi, ikinci dizinin sıralama ölçütü olmasını istediğiniz dizidir:

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

Bunları nesne olarak yaptım çünkü sonunda başka özelliklere sahip olacaklar.

Oluşturulan dizi:

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

Bunu veritabanından sonuç kümesiyle birlikte kullandı. Ne kadar verimli olduğunu bilmiyorum ama kullandığım az sayıda sütunla işe yaradı.

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

Yeni bir sıralı dizi elde Mapetmek için, bir dizideki aranan anahtarla tüm öğeleri alabilir ve toplayabilir ve istenen grubun elenmiş öğesini alarak istenen sıralı anahtarları eşleyebilirsiniz.

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

Referans dizisinde sıralama anahtarı yoksa, bu çözüm en sonunda nesneleri ekler

bu çalışır:

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;

Bu yöntemi deneyebilirsiniz.

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

Farklı giriş dizileriyle daha fazla örnek

Buraya bir dizi nesne ile ihtiyaç duymanız durumunda, @Durgpal Singh'in harika cevabının bir uyarlaması:

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

JQuery'den $ .inArray () yöntemini kullanın. O zaman böyle bir şey yapabilirdin

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

İki dizinin kesişimini kullanın.

Ör:

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

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

_.intersection(sortArray, arrayToBeSort) 

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

'z ve' s 'ilk dizi aralığının dışındaysa, sonucun sonuna ekleyin

Bunun gibi bir şey yapabilirsiniz:

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

Burada test edebilirsiniz .

Not: Bu, geçirdiğiniz dizilerin boyutunun eşdeğer olduğunu varsayar; durum böyle değilse ek denetimler eklemeniz gerekir.

bakınız linki

başvurmak