在javascript中操作多维数组

让数组操作的最后一部分正常工作让我发疯。 基本上，我有：

var array1 = [
  ["2", "1007"],
  ["5", "1042"],
  ["3", "1076"],
]

我想要这个

var array2 = [
  ["2", "1007", "1008"],
  ["5", "1042", "1043", "1044", "1045", "1046"],
  ["3", "1076", "1077", "1078"],
]

换句话说，我想使用每个子组的第一个元素作为计数器来驱动对第二个元素的连续添加。这是我一直坚持的后一部分，我不明白为什么我的代码不能工作。小提琴把操作分解成简单的部分。这将用于大约12000行，因此我认为我目前使用多个“forEach”循环的方法不是最快的。如果您有任何关于更好性能的想法，同时仍然可以阅读，我们将非常欢迎

var array1 = [
  ["2", "1007"],
  ["5", "1042"],
  ["3", "1076"],
]

array2 = []
console.table(array1)

//--------

array1.forEach(e => {
  for (var counter = 0; counter < e[0]; counter++) {
    array2.push(e);
  }
});

console.table(array2);

//--------


var myCol2 = 1007
var mycounter = 0

array2.forEach(e => {

  if (e[1] == myCol2) {
    mycounter = mycounter + 1
    var myinteger = parseInt(e[1]) + mycounter // convert ref. to number
    myinteger = myinteger.toString(); // convert ref. back to string

    e[1] = myinteger
    myCol2 = e[1]
  }
  else
  {
    myCol2 = e[1]
    mycounter = 0
  }

});

console.table(array2);

Fiddle:

您可以使用.map来根据内部数组中提供的第一个值将每个内部数组转换为自身的扩展版本，而不是使用.forEach，如下所示：

常数arr=[ [2, 1007], [5, 1042], [3, 1076], ]; const res=arr.map[r，start]=>{//使用destructuring获取内部数组的第一个和第二个元素 const ret=[]；//创建一个临时数组来保存连续整数 forlet i=+start；i代替使用.forEach，您可以使用.map根据内部数组中提供的第一个值将每个内部数组转换为自身的扩展版本，如下所示：

常数arr=[ [2, 1007], [5, 1042], [3, 1076], ]; const res=arr.map[r，start]=>{//使用destructuring获取内部数组的第一个和第二个元素 const ret=[]；//创建一个临时数组来保存连续整数

---

forlet i=+start；i可以迭代数组，获取内部数组并填充它，直到达到所需的计数

函数填充数组{ 对于数组的let{ 设[i，v]=a； 而-i a.push++v.toString； } } 变量数组1=[ [2, 1007], [5, 1042], [3, 1076], ]; Fillary1；

---

logarray1；您可以迭代数组，获取内部数组并填充它，直到达到所需的计数

函数填充数组{ 对于数组的let{ 设[i，v]=a； 而-i a.push++v.toString； } } 变量数组1=[ [2, 1007], [5, 1042], [3, 1076], ]; Fillary1；

---

console.logarray1；对于更紧凑的版本，您可以使用Array.reduce和一些ES6扩展：

const arr2 = array1.reduce((acc,[count,start])=>{
   const vals = [...Array(+count).keys()].map(val=>`${+start+val}`)
   return [...acc, [`${count}`,...vals]]
 },[])

甚至可以作为一个班轮：

var arr2 = array1.reduce((acc, [count, start])=> [...acc, [`${count}`,...[...Array(+count).keys()].map(val=>`${+start+val}`)]]
,[])

编辑：反射时，Array.map优于：

var arr2 = array1.map(([count, start])=> [count, ...[...Array(+count).keys()].map(val=>`${+start + +val}`)])

---

对于更紧凑的版本，您可以使用Array.reduce和一些ES6扩展：

const arr2 = array1.reduce((acc,[count,start])=>{
   const vals = [...Array(+count).keys()].map(val=>`${+start+val}`)
   return [...acc, [`${count}`,...vals]]
 },[])

甚至可以作为一个班轮：

var arr2 = array1.reduce((acc, [count, start])=> [...acc, [`${count}`,...[...Array(+count).keys()].map(val=>`${+start+val}`)]]
,[])

编辑：反射时，Array.map优于：

var arr2 = array1.map(([count, start])=> [count, ...[...Array(+count).keys()].map(val=>`${+start + +val}`)])

---

这很好，解释得很清楚，我能理解。将每个内部数组转换为自身的扩展版本正是我一直坚持的。非常感谢您的帮助。这很好，解释得很清楚，我能理解。将每个内部数组转换为自身的扩展版本正是我一直坚持的。哟非常感谢您的帮助。array1.map[n，s]=>[n，…Array+n.fill.map，i=>`${+s+i}`]；但请注意，这并不能满足您最快的要求，这只是一种有趣的方式：array1.map[n，s]=>[n，…Array+n.fill.map，i=>`${+s+i}`；但请注意，这并不能满足您最快的要求，这只是一种有趣的方式：