Da trilha de Go Este conceito ainda não saiu como card do dia. ir para o card de hoje

Go Strings Básico

Strings, bytes e runes

Em Go, uma string é uma sequência imutável de bytes, geralmente codificada em UTF-8. Isso significa que o índice de uma string acessa bytes, não caracteres. Para lidar com texto Unicode corretamente, usamos rune (um alias para int32), que representa um code point.

Ao iterar com for range sobre uma string, o Go decodifica automaticamente cada rune UTF-8, retornando a posição do byte inicial e o valor da rune. Já a indexação direta (s[i]) retorna um byte (uint8), o que pode quebrar caracteres multibyte.

O pacote strings oferece funções utilitárias como Contains, Split, Join, ToUpper, entre outras, que operam sobre strings completas. Para construir strings de forma eficiente em loops, use strings.Builder, que evita alocações repetidas e é mais rápido que concatenar com +.

Neste card, você vai entender a diferença entre bytes e runes, como percorrer strings com range, usar o pacote strings e montar textos com strings.Builder.

Pontos-chave

  • Strings em Go são imutáveis e armazenam bytes UTF-8; indexar uma string retorna um byte, não uma rune.
  • for range sobre string decodifica runes UTF-8, retornando o índice do byte e o valor da rune.
  • O pacote strings fornece funções como Contains, Split, Join e ToUpper para manipulação de texto.
  • strings.Builder é a forma eficiente de concatenar strings em loops, evitando cópias desnecessárias.
strings_bytes_runes.go
package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "Go é divertido!"

	// Acessando bytes individuais
	fmt.Println("Bytes:", len(s))
	fmt.Printf("Primeiro byte: %c\n", s[0])

	// Iterando com range: cada iteração decodifica uma rune
	fmt.Println("Runes:")
	for i, r := range s {
		fmt.Printf("índice %d: %c (%d)\n", i, r, r)
	}

	// Usando o pacote strings
	fmt.Println("Contém 'divertido'?", strings.Contains(s, "divertido"))
	fmt.Println("Maiúsculas:", strings.ToUpper(s))
	partes := strings.Split(s, " ")
	fmt.Println("Partes:", partes)
	fmt.Println("Juntando:", strings.Join(partes, "-"))

	// Construindo string com strings.Builder
	var b strings.Builder
	for i := 0; i < 3; i++ {
		fmt.Fprintf(&b, "linha %d; ", i+1)
	}
	fmt.Println("Builder:", b.String())
}

Exercícios

  1. 1
    Fácil

    Contando runes

    Escreva um programa que leia uma string fixa "Olá, mundo!" e imprima quantas runes (caracteres Unicode) ela contém, além do número de bytes.

    Resolver
  2. 2
    Médio

    Invertendo uma string com runes

    Escreva uma função reverse(s string) string que inverta a ordem das runes de uma string, preservando caracteres multibyte. Use strings.Builder para montar o resultado.

    Resolver
  3. 3
    Desafio

    Contador de palavras com Builder

    Escreva um programa que leia uma string texto (pode ser fixa) e conte quantas vezes cada palavra aparece. Use strings.Fields para separar as palavras, normalize para minúsculas com strings.ToLower e imprima o resultado ordenado alfabeticamente. Use strings.Builder para montar a saída formatada.

    Resolver

Continue estudando