如何在JavaScript中将数组拆分为数组对？

我想把一个数组拆分成几对数组

var arr = [2, 3, 4, 5, 6, 4, 3, 5, 5]

会是

var newarr = [
    [2, 3],
    [4, 5],
    [6, 4],
    [3, 5],
    [5]
]

---

没有预烘焙函数可以做到这一点，但这里有一个简单的解决方案：

var splitPairs = function(arr) {
    var pairs = [];
    for (var i=0 ; i<arr.length ; i+=2) {
        if (arr[i+1] !== undefined) {
            pairs.push ([arr[i], arr[i+1]]);
        } else {
            pairs.push ([arr[i]]);
        }
    }
    return pairs;
};

function splitInto(array, size, inplace) {
    var output, i, group;

    if (inplace) {
        output = array;

        for (i = 0; i < array.length; i++) {
            group = array.splice(i, size);

            output.splice(i, 0, group);
        }
    } else {
        output = [];

        for (i = 0; i < array.length; i += size) {
            output.push(array.slice(i, size + i));
        }
    }

    return output;
}

var splitPairs=函数（arr）{
var对=[]；
对于（var i=0；i，这里有一个很好的通用解决方案：

var splitPairs = function(arr) {
    var pairs = [];
    for (var i=0 ; i<arr.length ; i+=2) {
        if (arr[i+1] !== undefined) {
            pairs.push ([arr[i], arr[i+1]]);
        } else {
            pairs.push ([arr[i]]);
        }
    }
    return pairs;
};

function splitInto(array, size, inplace) {
    var output, i, group;

    if (inplace) {
        output = array;

        for (i = 0; i < array.length; i++) {
            group = array.splice(i, size);

            output.splice(i, 0, group);
        }
    } else {
        output = [];

        for (i = 0; i < array.length; i += size) {
            output.push(array.slice(i, size + i));
        }
    }

    return output;
}

inplace
参数确定操作是否就地完成

下面是一个演示：


函数拆分为（数组、大小、就地）{
var输出，i，组；
如果（就地）{
输出=阵列；
对于（i=0；i}
这是一种与使用
for
循环进行比较略有不同的方法。为避免修改原始数组
切片
创建浅拷贝，因为JS通过引用传递对象

function pairArray(a) {
  var temp = a.slice();
  var arr = [];

  while (temp.length) {
    arr.push(temp.splice(0,2));
  }

  return arr;
}


var数组=[2,3,4,5,6,4,3,5,5]；
var newArr=pairArray（数组）；
功能配对（a）{
var temp=a.slice（）；
var-arr=[]；
while（温度长度）{
arr.push（温度拼接（0,2））；
}
返回arr；
}
document.write（''+JSON.stringify（newArr）+''）；
我会在这种情况下使用

以下是一个使用以下方法的解决方案：


var arr=[2,3,4,5,6,4,3,5,5]；
var newArr=U8;（arr）.reduce（函数（结果、值、索引）{
如果（索引%2==0）
结果：推送（arr.slice（索引，索引+2））；
返回结果；
}, []);
document.write（JSON.stringify（newArr））；//[[2,3]、[4,5]、[6,4]、[3,5]、[5]]
下面是另一个使用lodash助手的解决方案：


函数toPairs（数组）{
常量evens=array.filter（（o，i）=>i%2）；
常数赔率=数组。过滤器（（o，i）=>！（i%2））；
返回u.zipWith（偶数，赔率，（e，o）=>e？[o，e]：[o]）；
}
console.log（toPairs（[2,3,4,5,6,4,3,5,5]）；
以下是一个简短且更通用的解决方案：

initialArray.reduce(function(result, value, index, array) {
  if (index % 2 === 0)
    result.push(array.slice(index, index + 2));
  return result;
}, []);

函数拆分阵列输入（arr，n）{
var len=阵列长度
变量对=[]
对于（设i=0；i

其中，arr是您的数组，n是成对的编号
您可以使用js

还有一个问题是，已经发布的答案有点杂乱无章。添加它是因为阅读了答案后，我仍然觉得事情可能会更容易阅读：

var组=[]；
对于（变量i=0；i
Lodash有一种方法：

uu.chunk（[2,3,4,5,6,4,3,5,5]，2）；
//=>[[2,3]、[4,5]、[6,4]、[3,5]、[5]]
可以将数组分组为一行中的成对/块，而无需库：


函数块（arr，大小=2）{
返回arr.map（（x，i）=>i%size==0&&arr.slice（i，i+size））.filter（x=>x）
}
log（块（[1,2,3,4,5,6,7]）/->[[1,2]，[3,4]，[5,6]，[7]]
const items=[1,2,3,4,5]；
常量createBucket=（bucketItems，bucketSize）=>buckets=>{
返回bucketItems.length==0？buckets:[…buckets，bucketItems.splice（0，bucketSize）]；
};
const bucketWithItems=items.reduce（createBucket（[…items]，4），[]）；
现在有了灵活的
数组#平面图（值、索引、数组）
：

const pairs=arr.flatMap（（u，i，a）=>i%2？[]：[a.slice（i，i+2）]；

还有可能更高效，但看起来傻乎乎的
数组。来自（源代码，mapfn？
：

const pairs=Array.from（{length:arr.length/2}，（u，i）=>arr.slice（i*2，i*2+2））
这里是另一个使用生成器函数的通用解决方案


/**
*返回给定“iterable”中所有唯一元素对的“Generator”。
*@param iterable要查找其所有唯一元素对的集合。
*/
函数*对（iterable）{
const seenItems=新集合（）；
用于（iterable的const currentItem）{
如果（！seenItems.has（currentItem））{
for（seenItems的常数seenItem）{
收益率[seenItem，currentItem]；
}
请参见条目添加（当前项）；
}
}
}
常量数=[1,2,3,2]；
const pairsOfNumbers=成对（数字）；
log（Array.from（pairsofNumber））；
//[[1,2]，[1,3]，[2,3]]
这结合了上面的一些答案，但没有Object.fromEntires。输出类似于使用minimist得到的结果


constsplitparameters=（args）=>{
常量拆分=（arg）=>（arg.includes（“=”）？arg.split（“=”[arg]）；
返回args.reduce（（参数，arg）=>[…参数，…拆分（arg）]，[]）；
};
const createPairs=（args）=>
Array.from（{length:args.length/2}，（\ux，i）=>
参数切片（i*2，i*2+2）
);
常量createParameters=（对）=>
减少(
（标志、值）=>({
…旗帜，
…{[值[0]。替换（“-”，“”）]：值[1]}
}),
{}
);
常量getCliParameters=（参数）=>{
const pairs=createPairs（splitParameters（args））；
常量参数=createParameters（成对）；
控制台日志（参数）；
返回参数；
};
//const argsFromNodeCli=process.argv.slice（2）；//用于节点
常数testArgs=[
“--url”，
"https://www.google.com",
"-
initialArray.reduce(function(result, value, index, array) {
  if (index % 2 === 0)
    result.push(array.slice(index, index + 2));
  return result;
}, []);

var groups = [];

for(var i = 0; i < arr.length; i += 2)
{
    groups.push(arr.slice(i, i + 2));
}