Question

我有一个带有多个级别的数组，每个数组都是一个“天”，并且每天都有不同的事件（catalogo），目录是一个包含当天要提供的食物的数组。我遇到的问题是试图显示目录中的数据；

(4) [Array(7), Array(7), Array(7), Array(7)]
    0: Array(7)
      0: {fecha: 2019, id: 1553410800, mes: 3, catalogo: Array(1), …}
      1: {fecha: 2019, id: 1553410800, mes: 3, catalogo: Array(1), …}
      2: {fecha: 2019, id: 1553410800, mes: 3, catalogo: Array(1), …}
      3: {fecha: 2019, id: 1553410800, mes: 3, catalogo: Array(1), …}
      4: {fecha: 2019, id: 1553410800, mes: 3, catalogo: Array(1), …}
      5: {fecha: 2019, id: 1553410800, mes: 3, catalogo: Array(1), …}
      6:
        fecha: 2019
        id: 1553410800
        mes: 3
        catalogo: Array(2)
          0: {id: "1553929200", tipo: "food",…}
          1: {id: "1553995800", tipo: "food" …} 
    1: (7) [{…}, {…}, {…}, {…}, {…}, {…}, {…}]
    2: (7) [{…}, {…}, {…}, {…}, {…}, {…}, {…}]
    3: (7) [{…}, {…}, {…}, {…}, {…}, {…}, {…}]

这样做，我可以循环到子数组，如何循环/访问catalogo中的数据；

for ( var i = 0; i < data_array.length; i++ ) {
  var childArray = data_array[i];
  for( var j = 0; j < childArray.length; j++ ) { 
}

我已经尝试过了，但是没有用：

for ( var i = 0; i < data_array.length; i++ ) {
  var childArray = data_array[i];
  for( var j = 0; j < childArray.length; j++ ) { 
    var third_Array = childArray[j];
    for ( var k = 0; k < third_Array.length; k++) { 
      console.log(third_Array);
    }
  }
}

Answer 1

在没有实际数据的情况下很难测试，但请尝试以下操作：

const data = [Array(7), Array(7), Array(7), Array(7)]; // your data
data.forEach(day => {
    day.forEach(element => { 
        element.catalogo.forEach(c => { console.log(c); }))
    }
})

Answer 2

您已经关闭，但是您缺少访问密钥catalogo的权限。看起来应该像这样：

for ( var i = 0; i < data_array.length; i++ ) {
  var childArray = data_array[i];
  for( var j = 0; j < childArray.length; j++ ) { 
    var third_Array = childArray[j].catalogo; // <-- This is missing
    for ( var k = 0; k < third_Array.length; k++) { 
      console.log(third_Array[k]);
    }
  }
}

Answer 3

third_Array实际上不是数组。这个对象包含一个catalogo属性，该属性是一个数组，因此您应该遍历third_Array.catalogo。

我该怎么写：

 for(const weekPlan of data_array) {
   for(const dayPlan of weekPlan) {
     for(const dish of dayPlan.catalogo) {
       console.log(dish);
       //...
     }
   }
}

或者，如果您只对最低级别感兴趣：

 for(const dish of data_array.flat().flatMap(it => it.catalogo)) {
  //...
 }

Answer 4

根据您的数据结构，您需要迭代外部数组，然后迭代内部数组的每个元素，最后访问每个内部数组的catalogo属性并对其进行迭代。

我还将通过使用内置的Array.prototype.forEach()来简化您的语法。

const data = [
  [
    {
      catalogo: [
        { foo: 'bar00' },
        { foo: 'bar01' }
      ]
    },
    {
      catalogo: [
        { foo: 'bar02' },
        { foo: 'bar03' }
      ]
    }
  ],
  [
    {
      catalogo: [
        { foo: 'bar04' },
        { foo: 'bar05' }
      ]
    },
    {
      catalogo: [
        { foo: 'bar06' },
        { foo: 'bar07' }
      ]
    }
  ],
  [
    {
      catalogo: [
        { foo: 'bar08' },
        { foo: 'bar09' }
      ]
    },
    {
      catalogo: [
        { foo: 'bar10' },
        { foo: 'bar11' }
      ]
    }
  ]
];

data.forEach(
  (innerArray) => innerArray.forEach(
    (element) => element.catalogo.forEach(
      (item) => console.log(item.foo)
    )
  )
);

Answer 5

您似乎有一个嵌套有多个数组的数组你可以这样解决你的问题这是一个例子

let array = [
[0, 1, 2],
[1, 2, 3],
[2, 3, 4]
]
let arrayLength = array.length;
for (let i = 0; i < arrayLength; i++) {
 let items = array[i].length;
 console.log(i, items)
 for (let n = 0; n < items; n++) {
  console.log(array[i][n]);
 }
}

通过多级数组循环

5 个答案: