如何将一个数组拆分为多个数组，每个数组都有一个唯一的名称

Question

我有一个数组 = [A,1,0,1,0,1,B,1,0,0,1,A,1] 我需要将此数组拆分为多个数组。拆分将发生在“A”或“B”位置，如下面的新数组所示。新数组的名称使用字符串“group”加上从 1 或 0 开始的递增数字。 最终结果应如下所示：

group1 = [A,1,0,1,0,1]
group2 = [B,1,0,0,1]
group3 = [A,1]

我可以通过创建一个数组 (arrTemp) 来获取我需要的数组部分，这样我就可以存储位置（索引），然后使用 slice() 来获取我想要的部分 (A,1,0,1 ,0,1)、(A,1,0,0,1) 和 (A,1)。但我不知道如何将 slice() 的结果存储在唯一名称递增 1 的数组中。 这是我迄今为止尝试过的：

var arr = [A,1,0,1,0,1,B,1,0,0,1,A,1];
arr.forEach(myFunction)
function myFunction(item, index)    {
if ((item=="A") || (item=="B")) {
arrTemp.push(index);
arrTemp=arrTemp; //not sure I need this. I did this so it array would be global
}
}
for (var i = 0; i < arr.length; i++){
sectArray = arr.slice(arrTemp[i]+1,arrTemp[i + 1])
'group' + [i] = [arrTemp[i],sectArray]; //here is my problem.
}

Answer 1

您似乎正在尝试动态创建变量。这似乎很棘手，可能行不通。您可能应该拥有的是一些结果集合。可能是一个包含所有这些的父数组。

例如：

var containerArray = [];

然后：

for (var i = 0; i < arr.length; i++){
    sectArray = arr.slice(arrTemp[i]+1,arrTemp[i + 1])
    containerArray[i] = [arrTemp[i],sectArray];
}

现在containerArray 将拥有你所有的东西。您也可以对对象执行此操作：

var containerObject = {};

之后也是一样。

Answer 2

这里只需要一个循环，保留一个空的临时数组，遍历 arr 并在每次看到“A”或“B”时将元素推入 temp 将 temp 推入最终数组，最后将 temp 再次推入final 数组，因为最后一部分将被留下。

var arr = ['A',1,0,1,0,1,'B',1,0,0,1,'A',1];
var temp = [];
var sectArray = [];
arr.forEach(myFunction)
function myFunction(item, index)    {
if (((item=="A") || (item=="B")) && temp.length) {
sectArray.push(temp);
temp = [item];
}else{
 temp.push(item);
}
}
sectArray.push(temp);
console.log(sectArray);

Answer 3

检查这个使用字符串和数组方法组合的解决方案：

var data = ['A',1,0,1,0,1,'B',1,0,0,1,'A',1];

var results = data.toString().split(/(?=[a-zA-Z]+)/)
.map(function(value){
  return value.split(',').filter(function (item) {
    return item.length ? true: false;
  })
})
.map(function(item) {
   return item.map(function (value) {
     return isNaN(parseInt(value)) ? value : parseInt(value);
   })
});

console.log(results);

// results = [["A", 1, 0, 1, 0, 1], ["B", 1, 0, 0, 1], ["A", 1]]

Answer 4

使用Array#reduce 函数的另一种解决方案。

var x = ["A", 1, 0, 1, 0, 1, "B", 1, 0, 0, 1, "A", 1];


function reformat(arr) {
    var smallArrCounter = 0;
    return arr.reduce(function (acc, item) {
        if (item === "A" || item === "B") {
            acc["group" + (++smallArrCounter)] = [item];
        } else {
            acc["group" + smallArrCounter].push(item);
        }
        return acc;
    }, {});
}

var result =  reformat(x);

console.log(result.group1); // ["A",  1,  0,  1,  0,  1]
console.log(result.group2); // ["B",  1,  0,  0,  1]
console.log(result.group3); // ["A", 1]

Answer 5

可能有一种更高效的方法，不需要数组的两次迭代，但我的想法是：

1. 确定组分隔符（字符）的索引
2. 根据这些分隔符将数组分割成组，使用下一个索引作为结尾，如果分割最后一组，则使用arr.length

这假设数组分隔符可能事先不知道。

const charIndices = [];
const groups = [];
const arr = ['A',1,0,1,0,1,'B',1,0,0,1,'A',1];
// get the indices of the characters
arr.forEach((v, i) => ('' + v).match(/[A-Z]+/) ? charIndices.push(i) : undefined);
// use the found indices to split into groups
charIndices.reduce((a, b, i) => {
   a.push(arr.slice(b, charIndices[i+1] ? charIndices[i+1]-1 : arr.length));
   return a;
}, groups);
console.log(groups);