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

Question

我有一个数组= [A，1,0,1,0,1，B，1,0,0,1，A，1] 我需要将此数组拆分为多个数组。分裂将发生在＆＃34; A＆＃34;或＆＃34; B＆＃34;位置如下面的新数组中所示。新数组的名称使用字符串＆＃34; group＆＃34;加上以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推入最后一个数组，因为最后一节将被保留。

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

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

＆＃13;

＆＃13;

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]]

＆＃13;

＆＃13;

＆＃13;

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切割最后一个组

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

＆＃13;
＆＃13;
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);
＆＃13;
＆＃13;
＆＃13;