Go vs Python: existe em Go a construção "if x in"?

Introdução: Por que programadores Python sentem falta do "in" em Go?

Se você veio para Go vindo do mundo Python, certamente se lembra daquela linha mágica: if "banana" in fruits:. Curta, elegante, legível. E então você abre Go e se pergunta: "Does Go have 'if x in' construct similar to Python?" — é exatamente assim que soa a pergunta mais popular no Stack Overflow, que reuniu milhares de visualizações.

Spoiler: não existe açúcar sintático direto como in em Go. Mas isso não significa que a tarefa não tenha solução ou seja difícil de resolver. Pelo contrário, Go possui várias formas idiomáticas de verificar pertinência, cada uma eficiente e bonita à sua maneira.

Neste artigo, vamos abordar:

\n
• Por que Go não tem in e como a filosofia da linguagem influenciou isso;
\n
• Como verificar a existência de um elemento em um slice (inclusive usando a nova função slices.Contains);
\n
• Como funciona a busca em um map (spoiler: é a forma mais rápida);
\n
• Busca de substring em string usando strings.Contains;
\n
• Vamos criar nossa própria função wrapper universal para um estilo "pytônico";
\n
• Comparar o desempenho das abordagens.
\n

Por que Go não quer "if x in"?

Go é uma linguagem minimalista. Seus criadores (Rob Pike, Ken Thompson, Rob Griesemer) evitaram conscientemente sobrecarregar a sintaxe. Em vez de adicionar a palavra-chave in, eles propuseram o uso de laços explícitos e construções embutidas.

Isso não é uma deficiência, mas uma característica: você sempre vê exatamente o que está acontecendo. Por exemplo, para map, a sintaxe value, ok := myMap[key] fornece não apenas a verificação de existência, mas também o próprio valor — isso é mais poderoso do que um simples booleano True/False.

Método 1: Busca em slice (clássico)

O cenário mais comum. Suponha que você tenha um slice de strings e precise verificar se "Go" está presente.

Antes da versão Go 1.21, você precisava escrever um loop manualmente:

package main\n\nimport "fmt"\n\nfunc contains(slice []string, target string) bool {\n    for _, v := range slice {\n        if v == target {\n            return true\n        }\n    }\n    return false\n}\n\nfunc main() {\n    languages := []string{"Python", "Java", "Go", "Rust"}\n    if contains(languages, "Go") {\n        fmt.Println("Go encontrado!")\n    }\n}\n

Este código é Go idiomático. Ele é explícito, rápido e compreensível. Para slices pequenos (até 1000 elementos), essa busca linear funciona perfeitamente.

Método 1.1: Usando slices.Contains (Go 1.21+)

A partir da versão Go 1.21 (lançada em agosto de 2023), a biblioteca padrão passou a incluir o pacote slices com a função pronta Contains. Agora seu código fica quase tão conciso quanto em Python:

package main\n\nimport (\n    "fmt"\n    "slices"\n)\n\nfunc main() {\n    languages := []string{"Python", "Java", "Go", "Rust"}\n    if slices.Contains(languages, "Go") {\n        fmt.Println("Go encontrado! (via slices.Contains)")\n    }\n}\n

Importante: slices.Contains é uma função genérica. Ela funciona com qualquer tipo que suporte o operador == (strings, números, booleanos, structs sem slices/maps internos).

Método 2: Busca em map — o rei do desempenho

Em Python, você usa in para dicionários, e isso é tempo constante O(1). Em Go é o mesmo, mas a sintaxe é diferente:

package main\n\nimport "fmt"\n\nfunc main() {\n    // Criando um map como set\n    fruits := map[string]bool{\n        "apple":  true,\n        "banana": true,\n        "cherry": true,\n    }\n\n    if fruits["banana"] {\n        fmt.Println("banana existe!")\n    }\n\n    // Forma mais correta — com verificação ok\n    if _, ok := fruits["orange"]; ok