Javascript - sắp xếp mảng dựa trên mảng khác

Có thể sắp xếp và sắp xếp lại một mảng trông như thế này không:

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

để phù hợp với sự sắp xếp của mảng này:

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

Thật không may, tôi không có bất kỳ ID nào để theo dõi. Tôi sẽ cần ưu tiên mảng mảng để khớp với sortingArr càng gần càng tốt.

Cập nhật:

Đây là đầu ra tôi đang tìm kiếm:

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

Bất kỳ ý tưởng làm thế nào điều này có thể được thực hiện?

Cái gì đó như:

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

Đây là một mã ngắn hơn, nhưng nó phá hủy sortingmảng:

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

Câu trả lời một dòng.

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

Nếu bạn sử dụng hàm sắp xếp mảng gốc, bạn có thể chuyển vào một bộ so sánh tùy chỉnh được sử dụng khi sắp xếp mảng. Bộ so sánh sẽ trả về số âm nếu giá trị đầu tiên nhỏ hơn giá trị thứ hai, bằng 0 nếu chúng bằng nhau và số dương nếu giá trị đầu tiên lớn hơn.

Vì vậy, nếu tôi hiểu ví dụ bạn đưa ra một cách chính xác, bạn có thể làm một cái gì đó như:

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

itemsArray.sort(sortFunc);

Trường hợp 1: Câu hỏi gốc (Không có thư viện)

Rất nhiều câu trả lời khác mà làm việc. :)

Trường hợp 2: Câu hỏi gốc (Lodash.js hoặc Underscore.js)

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

Trường hợp 3: Sắp xếp Array1 như thể đó là Array2

Tôi đoán rằng hầu hết mọi người đến đây đang tìm kiếm một tương đương với mảng_multisort của PHP (tôi đã làm) vì vậy tôi nghĩ tôi cũng sẽ đăng câu trả lời đó. Có một vài lựa chọn:

1. Hiện có một triển khai JS của Array_multisort () . Cảm ơn @Adnan đã chỉ ra nó trong các bình luận. Nó là khá lớn, mặc dù.

2. Viết của riêng bạn. ( Bản demo của 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 hoặc Underscore.js (cả thư viện phổ biến, nhỏ hơn tập trung vào hiệu suất) cung cấp các hàm trợ giúp cho phép bạn thực hiện việc này:

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

... Cái nào sẽ (1) nhóm sortArray thành [index, value]cặp, (2) sắp xếp chúng theo giá trị (bạn cũng có thể cung cấp một cuộc gọi lại ở đây), (3) thay thế từng cặp bằng vật phẩm từ itemArray tại chỉ mục cặp có nguồn gốc từ.

điều này có lẽ đã quá muộn nhưng, bạn cũng có thể sử dụng một số phiên bản sửa đổi của mã dưới đây theo kiểu ES6. Mã này dành cho các mảng như:

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

Các hoạt động thực tế:

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

Hoạt động thực tế trong ES5:

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

Nên kết quả trong arrayToBeSorted = [3,5]

Không phá hủy mảng tham chiếu.

Tôi sẽ sử dụng một đối tượng trung gian ( itemsMap), do đó tránh sự phức tạp bậc hai:

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

Xem 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/

Thứ tự kết quả: Bob, Jason, Henry, Thomas, Anne, Andrew

Tại sao không phải là một cái gì đó như

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

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

Chức năng bản đồ có thể không khả dụng trên tất cả các phiên bản của 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)

Đây là những gì tôi đang tìm kiếm và tôi đã làm để sắp xếp một mảng Mảng dựa trên một mảng khác:

Đó là ngày ^ 3 và có thể không phải là cách thực hành tốt nhất (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));

Tôi đã phải làm điều này cho một tải trọng JSON mà tôi nhận được từ một API, nhưng nó không theo thứ tự tôi muốn.

Mảng là mảng tham chiếu, mảng bạn muốn mảng thứ hai được sắp xếp theo:

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

Tôi đã làm những điều này như là các đối tượng bởi vì chúng sẽ có các thuộc tính khác cuối cùng.

Tạo mảng:

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

Đã sử dụng điều này với tập kết quả từ cơ sở dữ liệu. Tôi không biết hiệu quả của nó như thế nào nhưng với số lượng cột tôi đã sử dụng, nó hoạt động tốt.

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

Để có được một mảng được đặt hàng mới, bạn có thể lấy Mapvà thu thập tất cả các mục với khóa mong muốn trong một mảng và ánh xạ các khóa được yêu cầu bằng cách lấy phần tử đã chọn của nhóm mong muốn.

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

Giải pháp này sẽ nối các đối tượng ở cuối nếu khóa sắp xếp không có trong mảng tham chiếu

cái này sẽ hoạt động:

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;

Bạn có thể thử phương pháp này.

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

Thêm ví dụ với các mảng đầu vào khác nhau

Trong trường hợp bạn đến đây cần phải làm điều này với một loạt các đối tượng, thì đây là bản phóng tác của câu trả lời tuyệt vời của @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);
})

Sử dụng phương thức $ .inArray () từ jQuery. Sau đó bạn có thể làm một cái gì đó như thế này

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

Sử dụng giao điểm của hai mảng.

Ví dụ:

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

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

_.intersection(sortArray, arrayToBeSort) 

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

nếu 'z và' s 'nằm ngoài phạm vi của mảng đầu tiên, hãy thêm nó vào cuối kết quả

Bạn có thể làm một cái gì đó như thế này:

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

Bạn có thể kiểm tra nó ở đây .

Lưu ý: điều này giả sử các mảng bạn vượt qua có kích thước tương đương, bạn cần thêm một số kiểm tra bổ sung nếu điều này có thể không đúng.

liên kết giới thiệu

tham khảo