Javascript - 다른 어레이를 기준으로 배열 정렬

Javascript - 다른 어레이를 기준으로 배열 정렬

다음과 같이 배열 정렬 및 재배열이 가능합니까?

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

이 어레이의 배열에 일치시킵니다.

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

유감스럽게도, 저는 추적할 수 있는 신분증이 없습니다.가능한 한 sorting Arr에 맞춰 아이템 배열의 우선순위를 정해야 합니다.

업데이트:

원하는 출력은 다음과 같습니다.

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

어떻게 할 수 있는지 아세요?

한 줄의 답변.

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

또는 더 짧은 시간:

itemsArray.sort((a, b) => sortingArr.indexOf(a) - sortingArr.indexOf(b));

예를 들어 다음과 같습니다.

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

여기 더 짧은 코드가 있습니다. 하지만 이 암호는sorting어레이:

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

네이티브 어레이 정렬 기능을 사용하는 경우 어레이를 정렬할 때 사용할 사용자 지정 비교기를 전달할 수 있습니다.비교기는 첫 번째 값이 두 번째 값보다 작으면 음수, 같으면 0, 첫 번째 값이 크면 양수를 반환해야 합니다.

예를 들면, 다음과 같은 조작을 실시할 수 있습니다.

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

itemsArray.sort(sortFunc);

케이스 1: 질문 (라이브러리 없음)

효과가 있는 다른 대답들도 많죠:)

케이스 2: 질문 (Lodash.js 또는 Underscore.js)

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

케이스 3: Array1을 Array2와 동일하게 정렬합니다.

대부분의 사람들이 PHP의 array_multisort와 동등한 것을 찾고 있다고 생각하기 때문에, 그 답변을 투고하려고 합니다.몇 가지 옵션이 있습니다.

1. array_multisort()의 기존 JS 구현이 있습니다.댓글로 지적해 주신 @Adnan님 감사합니다.그래도 꽤 크긴 해요.

2. 직접 쓰세요.(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 또는 Underscore.js(인기 있는 퍼포먼스에 초점을 맞춘 소규모 라이브러리)는 다음과 같은 도우미 기능을 제공합니다.

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

...sortArray를 (1) 그룹화하여[index, value](2) 값을 기준으로 정렬하고(여기서 콜백을 제공할 수도 있음), (3) 각 쌍을 해당 쌍의 원본 인덱스에 있는 itemArray의 항목으로 바꿉니다.

이것은 아마도 너무 늦었을 것입니다만, 아래의 코드 수정 버전을 ES6 스타일로 사용할 수도 있습니다.이 코드는 다음과 같은 어레이용입니다.

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

실제 조작은 다음과 같습니다.

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

ES5에서의 실제 동작:

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

결과:arrayToBeSorted = [3,5]

참조 배열을 파기하지 않습니다.

왜 안 돼?

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

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

일부 버전에서는 맵 기능을 사용할 수 없을 수 있습니다.Javascript

function sortFunc(a, b) {
  var sortingArr = ["A", "B", "C"];
  return sortingArr.indexOf(a.type) - sortingArr.indexOf(b.type);
}

const itemsArray = [
  {
    type: "A",
  },
  {
    type: "C",
  },
  {
    type: "B",
  },
];
console.log(itemsArray);
itemsArray.sort(sortFunc);
console.log(itemsArray);

오브젝트중간 오브젝트)를 합니다.itemsMap2번으로 하다.

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

http://jsfiddle.net/eUskE/ 를 참조해 주세요.

ES6

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

다른 입력 어레이를 사용한 더 많은 예

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/

결과: 밥, 제이슨,헨리, 토마스, 앤, 앤드류

만약 당신이 여러 가지 물건으로 이것을 해야 한다면, 여기 @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);
})

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)

새 배열 순서를 가져오려면 원하는 키를 가진 항목을 배열에 모두 수집하고 원하는 그룹의 요소를 선택하여 원하는 정렬 키를 매핑할 수 있습니다.

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

다른 어레이를 기반으로 어레이를 정렬하기 위해 필요한 것은 다음과 같습니다.

On^3이므로 베스트 프랙티스가 아닐 수 있습니다(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));

It might help someone

API에서 받은 JSON payload에 대해 이 작업을 수행해야 했지만 원하는 순서가 아니었습니다.

두 번째 배열이 정렬되는 기준 배열인 배열:

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

이것들은 결국 다른 성질을 갖게 되기 때문에 오브젝트로 한 것입니다.

작성된 어레이:

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

데이터베이스의 결과 세트와 함께 사용.얼마나 효율적인지는 모르겠지만 몇 개의 컬럼을 사용했더니 잘 작동했어요.

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

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

이 솔루션은 정렬 키가 참조 배열에 없는 경우 마지막에 개체를 추가합니다.

  const result = sortingArr.map((i) => {
    const pos = itemsArray.findIndex(j => j[1] === i);
    const item = itemsArray[pos];
    itemsArray.splice(pos, 1);
    return item;
  });

다음과 같이 동작합니다.

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;

이 방법을 시도해 보세요.

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
}

숫자 정렬 포함Arr:

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

이 방법이 효과가 있는 것 같습니다.

var outputArray=['10','6','8','10','4','6','2','10','4','0','2','10','0'];
var template=['0','2','4','6','8','10'];
var temp=[];

for(i=0;i<template.length;i++) {
  for(x=0;x<outputArray.length;x++){
    if(template[i] == outputArray[x]) temp.push(outputArray[x])
  };
}

outputArray = temp;
alert(outputArray)

jQuery의 $.inArray() 메서드를 사용합니다.그러면 이런 걸 할 수 있어요.

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

두 배열의 교차점을 사용합니다.

예:

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

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

_.intersection(sortArray, arrayToBeSort) 

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

'z'와 's'가 첫 번째 어레이 범위를 벗어나면 결과 끝에 추가합니다.

this.arrToBeSorted =  this.arrToBeSorted.sort(function(a, b){  
  return uppthis.sorrtingByArray.findIndex(x => x.Id == a.ByPramaeterSorted) - uppthis.sorrtingByArray.findIndex(x => x.Id == b.ByPramaeterSorted);
});

다음과 같은 작업을 수행할 수 있습니다.

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

여기서 테스트 할 수 있어요.

주의: 전달되는 어레이의 크기가 동일하다고 가정합니다.그렇지 않은 경우는, 몇개의 체크를 추가할 필요가 있습니다.

참조 링크

참조하다

언급URL : https://stackoverflow.com/questions/13304543/javascript-sort-array-based-on-another-array