# Arrays e Slices em Golang

## Arrays (Tamanho Fixo)

Em Go, arrays têm tamanho fixo, ou seja, o número de elementos não pode ser alterado depois que o array é criado.

### Exemplo de Array com Tamanho Fixo:

```go
var sites [4]string
```

* O array `sites` pode armazenar exatamente 4 elementos do tipo `string`.
    
* O tamanho do array é uma parte de seu tipo, então arrays com diferentes tamanhos são considerados tipos diferentes.
    

## Slices (Tamanho Dinâmico)

Diferente dos arrays, slices podem ter tamanho variável e são mais flexíveis. Eles são usados com mais frequência devido à sua capacidade de crescer e diminuir dinamicamente.

### Exemplo de Slice (Tamanho Dinâmico):

```go
var sites []string
```

* `sites` é um slice de `string`, sem um tamanho fixo, que pode ser redimensionado conforme necessário.
    
* Diferente dos arrays, slices não são definidos com um número fixo entre os colchetes.
    

## Inicializando Arrays e Slices com Itens

### Inicializando Arrays com Tamanho Fixo:

Quando você inicializa um array com valores, o tamanho deve ser explicitamente definido.

```go
var strs = [2]string{"aaa", "bbb"}
```

* Aqui, o array `strs` tem exatamente 2 elementos do tipo `string`.
    

### Inicializando Slices com Tamanho Dinâmico:

Slices podem ser inicializados sem precisar especificar um tamanho fixo entre os colchetes.

```go
var strs = []string{"aaa", "bbb"}
```

* Neste caso, `strs` é um slice de `string` com dois elementos, mas o número de elementos pode crescer ou diminuir ao longo do tempo.
    

## Métodos Importantes

### 1\. `append()`

O método `append()` é usado para adicionar elementos a um slice. Se o slice atingir sua capacidade máxima, o `append()` automaticamente cria um novo slice com maior capacidade.

#### Exemplo de uso de `append`:

```go
var strs = []string{"aaa", "bbb"}
strs = append(strs, "ccc", "ddd")
fmt.Println(strs) // Saída: [aaa bbb ccc ddd]
```

* Aqui, dois novos elementos são adicionados ao slice `strs`. O slice cresce dinamicamente conforme necessário.
    
* A função `append()` sempre retorna um novo slice, pois o slice original pode ter sua capacidade aumentada.
    

### 2\. `len()`

O método `len()` retorna o número de elementos no slice (ou array).

#### Exemplo de uso de `len`:

```go
var strs = []string{"aaa", "bbb", "ccc"}
fmt.Println(len(strs)) // Saída: 3
```

* O `len(strs)` retorna `3`, que é o número de elementos atualmente no slice `strs`.
    

### 3\. `cap()`

O método `cap()` retorna a capacidade total do slice, ou seja, o número de elementos que ele pode armazenar antes de precisar ser realocado.

#### Exemplo de uso de `cap`:

```go
var strs = []string{"aaa", "bbb"}
fmt.Println(cap(strs)) // Saída: 2 (dependendo do tamanho inicial do slice)
```

* A função `cap(strs)` retorna a capacidade do slice `strs`, que pode ser diferente do número de elementos (retornado por `len()`).
    
* Em um slice, a capacidade pode ser maior que o número de elementos, permitindo que o slice cresça sem realocações imediatas.
    

## Diferenças Principais

* **Arrays**: Têm tamanho fixo e o tamanho é parte do tipo.
    
* **Slices**: Têm tamanho dinâmico e são mais flexíveis para o uso diário em Go. Slices podem crescer conforme necessário usando o método `append()`.
    

## Resumo de Funções

* `append(slice, elements...)`: Adiciona elementos ao slice.
    
* `len(slice)`: Retorna o número de elementos no slice.
    
* `cap(slice)`: Retorna a capacidade do slice.