Go Academy · Aula

Unicode e utf8

Trate textos multibyte

Unicode e utf8 é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Por que Unicode é importante

O texto moderno contém acentos, emojis e sistemas de escrita não latinos. Unicode atribui a cada caractere um número chamado ponto de código.

O Go armazena strings como UTF-8, uma codificação de largura variável desses pontos de código.

package main

import "fmt"

func main() {
    s := "héllo 世界"
    fmt.Println(s)
}

A quantidade de bytes por caractere varia

Em UTF-8, um caractere ocupa de 1 a 4 bytes:

Letras ASCII: 1 byte.
Latim acentuado: geralmente 2 bytes.
Caracteres CJK: geralmente 3 bytes.

package main

import "fmt"

func main() {
    fmt.Println(len("a"))
    fmt.Println(len("é"))
    fmt.Println(len("世"))
}

O pacote unicode/utf8

O pacote unicode/utf8 entende a codificação. utf8.RuneCountInString(s) conta os caracteres corretamente, ao contrário de len.

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "héllo"
    fmt.Println(len(s))
    fmt.Println(utf8.RuneCountInString(s))
}

Validando UTF-8

Use utf8.ValidString(s) para confirmar que uma cadeia de caracteres contém UTF-8 bem formado antes de processá-la.

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    fmt.Println(utf8.ValidString("héllo"))
    fmt.Println(utf8.ValidString(string([]byte{0xff, 0xfe})))
}

Decodificando uma runa

utf8.DecodeRuneInString(s) retorna a primeira runa e quantos bytes ela consumiu. Isso permite percorrer uma cadeia de caracteres manualmente.

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    r, size := utf8.DecodeRuneInString("世界")
    fmt.Println(string(r), size)
}

Range decodifica por você

Um laço for range já faz a decodificação UTF-8. O índice avança pelo tamanho em bytes da runa a cada etapa.

package main

import "fmt"

func main() {
    for i, r := range "a世b" {
        fmt.Println(i, string(r))
    }
}

O pacote unicode

O pacote unicode classifica runas individuais. Funções como unicode.IsLetter e unicode.IsDigit respondem a perguntas sobre um caractere.

package main

import (
    "fmt"
    "unicode"
)

func main() {
    fmt.Println(unicode.IsLetter('A'))
    fmt.Println(unicode.IsDigit('7'))
    fmt.Println(unicode.IsSpace(' '))
}

Alterando maiúsculas e minúsculas por runa

unicode.ToUpper e unicode.ToLower atuam sobre runas individuais, incluindo muitas letras que não são ASCII.

package main

import (
    "fmt"
    "unicode"
)

func main() {
    fmt.Println(string(unicode.ToUpper('a')))
    fmt.Println(string(unicode.ToLower('Z')))
}

Contando letras com segurança

Combine os pacotes para contar apenas as letras em um texto misto, tratando cada runa corretamente.

package main

import (
    "fmt"
    "unicode"
)

func main() {
    count := 0
    for _, r := range "a1 b2 世!" {
        if unicode.IsLetter(r) {
            count++
        }
    }
    fmt.Println(count)
}

Invertendo por runas

Para inverter um texto com segurança, você deve inverter runas, não bytes; caso contrário, os caracteres multibyte se separam.

package main

import "fmt"

func main() {
    runes := []rune("a世b")
    for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
        runes[i], runes[j] = runes[j], runes[i]
    }
    fmt.Println(string(runes))
}

Juntando tudo

Uma ferramenta de resumo rápido: informe o tamanho em bytes, a quantidade de runas e se o texto é UTF-8 válido.

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "Go 世界!"
    fmt.Println("bytes:", len(s))
    fmt.Println("runes:", utf8.RuneCountInString(s))
    fmt.Println("valid:", utf8.ValidString(s))
}

Verificação rápida

Escolha a maneira correta de contar caracteres.

Recapitulação: Unicode e utf8

Agora você consegue trabalhar com texto multibyte com confiança:

As cadeias de caracteres do Go usam UTF-8; os caracteres ocupam de 1 a 4 bytes.
unicode/utf8 conta, valida e decodifica runas.
unicode classifica e altera as maiúsculas e minúsculas de runas individuais.

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "café 語"
    fmt.Println(utf8.RuneCountInString(s), "runes")
}

Perguntas Frequentes

A aula “Unicode e utf8” é grátis?

Sim — o texto completo de “Unicode e utf8” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Unicode e utf8”?

Trate textos multibyte Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Unicode e utf8”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy