30:T6c2,Podemos explicar *arrays* de uma forma simplória, dizendo que são variáveis que contém muitos valores, acessados através de um índice. Essa é uma explicação que funcionará para que seja usada na programação, ainda que a questão seja bem mais complexa que isso em termos computacionais. Quando lidamos com dados simples, como uma coordenada ou um contador de quantas vezes algo já foi realizado ao longo do código, é mais prático e conveniente usarmos variáveis para registrar estas informações; mas quando lidamos com muitos dados que precisam ser processados, transformados e recalculados com frequência, usar *arrays* será mais prático. Em síntese: se há algo sendo feito de forma muito repetitiva envolvendo muitas variáveis, você deveria estar usando uma *array*. Uma *array* pode ser descrita com a representação abaixo. Nela temos o exemplo de `arr`, que contém **${arr.length}** valores diferentes associados a ela, que serão acessíveis através de índices de **0** a **${arr.length - 1}**.

Índice	0	1	2	3	4
arr =	${arr[0]}	${arr[1]}	${arr[2]}	${arr[3]}	${arr[4]}

Isto é declarado em javascript da seguinte maneira: ```js let arr = [32, 61.67, -40, 1450, 3]; ``` Outra forma de fazer a mesma declaração é inserindo na *array* valores um por um: ```js let arr = []; arr[0] = 32; arr[1] = 61.67; arr[2] = -40; arr[3] = 1450; arr[4] = 3; ```31:T5ae,Podemos fazer cálculos ou processamento sequencial em uma *array, o que torna seu uso muito conveniente quando temos muitas informações registradas. Utilizaremos uma *função* presente em todas as *arrays, chamada `map()`, que passará por todos os valores registrados nela, e operando algum tipo de processamento sobre eles. `map()` tem uma sintaxe complexa, por que recebe uma nova função como parâmetro. A função que ele recebe como parâmetro é exatamente o processamento que se deseja aplicar sobre os valores registrados na *array. Esta sintaxe funciona da seguinte forma: ```js let NovaArray = ArrayAntiga.map ( function (valor, indice) { // processamento desejado return NovoDado; } ); ``` Também é comum encontrarmos esta *função* sendo utilizada com a sintaxe específica do ECMAScript 6.0 (ES6). Trata-se da mesma coisa, apenas escrita de uma forma mais reduzida, assim como `x++` é uma forma de escrita reduzida de `x = x + 1`: ```js let NovaArray = ArrayAntiga.map ( (valor, indice) => { // processamento desejado return NovoDado; } ); ``` Realizaremos abaixo o processamento dos dados de `arr`. A operação fará uma divisão por **4.2** sobre todos os valores de `arr` (e colocará os resultados em outra *array* chamada `arr2`):32:T66b,Javascript é uma das poucas linguagens de programação que nos permite usar palavras (Strings) como índices das *arrays*. Quando organizamos o conteúdo de uma estrutura de dados por *strings*, chamamos essas *arrays* de *arrays associativas*, pois no fundo cada palavra (*string*) representa um índice numérico dentro da estrutura. A sintaxe para se declarar *arrays associativas* é ligeiramente diferente das *arrays ordinárias*: ```js associativa = [ 'termoA': 10, 'outroTermo': -40, 'nada': false, 'Fruta': 'Laranja', 'Matriz': [10,50,-40,1520], 'final' : 0 ]; ``` A única diferença para a declaração de *arrays* organizadas por índices numéricos, é que precisamos informar qual é o termo (*string*) que indexará aquele valor, com a sintaxe: ```js "termo": valor ``` e para acessar os respectivos valores, utilizamos **`associativa["Fruta"]`** ou **`associativa.Fruta`**. Como se trata do uso de *strings* como índice, essas referências podem conter espaços e caracteres especiais, como por exemplo: ```js associativa["Termo com espaço"] = true; ``` Mas nesses casos, a única forma de se acessar os valores é pela sintaxe **`associativa["Termo com espaço"]`**. Também podemos associar novos registros organizados por *string* nestas *arrays* com este mesmo tipo de sintaxe: ```js associativa.NovoDado = 10; ``` E quando temos uma outra *array* como dados dentro de uma *array associativa*, os acessamos com **`associativa["Matriz"][2]`** ou **`associativa.Matriz[2]`** (cujo valor é **-40**).33:[] 2e:{"title":"Arrays","cells":[{"id":0,"value":"# Arrays","pinned":false,"hidden":false,"mode":"md"},{"id":7,"value":"### Uma forma mais inteligente e poderosa para trabalhar com variáveis\n\n------\n\n","pinned":false,"hidden":false,"mode":"md"},{"id":43,"value":"$30","pinned":false,"hidden":false,"mode":"md"},{"id":454,"value":"arr = [32, 61.67, -40, 1450, 3]","pinned":false,"hidden":false,"mode":"ojs"},{"id":487,"value":"Como se vê, em termos práticos, uma *array* acabará se comportando como uma variável, com a única diferença de necessitar ser referenciada com um índice, informado através de colchetes (`variável[índice]`). ","pinned":false,"hidden":false,"mode":"md"},{"id":497,"value":"$31","pinned":false,"hidden":false,"mode":"md"},{"id":506,"value":"```js\narr2 = arr.map( function(v) {\n let calculo = v/4.2;\n return calculo;\n});\n```","pinned":false,"hidden":false,"mode":"md"},{"id":508,"value":"arr2 = arr.map(function (v) {\n return v / 4.2;\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":501,"value":"Estamos falando de um conjunto de **5** números, e parece que fazer um procedimento desses é algo um tanto exagerado (e que poderia ser feito facilmente através de variáveis comuns)... mas como seria fazer isso se tivéssemos **5000** números ao invés de **5**?\n\nO grande potencial da computação está em fazermos tarefas repetitivas em grande escala, algo que seria tedioso demais para pessoas realizarem, ou onde correríamos grande risco de uma falha humana pela própria repetição. Se iremos explorar a computação para o cálculo de **5** registros, **5000** registros, ou **5 milhões** de registros, o trabalho será o mesmo. Quando temos informações semelhantes armazenadas em variáveis diferentes, temos um indicativo de que seja o caso de se usar *arrays*, pois isso permitirá que a quantidade de registros aumente sem que seja necessário refazer ou repensar o código para processá-los.","pinned":false,"hidden":false,"mode":"md"},{"id":804,"value":"Mas como isso pode ser útil?\n\nSerá algo bastante prático quando for necessário realizar algo muitas vezes, com parâmetros diferentes. No exemplo abaixo, desenhamos diversas bolas, a partir dos dados informados na variável `arr`, na linha `3` do código:","pinned":false,"hidden":false,"mode":"md"},{"id":806,"value":"

","pinned":false,"hidden":false,"mode":"html"},{"id":812,"value":"Experimente incluir mais valores na variável `arr`, e executar novamente o código, para ver o que acontece.","pinned":false,"hidden":false,"mode":"md"},{"id":623,"value":"Qualquer tipo de valor pode ser associado a uma *array* não somente números. Podemos inclusive, misturar os tipos de dados:\n\n```js\ndados=[];\ndados[0] = \"Laranja\";\ndados[1] = 20.5;\ndados[2] = true;\ndados[3] = mVar;\ndados[4] = outraArray[2] + arr[0] + 50;\n```\n","pinned":false,"hidden":false,"mode":"md"},{"id":627,"value":"Podemos até incluir uma *array* dentro de um (ou vários) registros de outra *array*:\n\n```js\ndadoscomplexos = []\ndadoscomplexos[0] = \"Azul\";\ndadoscomplexos[1] = [10, 20, 100, -40, 12];\ndadoscomplexos[2] = arrIndividual[2];\ndadoscomplexos[3] = dados;\n```\n\nNeste caso, para acessar o valor **`12`** registrado como parte do conjunto de dados em `dadoscomplexos[1]`, você precisará referenciá-lo como `dadoscomplexos[1][4]` ou para acessar o valor **`Laranja`** em `dadoscomplexos[3]`, precisará referenciá-lo como `dadoscomplexos[3][0]`.\n\nEste tipo de articulação é bastante comum, e são chamadas de **matrizes bidimensionais**. Podemos encontrar também **matrizes tridimensionais** e **n-dimensionais**, pois não há limite para estes encadeamentos, além da legibilidade do código (e do bom senso na programação). O grande problema do uso de *arrays* é que elas tornam a leitura e compreensão do código mais difícil do que com variáveis simples.","pinned":false,"hidden":false,"mode":"md"},{"id":634,"value":"\n-----\n","pinned":false,"hidden":false,"mode":"md"},{"id":636,"value":"## Arrays associativas","pinned":false,"hidden":false,"mode":"md"},{"id":638,"value":"$32","pinned":false,"hidden":false,"mode":"md"},{"id":652,"value":"Todas as *arrays* (associativas ou não), possuem alguns registros internos (associativos) presentes e atualizados a cada novo dado incluído ou alterado nela. Um exemplo já visto é a *função* `.map()`, um registro associativo que também poderia ser acessado como **`arr['map']()`**, ou outro que é frequentemente utilizado, o `.length`, também disponível como `['length']` que nos informa quantos registros estão contidos dentro daquela *array*. Por exemplo, `arr.length` nos informará **`${arr.length}`**.","pinned":false,"hidden":false,"mode":"md"},{"id":695,"value":"

","pinned":false,"hidden":false,"mode":"md"}],"files":"$W33","stdlib":"1","titling":"auto"}