Strings em Golang: Split, Join, Contains, Replace e mais

Uma string em Go é uma sequência imutável de bytes, normalmente texto UTF-8. Os operadores trabalham sobre a própria string (+, ==, <, indexação, fatiamento), e todo o resto fica no pacote padrão strings.

package main

import (
	"fmt"
	"strings"
)

func main() {
	csv := "apple,banana,cherry"

	parts := strings.Split(csv, ",")
	fmt.Println(parts, len(parts))

	fmt.Println(strings.Join(parts, " | "))
	fmt.Println(strings.Contains(csv, "nan"))
	fmt.Println(strings.ReplaceAll(csv, ",", ";"))
	fmt.Println(strings.ToUpper(parts[0]))
	fmt.Println(strings.TrimSpace("   padded   ") + "!")
}

Dividindo strings

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Printf("%q\n", strings.Split("a,b,,c", ","))
	fmt.Printf("%q\n", strings.Split("", ","))
	fmt.Printf("%q\n", strings.Fields("  one  two\tthree\n"))
	fmt.Printf("%q\n", strings.SplitN("k=v=x", "=", 2))
	fmt.Printf("%q\n", strings.Split("go", ""))

	key, value, found := strings.Cut("timeout=30s", "=")
	fmt.Println(key, value, found)
}

O caso Split("", ",") pega muita gente: uma entrada vazia gera um slice de tamanho 1, não 0. Ao dividir entrada do usuário, usar Fields ou verificar s == "" antes evita um elemento vazio fantasma.

strings.Cut é o jeito mais limpo de dividir chave=valor, usuario@host e pares parecidos. O Go 1.24 também trouxe versões com iterador, strings.SplitSeq e strings.FieldsSeq, que entregam as partes uma a uma sem montar um slice.

Buscando

Toda busca diferencia maiúsculas de minúsculas, exceto EqualFold. Para buscar sem diferenciar, passe os dois lados para minúsculas ou use EqualFold em comparações de string inteira.

Transformando

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "  Hello, Gopher!  "

	fmt.Printf("%q\n", strings.TrimSpace(s))
	fmt.Printf("%q\n", strings.Trim("--go--", "-"))
	fmt.Printf("%q\n", strings.TrimPrefix("v1.2.3", "v"))
	fmt.Printf("%q\n", strings.TrimSuffix("report.pdf", ".pdf"))
	fmt.Printf("%q\n", strings.TrimLeft("xxhixx", "x"))

	fmt.Println(strings.ToLower("MiXeD"), strings.ToUpper("mixed"))
	fmt.Println(strings.Replace("a-b-c-d", "-", "+", 2))
	fmt.Println(strings.ReplaceAll("a-b-c-d", "-", ""))
	fmt.Println(strings.Repeat("=", 20))
}

Uma armadilha: Trim, TrimLeft e TrimRight recebem um conjunto de caracteres, não um prefixo. strings.TrimLeft("abcab", "ab") remove todos os a e b do começo e devolve "cab". Para remover um prefixo ou sufixo exato, use TrimPrefix e TrimSuffix.

Concatenação e strings.Builder

+ junta strings, e fmt.Sprintf formata valores em uma só. Os dois alocam uma string nova a cada vez, porque strings são imutáveis. Isso não é problema para poucas operações e é lento dentro de um laço, em que cada += copia tudo o que já foi montado. Use strings.Builder no lugar:

package main

import (
	"fmt"
	"strings"
)

func main() {
	var b strings.Builder
	for i := 1; i <= 5; i++ {
		fmt.Fprintf(&b, "row %d", i)
		if i < 5 {
			b.WriteString(", ")
		}
	}
	fmt.Println(b.String())
	fmt.Println("length:", b.Len())

	// joining a slice is simpler still
	names := []string{"Ana", "Ben", "Chen"}
	fmt.Println("Hello " + strings.Join(names, ", "))
}

Um strings.Builder zero já está pronto para uso. Ele implementa io.Writer, então fmt.Fprintf escreve direto nele. Chame b.Grow(n) antes se você souber mais ou menos o tamanho do resultado. Não copie um Builder depois de escrever nele; passe um ponteiro.

Strings multilinha e raw strings

Go tem dois tipos de literal de string:

package main

import "fmt"

func main() {
	interpreted := "line one\nline two\ttabbed \"quoted\""
	raw := `C:\Users\ana\notes.txt
second line, \n stays literal`

	fmt.Println(interpreted)
	fmt.Println(raw)

	query := `
SELECT id, name
FROM users
WHERE active = true`
	fmt.Println(query)
}

Strings entre aspas duplas processam escapes (\n, \t, \", \\, \u00e9) e precisam caber em uma linha. Raw strings entre crases tomam tudo ao pé da letra, incluindo quebras de linha, e por isso são a forma de escrever strings multilinha, expressões regulares, JSON e caminhos do Windows. Uma raw string não pode conter crase, e os retornos de carro (carriage return) dentro dela são descartados. Repare que a query acima começa com uma quebra de linha, já que o literal começa logo depois da crase de abertura.

Tamanho, indexação e substrings

len(s) é o número de bytes. s[i] é um byte, e s[i:j] é uma substring por posições em bytes:

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "naïve café"

	fmt.Println(len(s), utf8.RuneCountInString(s))
	fmt.Println(s[0], string(s[0]))
	fmt.Println(s[:5]) // first 5 bytes
	fmt.Println(s[6:]) // from byte 6 to the end

	r := []rune(s)
	fmt.Println(string(r[:5])) // first 5 characters
}

ï e é ocupam dois bytes cada, então a string tem 12 bytes e 10 caracteres. Fatiar por bytes é seguro desde que as posições venham de strings.Index ou funções parecidas, que devolvem offsets em bytes nas fronteiras entre caracteres. Para pegar "os n primeiros caracteres", converta antes para []rune. A página de runes e bytes explica o UTF-8 a fundo.

Strings são imutáveis

Você não pode alterar um byte no lugar: s[0] = 'H' é erro de compilação (cannot assign to s[0] (neither addressable nor a map index expression)). Toda função de strings devolve uma string nova. Para editar, converta para []byte ou []rune, altere o slice e converta de volta:

b := []byte("hello")
b[0] = 'H'
s := string(b) // "Hello"

A imutabilidade também explica por que substrings são baratas: s[2:5] compartilha memória com s em vez de copiar. O outro lado é que uma substring pequena de uma string enorme mantém a string enorme inteira viva. Use strings.Clone (Go 1.20) quando for guardar um pedaço curto de uma entrada grande.

Comparando strings

== e != comparam o conteúdo, e <, > comparam byte a byte, o que dá ordem alfabética para ASCII. strings.Compare existe, mas raramente é necessário; slices.Sort em um []string usa <. Para ordenar texto em outros idiomas respeitando as regras locais, use golang.org/x/text/collate.

Convertendo outros tipos

Números viram strings com strconv.Itoa, strconv.FormatFloat ou fmt.Sprintf, e strings viram números com strconv.Atoi e strconv.ParseFloat. Não escreva string(42): isso gera o caractere com code point 42, "*". A página de conversão de tipos tem a tabela completa.

query := `SELECT id, name
FROM users
WHERE active = true`