Question

我说有两个数组 priceArray = [1,5,3,7]

userIdArray = [11,52,41,5]

我需要对priceArray进行排序，以便对userIdArray进行排序。例如，输出应为：

priceArray = [1,3,5,7] userIdArray = [11,41,52,5]

任何想法怎么做？

我正在NodeJS中编写我的服务器

Answer 1

取自Sorting with map并改编为userIdArray：

＆＃13;

// the array to be sorted
var priceArray = [1, 5, 3, 7],
    userIdArray = [11, 52, 41, 5];

// temporary array holds objects with position and sort-value
var mapped = priceArray.map(function (el, i) {
    return { index: i, value: el };
});

// sorting the mapped array containing the reduced values
mapped.sort(function (a, b) {
    return a.value - b.value;
});

// container for the resulting order
var resultPrice = mapped.map(function (el) {
    return priceArray[el.index];
});
var resultUser = mapped.map(function (el) {
    return userIdArray[el.index];
});

document.write('<pre>' + JSON.stringify(resultPrice, 0, 4) + '</pre>');
document.write('<pre>' + JSON.stringify(resultUser, 0, 4) + '</pre>');

＆＃13;

正如rrowland建议的那样，使用正确的数据结构，您可以使用：

＆＃13;

var data = [{
        userId: 11, price: 1
    }, {
        userId: 52, price: 15
    }, {
        userId: 41, price: 13
    }, {
        userId: 5, price: 17
    }];

data.sort(function (a, b) {
    return a.price - b.price;
});

document.write('<pre>' + JSON.stringify(data, 0, 4) + '</pre>');

＆＃13;

ES6稍短一点

＆＃13;

var priceArray = [1, 5, 3, 7],
    userIdArray = [11, 52, 41, 5],
    temp = Array.from(priceArray.keys()).sort((a, b) => priceArray[a] - priceArray[b]);

priceArray = temp.map(i => priceArray[i]);
userIdArray = temp.map(i => userIdArray[i]);

console.log(priceArray);
console.log(userIdArray);

＆＃13;

.as-console-wrapper { max-height: 100% !important; top: 0; }

＆＃13;

Answer 2

如果不了解整个用例，很难开出更好的解决方案。也就是说，如果您需要按ID排序，那么创建包含用户对象的单个数组可能更有意义：

var users = [
  { id: 123, price: 25.00 },
  { id: 124, price: 50.00 }
];

users.sort(function(a, b) {
  return a.id - b.id;
});

或者，如果他们不需要排序，您只需按ID创建用户地图：

var userPrices = {
  123: 25.00,
  124: 50.00
};

Answer 3

在Rrowland的答案基础上，您可以使用Debugger fails with "This operation is not supported from a callback function."这样的库创建对象数组：

var prices  = [1, 5, 8, 2];
var userIds = [3, 5, 1, 9];

var pairs = _.zipWith(prices, userIds, function(p, u) {
  return { price: p, userId: u };
});

这会给你一个像这样的对象：

[ 
  { price: 1, userId: 3 },
  { price: 5, userId: 5 },
  ... etc
]

然后，为了排序，您只需使用Javascript排序：

pairs.sort(function(p) { return p.price });

如果你真的需要它作为一个userIds数组，你可以在排序后取回它：

var sortedUserId = pairs.map( function(p) { return p.userId });
// returns [ 3, 9, 5, 8 ];

Answer 4

我已经看到了一个关于使不可能状态变得不可能的好话题。这涵盖了2个相关但可能不同步的数组，更好地使用了一个具有2个属性的对象数组（如上所述）。

然而;如果你想改变两个数组并按照你可以执行以下操作的方式对它们进行排序：

＆＃13;

//this will mutate both arrays passed into it
//  you could return the arrays but then you need to do arr.slice(0).sort(...) instead
const sortSame = sortFn => (arrayToSort,arrayToSortSame) => {
  const sortResults = [];
  arrayToSort.sort(//will mutate the array
    (a,b)=>{
      const result = sortFn(a,b);
      sortResults.push(result);
      return result
    }
  );
  arrayToSortSame.sort(()=>sortResults.shift());
  return undefined;
}

const priceArray= [1,5,3,7];
const userIdArray=[11, 52, 41, 5];
const numSortSameAscending = sortSame((a,b)=>a-b);
numSortSameAscending(priceArray,userIdArray);
console.log(
  priceArray,userIdArray
)

＆＃13;

尽管这个答案中的代码可能看起来更简单，但这并不是最便宜的方式，因为映射比排序更便宜（更好地映射3次并排序一次然后排序两次），具体取决于大小数组以及原始数组乱序多少这种排序方式可能非常昂贵。

在javascript中使用其中一个的值排序2数组

4 个答案: