Question

假设我有一个数组：

var ay=[0,1,2,3,4,5,6,7,8,9];

现在我想得到两个数组：

var ay1=[0,2,4,6,8];
var ay2=[1,3,5,7,9];

什么是有效的方式？

更新

我知道这样的简单循环和模运算符方法（如elclanrs所述）：

var ay1=[],ay2=[];
for(var i=0,len=ay.length;i++){
  if(i%2==0){
    ay2.push(ay[i]);
  } else 
    ay1.push(ay[i]);
}

但我只是想知道是否还有其他有效或酷的方式我还不知道。

这就是我问这个简单问题的原因。我不是问怎么做，我问如果可能的话怎么做得更好！

所以我认为这篇文章不值得投票。

Answer 1

假设我们稍微概括了这个问题。为什么不允许将数组以相同的方式分成三个，四个或更多个单独的数组，而不是仅仅将数组的交替元素拆分为两个数组？

事实证明，允许任意数量的数组同样容易，只需要两个数组。

将阵列想象成一根由绳子组成的绳子，绳索中的绳索数量，你想解开它。你可以这样做：

// "Unravel" an array as if it were a rope made up of strands, going
// around the rope and pulling off part of each strand one by one.
// 'rope' is the array and 'count' is the number of strands.
// Return an array of arrays, where the outer array has length 'count'
// and the inner arrays represent the individual strands.
function unravel( rope, count ) {
    // Create each strand
    var strands = [];
    for( var i = 0;  i < count;  i++ ) {
        strands.push( [] );
    }
    // Unravel the rope into the individual strands
    for( var i = 0, n = rope.length;  i < n;  i++ ) {
        strands[ i % count ].push( rope[i] );
    }
    return strands;
}

var rope = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ];

var s = unravel( rope, 2 );
console.log( s[0], s[1] );

var s = unravel( rope, 3 );
console.log( s[0], s[1], s[2] );

var s = unravel( rope, 5 );
console.log( s[0], s[1], s[2], s[3], s[4] );

此日志：

[0, 2, 4, 6, 8] [1, 3, 5, 7, 9]
[0, 3, 6, 9] [1, 4, 7] [2, 5, 8]
[0, 5] [1, 6] [2, 7] [3, 8] [4, 9]

请注意，在第二种情况下（count = 3），其中一条链比另外两条长 - 这是预期的，因为10不能被3整除。

Answer 2

为什么不使用模数函数？

for (var i = 0; i < ay.length; i++) {
    if (i%2 == 0)
    {
     ay1[i] = ay[i];
    }
    else
    {
     ay2[i] - ay[i];
    }
}

Answer 3

这是一种方式：

var ay = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

var ay1 = [];
var ay2 = [];
for(var i = 0; i < ay.length; i++) {
    if(i % 2 == 0) {
        ay1.push(ay[i]);
    }else{
        ay2.push(ay[i]);
    }
}

Answer 4

var ay=[0,1,2,3,4,5,6,7,8,9];
var ay1 = [];
var ay2 = [];

for (var i = 0; i < ay.length; i++)
    if (i % 2) ay2.push(ay[i]);
    else ay1.push(ay[i]);
console.log(ay1, ay2);

http://jsfiddle.net/MPAAC/

Answer 5

var ay1=new Array();
var ay2=new Array();

for (var i = 0, len = ay.length; i < len; i++) {
//Check the i is odd or even
//insert any one of the array

}

Answer 6

为什么不使用数组的filter方法？

var ay = [0,1,2,3,4,5,6,7,8,9];
var odds = ay.filter(function(val){ return val % 2 === 1; });
var evens = ay.filter(function(val){ return val % 2 === 0; });

如果您需要支持IE8

，可以使用上述链接的垫片

Answer 7

Here is a variant，因为我可以。它是“最有效的”吗？没有; 但它具有相同的边界 - O（1）用于恒定大小的结果列表。

它非常酷且非常灵活 - 它实际上只是一个可以解压缩为n（可能是非独特的）序列的“分区”变体。给出的大多数其他答案都是基于不使用HoF的专用分区实现，所以我认为在这方面这是优越的;-)通过如何这是有效的练习

function unzip(arr) {
    var conds = Array.prototype.slice.call(arguments, 1);
    // Requires ES5 or a shim for `Array.map`.
    var res = conds.map(function () { return [] });
    for (var i = 0; i < arr.length; i++) {
       for (var k = 0; k < conds.length; k++) {
           if (conds[k](i, arr[i])) {
               res[k].push(arr[i]);
           }
       }
    }
    return res;
}

r = unzip([0,1,2,3,4],
    function (i) { return !(i % 2) }, // even
    function (i) { return i % 2 });   // odd

alert(r[0] + " || " + r[1]);

如果已经使用了underscore.js（为什么不使用？），则可以使用a groupBy approach。

Answer 8

funciton isEven(x) {
   return x % 2 == 0;
}
function isOdd(x) {
   return ! isEven(x);
}

var arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
    arrEven = arr.filter(isEven),
    arrOdd = arr.filter(isOdd);

按索引拆分数组

8 个答案: