Impressionante! Você acabou de aprender uma tonelada sobre arrays! Esta foi uma visão geral de alto nível, e há muito mais a aprender sobre como trabalhar com matrizes, muitas das quais você verá em seções posteriores. Mas antes de pensar em objetos , vamos dar mais uma olhada e ver como as matrizes podem se tornar um pouco mais complexas do que as que vimos nos desafios anteriores. Uma das características mais poderosas quando se pensa em matrizes como estruturas de dados, é que as matrizes podem conter, ou mesmo serem completamente compostas por outras matrizes. Vimos matrizes que contêm matrizes em desafios anteriores, mas que são bem simples. No entanto, os arrays podem conter uma profundidade infinita de arrays que podem conter outros arrays, cada um com seus próprios níveis arbitrários de profundidade, e assim por diante. Dessa forma, um array pode se tornar muito rapidamente uma estrutura de dados muito complexa, conhecida como array multidimensional ou aninhado. Considere o seguinte exemplo:

vamos nestedArray = [// top, ou primeiro nível - o array mais externo
['deep'], // uma matriz dentro de uma matriz, 2 níveis de profundidade
[
['deep'], ['deep'] // 2 arrays aninhados 3 níveis de profundidade
]
[
[
['deepest'], ['deepest'] // 2 arrays aninhados em 4 níveis de profundidade
]
[
[
['deepest-est?'] // uma matriz aninhada a 5 níveis de profundidade
]
]
]
];

Embora esse exemplo possa parecer complicado, esse nível de complexidade não é inédito, ou mesmo incomum, ao lidar com grandes quantidades de dados. No entanto, ainda podemos acessar com facilidade os níveis mais profundos de um array neste complexo com a notação de colchetes:

console.log (nestedArray [2] [1] [0] [0] [0]);
// logs: deepest?

E agora que sabemos onde estão esses dados, podemos redefini-los se precisarmos:

nestedArray [2] [1] [0] [0] [0] = 'ainda mais profundo';

console.log (nestedArray [2] [1] [0] [0] [0]);
// agora registra: mais fundo ainda

```yml tests: - text: 'myNestedArray deve conter apenas números, booleanos e cadeias de caracteres como elementos de dados' testString: 'assert.strictEqual((function(arr) { let flattened = (function flatten(arr) { const flat = [].concat(...arr); return flat.some (Array.isArray) ? flatten(flat) : flat; })(arr); for (let i = 0; i < flattened.length; i++) { if ( typeof flattened[i] !== "number" && typeof flattened[i] !== "string" && typeof flattened[i] !== "boolean") { return false } } return true })(myNestedArray), true, "myNestedArray should contain only numbers, booleans, and strings as data elements");' - text: myNestedArray deve ter exatamente 5 níveis de profundidade testString: 'assert.strictEqual((function(arr) {let depth = 0;function arrayDepth(array, i, d) { if (Array.isArray(array[i])) { arrayDepth(array[i], 0, d + 1);} else { depth = (d > depth) ? d : depth;}if (i < array.length) { arrayDepth(array, i + 1, d);} }arrayDepth(arr, 0, 0);return depth;})(myNestedArray), 4, "myNestedArray should have exactly 5 levels of depth");' - text: myNestedArray deve conter exatamente uma ocorrência da string "deep" em uma matriz aninhada em 3 níveis de profundidade testString: 'assert((function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, "deep").length === 1 && (function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, "deep")[0] === 2, "myNestedArray should contain exactly one occurrence of the string "deep" on an array nested 3 levels deep");' - text: myNestedArray deve conter exatamente uma ocorrência da string "deeper" em uma matriz aninhada em 4 níveis de profundidade testString: 'assert((function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, "deeper").length === 1 && (function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, "deeper")[0] === 3, "myNestedArray should contain exactly one occurrence of the string "deeper" on an array nested 4 levels deep");' - text: myNestedArray deve conter exatamente uma ocorrência da string "deepest" em uma matriz aninhada em 5 níveis de profundidade testString: 'assert((function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, "deepest").length === 1 && (function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, "deepest")[0] === 4, "myNestedArray should contain exactly one occurrence of the string "deepest" on an array nested 5 levels deep");' ```