Arrays em Golang
Tags: go, beginners, tutorial
Published: 2020-06-02 21:13:42

Se você já teve contato com outras linguagens, então deve conhecer o array. Em Go eles não são tão diferentes, mas você precisa saber que ele não é o mais utilizado. 

Você deve está pensando: *"Nossa, o que vamos utilizar no lugar do array?*
A resposta é fácil: **Vamos utilizar slices**.

Antes de estudarmos slice, é preciso conhecer um pouco sobre o array, pois ele será a nossa base. Então vamos lá... 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/6imvev7xi7e44eicr70q.jpg)

Primeiro pense na sua rua. Existem várias casas, incluindo a sua. Cada casa ocupa o espaço e tem um número para ser identificada. Essa mesma lógica se aplica aos arrays. 

 ![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/vxzzmdojb0k8blwb8hln.png)

Só que ao invés de casas, vamos ter dados. Ao invés de espaço na rua, ele ocupará um espaço na memoria do computador. E o número da casa se chamará índex ou índice. 

O array é um tipo de dado composto, ele será formado por vários elementos do mesmo tipo. Posso ter um array com varias variáveis do tipo int, outro só com tipos strings e por ai vai. 

Outro detalhe que vale ser lembrado é que o índice do array sempre começa do 0. Então se um array for composto por 6 elementos, o índice irá do 0 a 5.

Já falamos demais, vamos para a parte boa.

```golang
arrayDeNumeros := [5]int{1, 2, 3, 4, 5}

fmt.Println(arrayDeNumeros)
``` 
``[5]int{1, 2, 3, 4, 5}`` essa é a forma de declaração mais utilizada, mas não é a única. Antes de conhecermos as outras, vamos entender os detalhes. 

Percebam que estamos indicando o número de elementos que nosso array vai suportar, o length. Esse número é fixo, uma vez declarado, não pode aumentar, ou seja, não podemos adicionar novos elementos ao nosso array.

Podemos alterar os 5 elementos já existentes, mas não adicionar um sexto.

Adicionar novos elemento a um array é uma ação comum em outras linguagem, mas aqui não pode ser realizada. *Não surte ainda, isso pode ser feito com slices*

```golang
var arrayDeNumeros [5]int 

arrayDeNumeros[0], arrayDeNumeros[1], arrayDeNumeros[2] = 1, 2, 3
arrayDeNumeros[4] = 4

fmt.Println(arrayDeNumeros)

/*
Resultado: [1, 2, 3, 4, 0]
*/
```  
Agora estamos declarando o array e atribuindo valor para seus elementos de forma separada. Um dos elementos não teve seu valor definido, então ele será zero.

##For e arrays##

```golang
arrayDeNumeros := [5]int{1, 2, 3, 4, 5}

for i:=0; i < len(arrayDeNumeros); i++{
    fmt.Printf("Indice: %v - Valor: %v\n", i, arrayDeNumeros)
}

fmt.Println(" ")

for i, valor := range arrayDeNumeros{
   fmt.Printf("Indice: %v - Valor: %v\n", i, valor)
} 

/*
Resultado:
Indice: 0 - Valor: 1
Indice: 1 - Valor: 2
Indice: 2 - Valor: 3
Indice: 3 - Valor: 4
Indice: 4 - Valor: 5
*/
```
O resultado será exatamente o mesmo. 

Caso você não tenha entendido o ``for`` 👇🏽

{% link https://dev.to/linivecristine/loop-for-range-em-go-39n7 %}

Agora vamos atribuir novos valores aos elementos.

```golang
arrayDeNumeros := [5]int{1, 2, 3, 4, 5}


for i, valor := range arrayDeNumeros{
    arrayDeNumeros[i] = valor + 10
} 

fmt.Println(arrayDeNumeros)

/*
Resultado: {11, 12, 13, 14, 15}
*/
```

Para mudar o valor de um elemento do array, é so chama-lo junto com o índice que queremos alterar: ``arrayDeNumeros[2]``. Depois é só passar o novo valor:  ``arrayDeNumeros[2] = 33``. Nessa caso, o elemento 3 (índice 2) terá seu valor igual a 33. 

Bem, de array é o que temos. Só precisamos saber que seu número de elementos é fixo, como declarar, iniciar um array e como fazer um loop com ele, pois são coisas que iremos utilizar nos slices.

Espero que tenham entendido. 

Fiquem bem e para não perder o costume...
👉🏽 [curso](https://youtu.be/WiGU_ZB-u0w) 👈🏽

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/6z70sd2569pe23nalziy.gif)