Question

给定一个数组和一个（变量）整数n，我想创建一个包含n个连续元素数组的新数组。我有它，如果n = 2但我无法计算如何启用变量n：

var arr = ["first", "second", "third", "fourth", "fifth", "sixth" ];
var int = 3;

function consecEls(array, int) {
    newArr = arr.map(function(val, ix, arr) {
        var next = ix+1; // this works if I only needed firstsecond, secondthird, etc. but I need arbitrary # of consecutive els
        // var next = ... ? ... next n els

        var els = arr.slice(arr[ix], int); // or slice(ix, int) ... both return  ["first", "second", "third"]

        if (next !== arr.length) {
            return val + arr[next];
        }
        else { return val; }
    }) // forEach
    return newArr;
}

consecEls(arr, int);

非常感谢任何见解，

=============================================== =

正如我在下面的评论中所提到的，这是我对@ gyre解决方案的略微修改版本：

var arr = ["first", "second", "third", "fourth", "fifth", "sixth" ];

function map(array, groupSize, callback, context) {
    var i = 0;
    var result = [];
    while (i < array.length) {
        result.push(
          callback.call(context, array.slice(i, i + groupSize), i, array)
        )
        i ++
    }
    return result
}

map(arr, 2, function (e) { 
    return e.join("")
})

=============================================== =

好的，还有一个更快的编辑：我稍微调整一下，以消除回调：

function map(array, groupSize) {
    var i = 0;
    var result = [];
    while (i < array.length) {
        result.push(array.slice(i, i + groupSize).join(""))
    i ++
    }
    return result
}
map(array, n);

Answer 1

编辑： @torazaburo's idea实际上是比我原来的功能更好的关注点分离。我没有意识到将数组拆分成固定长度组的过程有一个名称。但是，这是我partition函数的替代实现，因为我认为它可能更清晰，并包含一个可选的offset参数，以允许跳过前几个元素：

＆＃13;

function partition (array, size, offset) {
    offset |= 0
    var result = []
    while (offset < array.length) {
        result.push(array.slice(offset, offset += size))
    }
    return result
}

var arr = ["first", "second", "third", "fourth", "fifth", "sixth" ],
    example

// Groups of three, joined by spaces
example = partition(arr, 3).map(function (e) { 
    return e.join(' ')
})
console.log(example) //=> ["first second third", "fourth fifth sixth" ]

// A list of pairs
example = partition(arr, 2)
console.log(example) //=> [ ["first", "second"], ["third", "fourth"], ["fifth", "sixth"] ]

// A list of one-element arrays, skipping the first element
example = partition(arr, 1, 1)
console.log(example) //=> [ ["second"], ["third"], ["fourth"], ["fifth"], ["sixth"] ]

＆＃13;

原文：好吧，好像我第一次误解了你的问题。看起来你的目标是映射数组元素组;比方说，一次而不是一对。

下面是一个函数map，它接受与原始Array#map类似的参数。不要让功能签名过多地威胁你;它非常易于使用，您很少需要传递三个以上的参数。

function map(array, groupSize, callback, offset, context) {

<强>参数：

array - 要映射的数组。
groupSize - 您希望一次看到的元素数量。
callback - 您传递的映射函数，它接收 1）一组元素， 2）第一个元素的索引在当前组中， 3）原始数组。
offset - 第一组应该开始的索引;允许跳过元素。
context - 确定回调中绑定的this。

<强>返回：

一个数组，按顺序包含对每组元素的callback调用的返回值。

<强>演示：

＆＃13;

var arr = ["first", "second", "third", "fourth", "fifth", "sixth" ],
    example

// Groups of three, joined by spaces
example = map(arr, 3, function (e) { 
    return e.join(' ')
})
console.log(example) //=> ["first second third", "fourth fifth sixth" ]

// A list of pairs
example = map(arr, 2, function (e) { 
    return e
})
console.log(example) //=> [ ["first", "second"], ["third", "fourth"], ["fifth", "sixth"] ]


function map(array, groupSize, callback, offset, context) {
    var i = offset | 0,
        result = []
    while (i < array.length) {
        result.push(
          callback.call(context, array.slice(i, i + groupSize), i, array)
        )
        i += groupSize
    }
    return result
}

＆＃13;

Answer 2

array.slice()如果你想保留原始数组要么 array.splice()如果要从原始数组中删除项目对于这两个函数，您将起始索引和从该起始索引的元素数传递到＆＃34; select / cut＆＃34;来自原始数组

Answer 3

我认为你正在寻找的是＆＃34; chunking＆＃34;或＆＃34;分区＆＃34;。这是指根据某些标准（通常是长度）将数组拆分为子数组。那里有很多分区解决方案;这里我们使用一个非常简单的。但请注意，这会破坏原始数组。

一旦你对输入进行了分区，在你的情况下你想要连接每个子数组的元素，所以

＆＃13;

function partition(array, n) {
  return array.length ? [array.splice(0, n)].concat(partition(array, n)) : [];
}   

var arr = ["first", "second", "third", "fourth", "fifth", "sixth" ];
var int = 3;

const result = partition(arr, int).map(subarray => subarray.join(''))

console.log(result);

＆＃13;

这是一个更直接的分区实现：

function partition(array, n) {
  let result = [], cnt = 0, sub;

  for (let i = 0; i < array.length; i++) {
    if (!cnt--) cnt = n, result.push(sub = []);
    sub.push(array[i]);
  }

  return result;
}

获取n个连续的数组元素

3 个答案: