Golang básico - Comparação de Igualdade

Esse post faz parte de uma série onde pretendo compartilhar o básico essencial para desenvolver com GoLang.

As comparações lógicas utilizando os operadores == ou != não tem muito mistério. Ou seu código compara se os valores são iguais ou diferentes.
Mas existem alguns detalhes importantes de saber sobre o que você está comparando.

Interface Comparable

A primeira coisa é saber o que pode ser comparado com esses operadores, o lugar mais óbvio para saber disso é a documentação do Go: seção sobre comparadores

E outra opção é olhar a interface comparable, que foi adicionada junto com a implementação de generics do Go, todos os tipos que implementam essa interface são comparáveis.

Então basicamente todos os tipos primitivos definidos pelo Go são comparáveis, como: string, números (int, float, complex), bool.

Comparação de tipos complexos

Alguns tipos possuem condições para serem ou não comparáveis. Que é o caso de: struct, slices e channels.
Somente são comparáveis se os elementos deles também o forem.
O interessante é que o Go valida isso a nível de compilação, te ajudando a evitar erros em runtime, por exemplo:

//Esse código compila e a comparação funciona: func main() { test1 := struct { name string }{} test2 := struct { name string }{} if test1 == test2 { fmt.Println("Funciona") } } 

No código acima estou criando dois structs com o atributos equivalentes e a comparação funciona.

//Esse código não compila func main() { test1 := struct { name string attributes map[string]string }{} test2 := struct { name string attributes map[string]string }{} if test1 == test2 { fmt.Println("Cade?") } } 

Já esse código vai falhar na compilação com o erro invalid operation.

Isso acontece porque map não é um tipo comparável em Go.

Detalhes sobre structs e map

É bastante conveniente poder comparar structs com ==, já que esse são os tipos onde customizamos nossas modelagens.
Mas mesmo quando estiver utilizando um tipo não comparável há algumas maneiras de simplificar o código, e saber disso vai te poupar de escrever condições bem chatas.

Bom vamos imaginar que estamos trabalhando no sistema de uma escola e temos a seguinte struct não comparável:

type student struct { ID int name string age int course string attributes map[string]string } 

A parte boa, esse struct possui um campo ID, o que facilita muito se você estiver trabalhando com dados persistidos.

Agora imagina só se estiver trabalhando com dados ainda transientes, por exemplo se estiver lendo um arquivo e precisar fazer algum tipo de processamento antes de persistir esses dados.

Você sempre vai ter a opção de comparar campo a campo, não é nada conveniente, mas funciona. Mas você pode fazer uso de composição de struct da seguinte forma:

func main() { type identity struct { name string age int course string } type student struct { ID int identity attributes map[string]string } s1 := student{ identity: identity{ name: "Chuck", age: 10, course: "golang", }, attributes: map[string]string{ "last_score": "10", }, } s2 := student{ identity: identity{ name: "Chuck", age: 10, course: "golang", }, attributes: map[string]string{ "last_score": "20", }, } s3 := student{ identity: identity{ name: "Chuck", age: 12, course: "golang", }, attributes: map[string]string{ "last_score": "20", }, } if s1.identity == s2.identity { fmt.Println("Achou", s1) } if s1.identity != s3.identity { fmt.Println("Não achou") } } 

A alternativa a esse código seria fazer condições como essas:

 if s1.name == s2.name && s1.age == s2.age && s1.course == s2.course { fmt.Println("Achou", s1) } 

Você poderia extrair para uma função, para ficar menos confuso, mas mesmo assim teria que ficar mantendo essas comparações.

Faça bom uso de composição isso pode simplificar bastante o seu código!

Resumo

• Conheça a interface comparable
• Tipos primitivos são comparáveis
• Tipos complexos podem ou não ser comparáveis
• Use a composição a seu favor.