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

Question

我有一个数组= [A，1,0,1,0,1，B，1,0,0,1，A，1] 需要将这个数组分割成多个数组。分割将出现在“A”或“B”位置，如下面的新阵列所示。新阵列的名称中使用字符串“群”加一个递增的数字从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）。但我不知道如何来存储我的切片的结果（）的在递增唯一的名称由数组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进入最终阵列，因为最后一节将被留下。

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

使用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 4

有可能是不需要的阵列的两个迭代更高性能的方法，但我的想法是：

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

Answer 5

检查该溶液使用的串和阵列相结合的方法：

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