Arrays e slices
Arrays te permitem armazenar diversos elementos do mesmo tipo em uma variável em uma ordem específica.
Quando você tem um array, é muito comum ter que percorrer sobre ele. Logo, vamos usar nosso recém adquirido conhecimento de for para criar uma função Soma. Soma vai receber um array de números e retornar o total.
Também vamos praticar nossas habilidades em TDD.

Escreva o teste primeiro

Em soma_test.go:
1
package main
2
3
import "testing"
4
5
func TestSoma(t *testing.T) {
6
7
numeros := [5]int{1, 2, 3, 4, 5}
8
9
resultado := Soma(numeros)
10
esperado := 15
11
12
if esperado != resultado {
13
t.Errorf("resultado %d, esperado %d, dado %v", resultado, esperado, numeros)
14
}
15
}
Copied!
Arrays têm uma capacidade fixa que é definida quando você declara a variável. Podemos inicializar um array de duas formas:
  • [N]tipo{valor1, valor2, ..., valorN}, como numeros := [5]int{1, 2, 3, 4, 5}
  • [...]tipo{valor1, valor2, ..., valorN}, como numbers := [...]int{1, 2, 3, 4, 5}
Às vezes é útil também mostrarmos as entradas da função na mensagem de erro. Para isso estamos usando o formatador %v, que é o formato "padrão" e funciona bem com arrays.

Execute o teste

Ao executar go test, o compilador vai falhar com ./soma_test.go:10:15: undefined: Soma

Escreva o mínimo de código possível para fazer o teste rodar e verifique a saída do teste falhado

Em soma.go:
1
package main
2
3
func Soma(numeros [5]int) int {
4
return 0
5
}
Copied!
Agora seu teste deve falhar com uma mensagem clara de erro:
soma_test.go:13: resultado 0, esperado 15, dado [1 2 3 4 5]

Escreva código o suficiente para fazer o teste passar

1
func Soma(numeros [5]int) int {
2
soma := 0
3
for i := 0; i < 5; i++ {
4
soma += numeros[i]
5
}
6
return soma
7
}
Copied!
Para receber o valor de um array em uma posição específica, basta usar a sintaxe array[índice]. Nesse caso, estamos usando o for para percorrer cada posição do array (que tem 5 posições) e somar cada valor na variável soma.

Refatoração

Vamos apresentar o range para nos ajudar a limpar o código:
1
func Soma(numeros [5]int) int {
2
soma := 0
3
for _, numero := range numeros {
4
soma += numero
5
}
6
return soma
7
}
Copied!
O range permite que você percorra um array. Sempre que é chamado, retorna dois valores: o índice e o valor. Decidimos ignorar o valor índice usando _ blank identifier.

Arrays e seus tipos

Uma propriedade interessante dos arrays é que seu tamanho é relacionado ao seu tipo. Se tentar passar um [4]int dentro da função que espera [5]int, ela não vai compilar. Elas são de tipos diferentes e é a mesma coisa que tentar passar uma string para uma função que espera um int.
Você pode estar pensando que é bastante complicado que arrays tenham tamanho fixo, não é? Só que na maioria das vezes, você provavelmente não vai usá-los!
O Go tem slices, em que você não define o tamanho da coleção e, graças a isso, pode ter qualquer tamanho.
O próprio requerimento será somar coleções de tamanhos variados.

Escreva o teste primeiro

Agora vamos usar o tipo slice que nos permite ter coleções de qualquer tamanho. A sintaxe é bem parecida com a dos arrays e você só precisa omitir o tamanho quando declará-lo.
meuSlice := []int{1,2,3} ao invés de meuArray := [3]int{1,2,3}
1
func TestSoma(t *testing.T) {
2
3
t.Run("coleção de 5 números", func(t *testing.T) {
4
numeros := [5]int{1, 2, 3, 4, 5}
5
6
resultado := Soma(numeros)
7
esperado := 15
8
9
if resultado != esperado {
10
t.Errorf("resultado %d, want %d, dado %v", resultado, esperado, numeros)
11
}
12
})
13
14
t.Run("coleção de qualquer tamanho", func(t *testing.T) {
15
numeros := []int{1, 2, 3}
16
17
resultado := Soma(numeros)
18
esperado := 6
19
20
if resultado != esperado {
21
t.Errorf("resultado %d, esperado %d, dado %v", resultado, esperado, numeros)
22
}
23
})
24
25
}
Copied!

Execute o teste

Isso não vai compilar.
./soma_test.go:22:13: cannot use numbers (type []int) as type [5]int in argument to Soma
não é possível usar números (tipo []int) como tipo [5]int no argumento para Soma

Escreva o mínimo de código possível para fazer o teste rodar e verifique a saída do teste falhado

Para resolver o problema, podemos:
  • Alterar a API existente mudando o argumento de Soma para um slice ao invés de um array.Quando fazemos isso, vamos saber que podemos ter arruinado do dia de alguém, porque nosso outro teste não vai compilar!
  • Criar uma nova função
No nosso caso, mais ninguém está usando nossa função. Logo, ao invés de ter duas funções para manter, vamos usar apenas uma.
1
func Soma(numeros []int) int {
2
soma := 0
3
for _, numero := range numeros {
4
soma += numero
5
}
6
return soma
7
}
Copied!
Se tentar rodar os testes eles ainda não vão compilar. Você vai ter que alterar o primeiro teste e passar um slice ao invés de um array.

Escreva código o suficiente para fazer o teste passar

Nesse caso, para arrumar os problemas de compilação, tudo o que precisamos fazer aqui é fazer os testes passarem!

Refatoração

Nós já refatoramos a função Soma e tudo o que fizemos foi mudar os arrays para slices. Logo, não há muito o que fazer aqui. Lembre-se que não devemos abandonar nosso código de teste na etapa de refatoração e precisamos fazer alguma coisa aqui.
1
func TestSoma(t *testing.T) {
2
3
t.Run("coleção de 5 números", func(t *testing.T) {
4
numeros := []int{1, 2, 3, 4, 5}
5
6
resultado := Soma(numeros)
7
esperado := 15
8
9
if resultado != esperado {
10
t.Errorf("resultado %d, esperado %d, dado, %v", resultado, esperado, numeros)
11
}
12
})
13
14
t.Run("coleção de qualquer tamanho", func(t *testing.T) {
15
numeros := []int{1, 2, 3}
16
17
resultado := Soma(numeros)
18
esperado := 6
19
20
if resultado != esperado {
21
t.Errorf("resultado %d, esperado %d, dado %v", resultado, esperado, numeros)
22
}
23
})
24
25
}
Copied!
É importante questionar o valor dos seus testes. Ter o máximo de testes possível não deve ser o objetivo e sim ter o máximo de confiança possível na sua base de código. Ter testes demais pode se tornar um problema real e só adiciona mais peso na manutenção. Todo teste tem um custo.
No nosso caso, dá para perceber que ter dois testes para essa função é redundância. Se funciona para um slice de determindo tamanho, é muito provável que funciona para um slice de qualquer tamanho (dentro desse escopo).
A ferramenta de testes nativa do Go tem a funcionalidade de cobertura de código que te ajuda a identificar áreas do seu código que você não cobriu. Já adianto que ter 100% de cobertura não deve ser seu objetivo; é apenas uma ferramenta para te dar uma ideia da sua cobertura. De qualquer forma, se você aplicar o TDD, é bem provável que chegue bem perto dos 100% de cobertura.
Tente executar go test -cover no terminal.
Você deve ver:
1
PASS
2
coverage: 100.0% of statements
Copied!
Agora apague um dos testes e verifique a cobertura novamente.
Agora que estamos felizes com nossa função bem testada, você deve salvar seu trabalho incrível com um commit antes de partir para o próximo desafio.
Precisamos de uma nova função chamada SomaTudo, que vai receber uma quantidade variável de slices e devolver um novo slice contendo as somas de cada slice recebido.
Por exemplo:
SomaTudo([]int{1,2}, []int{0,9}) deve retornar []int{3, 9}
ou
SomaTudo([]int{1,1,1}) deve retornar []int{3}

Escreva o teste primeiro

1
func TestSomaTudo(t *testing.T) {
2
3
resultado := SomaTudo([]int{1,2}, []int{0,9})
4
esperado := []int{3, 9}
5
6
if resultado != esperado {
7
t.Errorf("resultado %v esperado %v", resultado, esperado)
8
}
9
}
Copied!

Execute o teste

./soma_test.go:23:9: undefined: SomaTudo

Escreva o mínimo de código possível para fazer o teste rodar e verifique a saída do teste falhado

Precisamos definir o SomaTudo de acordo com o que nosso teste precisa.
O Go te permite escrever funções variádicas em que a quantidade de argumentos podem variar.
1
func SomaTudo(numerosParaSomar ...[]int) (somas []int) {
2
return
3
}
Copied!
Pode tentar compilar, mas nossos testes não vão funcionar!
./soma_test.go:26:9: invalid operation: got != want (slice can only be compared to nil)
operação inválida: recebido != esperado (slice só pode ser comparado a nil
O Go não te deixa usar operadores de igualdade com slices. É possível escrever uma função que percorre cada slice recebido e esperado e verificar seus valores, mas por praticidade podemos usar o reflect.DeepEqual que é útil para verificar se duas variáveis são iguais.
1
func TestSomaTudo(t *testing.T) {
2
3
recebido := SomaTudo([]int{1,2}, []int{0,9})
4
esperado := []int{3, 9}
5
6
if !reflect.DeepEqual(recebido, esperado) {
7
t.Errorf("recebido %v esperado %v", recebido, esperado)
8
}
9
}
Copied!
(coloque import reflect no topo do seu arquivo para ter acesso ao DeepEqual)
É importante saber que o reflect.DeepEqual não tem "segurança de tipos", ou seja, o código vai compilar mesmo se você tiver feito algo estranho. Para ver isso em ação, altere o teste temporariamente para:
1
func TestSomaTudo(t *testing.T) {
2
3
recebido := SomaTudo([]int{1,2}, []int{0,9})
4
esperado := "joao"
5
6
if !reflect.DeepEqual(recebido, esperado) {
7
t.Errorf("recebido %v, esperado %v", recebido, esperado)
8
}
9
}
Copied!
O que fizemos aqui foi comparar um slice com uma string. Isso não faz sentido, mas o teste compila! Logo, apesar de ser uma forma simples de comparar slices (e outras coisas), você deve tomar cuidado quando for usar o reflect.DeepEqual.
Volte o teste da forma como estava e execute-o. Você deve ter a saída do teste com uma mensagem tipo:
soma_test.go:30: recebido [], esperado [3 9]

Escreva código o suficiente para fazer o teste passar

O que precisamos fazer é percorrer as variáveis recebidas como argumento, calcular a soma com nossa função Soma de antes e adicioná-la ao slice que vamos retornar:
1
func SomaTudo(numerosParaSomar ...[]int) (somas []int) {
2
quantidadeDeNumeros := len(numerosParaSomar)
3
somas = make([]int, quantidadeDeNumeros)
4
5
for i, numeros := range numerosParaSomar {
6
somas[i] = Soma(numeros)
7
}
8
9
return
10
}
Copied!
Muitas coisas novas para aprender!
Há uma nova forma de criar um slice. O make te permite criar um slice com uma capacidade inicial de len de numerosParaSomar que precisamos percorrer.
Você pode indexar slices como arrays com meuSlice[N] para obter seu valor ou designá-lo a um novo valor com =.
Agora o teste deve passar.

Refatoração

Como mencionado, slices têm uma capacidade. Se você tiver um slice com uma capacidade de 2 e tentar fazer uma atribuição como meuSlice[10] = 1, vai receber um erro em tempo de execução.
No entanto, você pode usar a função append, que recebe um slice e um novo valor e retorna um novo slice com todos os itens dentro dele.
1
func SomaTudo(numerosParaSomar ...[]int) []int {
2
var somas []int
3
for _, numeros := range numerosParaSomar {
4
somas = append(somas, Soma(numeros))
5
}
6
7
return somas
8
}
Copied!
Nessa implementação, nos preocupamos menos sobre capacidade. Começamos com um slice vazio somas e o anexamos ao resultado de Soma enquanto percorremos as variáveis recebidas como argumento.
Nosso próprio requisito é alterar o SomaTudo para SomaTodoOResto, onde agora calcula os totais de todos os "finais" de cada slice. O final de uma coleção é todos os itens com exceção do primeiro (a "cabeça").

Escreva o teste primeiro

1
func TestSomaTodoOResto(t *testing.T) {
2
resultado := SomaTodoOResto([]int{1,2}, []int{0,9})
3
esperado := []int{2, 9}
4
5
if !reflect.DeepEqual(resultado, esperado) {
6
t.Errorf("resultado %v, esperado %v", resultado, esperado)
7
}
8
}
Copied!

Execute o teste

./soma_test.go:26:9: undefined: SomaTodoOResto

Escreva o mínimo de código possível para fazer o teste rodar e verifique a saída do teste falhado

Renomeie a função para SomaTodoOResto e volte a executar o teste.
soma_test.go:30: resultado [3 9], esperado [2 9]

Escreva código o suficiente para fazer o teste passar

1
func SomaTodoOResto(numerosParaSomar ...[]int) []int {
2
var somas []int
3
for _, numeros := range numerosParaSomar {
4
final := numeros[1:]
5
somas = append(somas, Soma(final))
6
}
7
8
return somas
9
}
Copied!
Slices podem ser "fatiados"! A sintaxe usada é slice[inicio:final]. Se você omitir o valor de um dos lados dos : ele captura tudo do lado omitido. No nosso caso, quando usamos numeros[1:], estamos dizendo "pegue da posição 1 até o final". É uma boa ideia investir um tempo escrevend outros testes com slices e brincar com o operador slice para criar mais familiaridade com ele.

Refatoração

Não tem muito o que refatorar dessa vez.
O que acha que aconteceria se você passar um slice vazio para a nossa função? Qual é o "final" de um slice vazio? O que acontece quando você fala para o Go capturar todos os elementos de meuSliceVazio[1:]?

Escreva o teste primeiro

1
func TestSomaTodoOResto(t *testing.T) {
2
3
t.Run("faz as somas de alguns slices", func(t *testing.T) {
4
resultado := SomaTodoOResto([]int{1,2}, []int{0,9})
5
esperado := []int{2, 9}
6
7
if !reflect.DeepEqual(resultado, esperado) {
8
t.Errorf("resultado %v, esperado %v", resultado, esperado)
9
}
10
})
11
12
t.Run("soma slices vazios de forma segura", func(t *testing.T) {
13
resultado := SomaTodoOResto([]int{}, []int{3, 4, 5})
14
esperado := []int{0, 9}
15
16
if !reflect.DeepEqual(resultado, esperado) {
17
t.Errorf("resultado %v, esperado %v", resultado, esperado)
18
}
19
})
20
21
}
Copied!

Execute o teste

1
panic: runtime error: slice bounds out of range [recovered]
2
panic: runtime error: slice bounds out of range
Copied!
pânico: erro em tempo de execução: fora da capacidade do slice
Oh, não! É importante perceber que o test foi compilado, esse é um erro em tempo de execução. Erros em tempo de compilação são nossos amigos, porque nos ajudam a escrever softwares que funcionam. Erros em tempo de execução são nosso inimigos, porque afetam nossos usuários.

Escreva código o suficiente para fazer o teste passar

1
func SomaTodoOResto(numerosParaSomar ...[]int) []int {
2
var somas []int
3
for _, numeros := range numerosParaSomar {
4
if len(numeros) == 0 {
5
somas = append(somas, 0)
6
} else {
7
final := numeros[1:]
8
somas = append(somas, Soma(final))
9
}
10
}
11
12
return somas
13
}
Copied!

Refatoração

Nossos testes têm código repetido em relação à asserção de novo. Vamos encapsular isso em uma função:
1
func TestSomaTodoOResto(t *testing.T) {
2
3
verificaSomas := func(t *testing.T, resultado, esperado []int) {
4
t.Helper()
5
if !reflect.DeepEqual(resultado, esperado) {
6
t.Errorf("resultado %v, esperado %v", resultado, esperado)
7
}
8
}
9
10
t.Run("faz a soma do resto", func(t *testing.T) {
11
resultado := SomaTodoOResto([]int{1, 2}, []int{0, 9})
12
esperado := []int{2, 9}
13
verificaSomas(t, resultado, esperado)
14
})
15
16
t.Run("soma slices vazios de forma segura", func(t *testing.T) {
17
resultado := SomaTodoOResto([]int{}, []int{3, 4, 5})
18
esperado := []int{0, 9}
19
verificaSomas(t, resultado, esperado)
20
})
21
22
}
Copied!
Um efeito colateral útil disso é que adiciona um pouco de segurança de tipos no nosso código. Se uma pessoa espertinha adicionar um novo teste com verificaSomas(t, resultado, "luisa") o compilador vai pará-lo antes que algo errado aconteça.
1
$ go test
2
./soma_test.go:52:21: cannot use "luisa" (type string) as type []int in argument to verificaSomas
Copied!
não é possível usar "luisa" (tipo string) como tipo []int no argumento para verificaSomas

Resumindo

Falamos sobre:
  • Arrays
  • Slices
  • Várias formas de criá-las
  • Como eles têm uma capacidade fixa, mas é posível criar novos slices de antigos usando append
  • Como "fatiar" slices!
  • len obtém o tamanho de um array ou slice
  • Ferramenta de cobertura de testes
  • reflect.DeepEqual e por que é útil, mas pode diminuir a segurança de tipos do seu código
Usamos slices e arrays com inteiros, mas eles também funcionam com qualquer outro tipo, incluindo até os próprios arrays/slices. Logo, você pode declarar uma variável de [][]string se precisar.
Dê uma olhada no post sobre slices no blog de Go para saber mais sobre slices. Tente escrever mais testes para demonstrar o que você aprendeu com a leitura.
Outra forma útil de brincar com Go ao invés de escrever testes é o Go playground. Você pode testar mais coisas lá e você pode compartilhar seu código facilmente se precisar tirar dúvidas. Criei um exemplo com um slice para testar lá.
Last modified 1yr ago