Javascript 使用2个条件对JS对象数组进行排序
我有一个对象数组:Javascript 使用2个条件对JS对象数组进行排序,javascript,arrays,sorting,underscore.js,Javascript,Arrays,Sorting,Underscore.js,我有一个对象数组: [{cat:A,size:2}, {cat:B,size:2}, {cat:B,size:1}, {cat:A,size:3}, {cat:C,size:5}, {cat:B,size:3}] 我想先按类别对这个数组进行排序,然后按每个类别中的asc大小进行排序。生成的数组将是: [{cat:A,size:2}, {cat:A,size:3}, {cat:B,size:1}, {cat:B,size:2}, {cat:B,size:3}, {cat:C,size:5}]
[{cat:A,size:2},
{cat:B,size:2},
{cat:B,size:1},
{cat:A,size:3},
{cat:C,size:5},
{cat:B,size:3}]
我想先按类别对这个数组进行排序,然后按每个类别中的asc大小进行排序。生成的数组将是:
[{cat:A,size:2},
{cat:A,size:3},
{cat:B,size:1},
{cat:B,size:2},
{cat:B,size:3},
{cat:C,size:5}]
我目前正在用cat将数组划分为临时子集,然后按大小对每个数组进行排序并加入。。。但我有100000多个值需要排序,我相信有更好/更快的方法。如果有帮助的话,我的项目中包含了下划线.js。猫的数量是动态的。。。有什么建议吗?只需进行两种比较。如果类别不同,则无需比较大小
yourArray.sort(function(e1, e2) {
if (e1.cat < e2.cat) return -1;
if (e1.cat > e2.cat) return 1;
// categories must be the same, so order by size
if (e1.size < e2.size) return -1;
if (e1.size > e2.size) return 1;
return 0;
});
yourray.sort(函数(e1,e2){
如果(e1.cate2.cat)返回1;
//类别必须相同,因此按大小排序
if(e1.sizee2.size)返回1;
返回0;
});
只需执行两个比较。如果类别不同,则无需比较大小
yourArray.sort(function(e1, e2) {
if (e1.cat < e2.cat) return -1;
if (e1.cat > e2.cat) return 1;
// categories must be the same, so order by size
if (e1.size < e2.size) return -1;
if (e1.size > e2.size) return 1;
return 0;
});
yourray.sort(函数(e1,e2){
如果(e1.cate2.cat)返回1;
//类别必须相同,因此按大小排序
if(e1.sizee2.size)返回1;
返回0;
});
只需执行两个比较。如果类别不同,则无需比较大小
yourArray.sort(function(e1, e2) {
if (e1.cat < e2.cat) return -1;
if (e1.cat > e2.cat) return 1;
// categories must be the same, so order by size
if (e1.size < e2.size) return -1;
if (e1.size > e2.size) return 1;
return 0;
});
yourray.sort(函数(e1,e2){
如果(e1.cate2.cat)返回1;
//类别必须相同,因此按大小排序
if(e1.sizee2.size)返回1;
返回0;
});
只需执行两个比较。如果类别不同,则无需比较大小
yourArray.sort(function(e1, e2) {
if (e1.cat < e2.cat) return -1;
if (e1.cat > e2.cat) return 1;
// categories must be the same, so order by size
if (e1.size < e2.size) return -1;
if (e1.size > e2.size) return 1;
return 0;
});
yourray.sort(函数(e1,e2){
如果(e1.cate2.cat)返回1;
//类别必须相同,因此按大小排序
if(e1.sizee2.size)返回1;
返回0;
});
当类别相等时,顺序由大小值定义。否则,顺序由类别定义。
看到它在这里工作:
记住,它通过返回负值、零值或正值来工作;不需要返回+1或-1
let catSizes = [
{ cat: 'A', size: 2 },
{ cat: 'B', size: 2 },
{ cat: 'B', size: 1 },
{ cat: 'A', size: 3 },
{ cat: 'C', size: 5 },
{ cat: 'B', size: 3 }
];
catSizes.sort( ( a, b ) => {
if( a.cat === b.cat ){ return a.size - b.size }
return a.cat > b.cat ? 1 : -1;
});````
当类别相等时,顺序由大小值定义。
否则,顺序由类别定义。
看到它在这里工作:
记住,它通过返回负值、零值或正值来工作;不需要返回+1或-1
let catSizes = [
{ cat: 'A', size: 2 },
{ cat: 'B', size: 2 },
{ cat: 'B', size: 1 },
{ cat: 'A', size: 3 },
{ cat: 'C', size: 5 },
{ cat: 'B', size: 3 }
];
catSizes.sort( ( a, b ) => {
if( a.cat === b.cat ){ return a.size - b.size }
return a.cat > b.cat ? 1 : -1;
});````
当类别相等时,顺序由大小值定义。
否则,顺序由类别定义。
看到它在这里工作:
记住,它通过返回负值、零值或正值来工作;不需要返回+1或-1
let catSizes = [
{ cat: 'A', size: 2 },
{ cat: 'B', size: 2 },
{ cat: 'B', size: 1 },
{ cat: 'A', size: 3 },
{ cat: 'C', size: 5 },
{ cat: 'B', size: 3 }
];
catSizes.sort( ( a, b ) => {
if( a.cat === b.cat ){ return a.size - b.size }
return a.cat > b.cat ? 1 : -1;
});````
当类别相等时,顺序由大小值定义。
否则,顺序由类别定义。
看到它在这里工作:
记住,它通过返回负值、零值或正值来工作;不需要返回+1或-1
let catSizes = [
{ cat: 'A', size: 2 },
{ cat: 'B', size: 2 },
{ cat: 'B', size: 1 },
{ cat: 'A', size: 3 },
{ cat: 'C', size: 5 },
{ cat: 'B', size: 3 }
];
catSizes.sort( ( a, b ) => {
if( a.cat === b.cat ){ return a.size - b.size }
return a.cat > b.cat ? 1 : -1;
});````
它不是一个重复,我只是建议用下划线。下面的答案更有价值。它的可能重复不是重复,我只是建议用下划线。下面的答案更有价值。它的可能重复不是重复,我只是建议用下划线。下面的答案更有价值。它的可能重复不是重复,我只是建议用下划线。下面的答案更有价值。