-1

假设我有一个数组：

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

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

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

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

4

8 回答 8

5

假设我们将这个问题概括一下。与其将数组的交替元素拆分为两个数组，为什么不允许以相同的方式将数组拆分为三个、四个或更多单独的数组？

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

将阵列想象成一根由股线组成的绳索，无论绳索中有多少股线，您都想解开它。你可以这样做：

// "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 整除。

于 2013-06-20T04:34:01.213 回答
0

这是一个变体，只是因为我可以。它是“最有效的”吗？哎呀，不；但它具有相同的界限- 对于固定大小的结果列表数量为 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 已经被使用（为什么不呢？），那么可以使用groupBy 方法。

于 2013-06-20T04:14:01.030 回答
0 
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);
于 2013-06-20T04:19:30.813 回答
0

为什么不使用模函数？

for (var i = 0; i < ay.length; i++) {
    if (i%2 == 0)
    {
     ay1[i] = ay[i];
    }
    else
    {
     ay2[i] - ay[i];
    }
}
于 2013-06-20T04:01:38.260 回答
0

这是一种方法：

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]);
    }
}
于 2013-06-20T04:02:57.490 回答
0 
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/

于 2013-06-20T04:03:02.333 回答
0 
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

}
于 2013-06-20T04:03:38.947 回答
0

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

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，可以使用上述链接中的 shim

于 2013-06-20T04:05:25.377 回答