Go Academy · Aula

Runas versus bytes

Entenda o funcionamento interno das strings de Go

Aula 1 de 413 etapas

Runas versus bytes é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 1 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.

O que é uma String do Go?

No Go, uma string é uma sequência imutável de bytes. Os bytes geralmente contêm texto codificado em UTF-8, mas o Go nunca impõe isso.

Não é possível alterar uma string no próprio lugar.
Seu len conta bytes, não caracteres.

package main

import "fmt"

func main() {
    s := "Go"
    fmt.Println(s)
    fmt.Println(len(s))
}

Os bytes nos bastidores

Indexar uma string com s[i] retorna um único byte (tipo byte, um alias de uint8).

Em texto ASCII simples, cada caractere ocupa exatamente um byte.

package main

import "fmt"

func main() {
    s := "ABC"
    fmt.Println(s[0])
    fmt.Println(s[1])
    fmt.Println(s[2])
}

Um byte é um número

Como um byte é apenas um número, imprimir s[0] mostra 65 (o código ASCII de A), não a letra.

Para ver o caractere, converta o byte novamente em uma string.

package main

import "fmt"

func main() {
    s := "ABC"
    fmt.Println(string(s[0]))
}

O que é uma rune?

Uma rune é um alias de int32 e representa um único ponto de código Unicode.

Uma rune pode ocupar vários bytes quando codificada como UTF-8.
Use runes quando precisar trabalhar com caracteres, não com bytes brutos.

package main

import "fmt"

func main() {
    var r rune = 'A'
    fmt.Println(r)
    fmt.Println(string(r))
}

Caracteres de vários bytes

Caracteres não ASCII ocupam mais de um byte em UTF-8. Uma string como "héllo" tem mais bytes do que letras.

Observe que len informa a quantidade de bytes, que é maior que o comprimento visível.

package main

import "fmt"

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

Percorrendo uma string

Um laço for range sobre uma string decodifica UTF-8 automaticamente. Cada iteração produz:

o índice do byte onde a rune começa;
a própria rune.

package main

import "fmt"

func main() {
    for i, r := range "héllo" {
        fmt.Println(i, string(r))
    }
}

Contando caracteres corretamente

Para contar caracteres em vez de bytes, converta a string em uma []rune e obtenha seu comprimento.

Isso fornece o número de pontos de código.

package main

import "fmt"

func main() {
    s := "héllo"
    runes := []rune(s)
    fmt.Println(len(runes))
}

Indexando por rune

Depois de obter uma []rune, é possível indexá-la para obter o N-ésimo caractere com segurança, mesmo em textos com vários bytes.

package main

import "fmt"

func main() {
    runes := []rune("héllo")
    fmt.Println(string(runes[1]))
}

De strings para bytes e de volta

É possível converter livremente entre uma string e uma []byte.

[]byte(s) fornece os bytes brutos.
string(b) reconstrói o texto.

package main

import "fmt"

func main() {
    b := []byte("Go")
    fmt.Println(b)
    fmt.Println(string(b))
}

Construindo uma string a partir de runes

Uma fatia de runes é convertida novamente em uma string da mesma forma. Isso é útil depois de editar caracteres individualmente.

package main

import "fmt"

func main() {
    runes := []rune{'G', 'o', '!'}
    fmt.Println(string(runes))
}

Resumo: bytes versus runes

Modelo mental rápido:

byte = um byte bruto (uint8); len(s) conta esses bytes.
rune = um ponto de código Unicode (int32); range produz esses pontos.
Use []rune ao contar ou indexar caracteres.

package main

import "fmt"

func main() {
    s := "café"
    fmt.Println(len(s))
    fmt.Println(len([]rune(s)))
}

Verificação rápida

Teste sua compreensão sobre runes e bytes.

Responda na aula interativa

Recapitulação: runes versus bytes

Você aprendeu que as strings do Go são sequências imutáveis de bytes, geralmente em UTF-8.

byte é um byte bruto; len conta bytes.
rune é um ponto de código Unicode; range os decodifica.
Converta com []byte(s) e []rune(s) para trabalhar no nível adequado.

package main

import "fmt"

func main() {
    s := "Go語"
    fmt.Println("bytes:", len(s))
    fmt.Println("runes:", len([]rune(s)))
}

Grátis para começar

Aprenda Go com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 51
Aulas: 203

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Runas versus bytes” é grátis?

Sim — o texto completo de “Runas versus bytes” é 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 “Runas versus bytes”?

Entenda o funcionamento interno das strings de Go 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 1 de 4.

Quanto tempo leva a aula “Runas versus bytes”?

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