Unindo strings em Go: top 3 erros e como evitá-los

Como unir um slice de strings em Go: principais erros e como evitá-los

Você já escreveu em Go e de repente pensou: "Preciso unir todas essas strings em uma, mas como fazer isso corretamente?" Esta pergunta é uma das mais populares no Stack Overflow (dezenas de milhares de visualizações). Parece simples, não? Mas iniciantes (e não só) acabam cometendo os mesmos erros: deixam o código lento, consomem muita memória ou obtêm bugs inesperados.

Neste artigo, vamos analisar três erros típicos ao unir um slice de strings em Go e mostrar como evitá-los. Você aprenderá a escolher a ferramenta certa para cada tarefa — desde uma simples união até aplicações de alta carga. Vamos lá!

Por que este tópico é tão importante?

Trabalhar com strings é a base de qualquer linguagem de programação. Em Go, as strings são imutáveis (immutable). Quando você "une" duas strings com o operador +, na verdade uma nova string é criada e as antigas são copiadas. Em um loop, isso se torna uma complexidade quadrática O(n²). E se houver muitas strings (centenas de milhares), o programa pode ficar lento ou até falhar com out of memory.

Além disso, Go é uma linguagem onde o desempenho é importante. Por isso, a biblioteca padrão oferece soluções elegantes. Vamos ver quais erros são mais comuns.

Erro nº 1: Concatenação em loop com +=

Como isso se parece na prática

Suponha que você tenha um slice de strings:

words := []string{"Go", "is", "awesome", "but", "only", "if", "you", "use", "the", "right", "tools"}

A maneira mais intuitiva é percorrer o slice e adicionar cada palavra:

result := ""\nfor _, w := range words {\n    result += w + " "\n}\nfmt.Println(result) // "Go is awesome but only if you use the right tools "

Parece lógico? Sim. Mas isso é uma bomba-relógio.

Por que isso é ruim?

\n
• Cópia de memória. Cada iteração cria uma nova string, copiando todos os dados anteriores. Para 1000 strings de 10 caracteres cada — são ~500.000 cópias desnecessárias.
\n
• Grande número de alocações. Em vez de uma string, você cria n strings, cada uma sendo depois descartada pelo garbage collector.
\n
• Código menos legível. É fácil esquecer espaços ou separadores.
\n

Quando isso é aceitável? Apenas se houver 2-3 strings e você estiver escrevendo um script descartável. Para produção — nunca.

Erro nº 2: Usar strings.Join com separador vazio (e não entender seu poder)

O herói certo

A biblioteca padrão do Go nos oferece strings.Join. Esta é a solução ideal para 90% dos casos:

import "strings"\n\nwords := []string{"Go", "is", "awesome"}\nresult := strings.Join(words, " ")\nfmt.Println(result) // "Go is awesome"

O código se lê como um livro: "una words com espaço". E funciona rápido — strings.Join calcula previamente o comprimento total da string e aloca memória exatamente uma vez.

Como as pessoas erram?

\n
• Esquecem o separador. strings.Join(words, "") — une tudo em sequência. Às vezes é necessário, mas frequentemente é um bug.
\n
• Usam strings.Join para concatenação única. Não faça isso: strings.Join([]string{a, b}, ""). Simplesmente escreva a + b.
\n
• Não tratam um slice vazio. strings.Join([]string{}, ",") retornará uma string vazia. Isso é normal, mas iniciantes esperam um erro.
\n

// Exemplo onde Join não é adequado\ndata := []string{}\nresult := strings.Join(data, ",") // "" — vazio, mas às vezes é necessário ","\n// Então você precisa fazer uma verificação:\nif len(data) > 0 {\n    result = "," + strings.Join(data, ",")\n}

Conclusão: strings.Join é seu amigo. Use-o sempre