Learn Rust Coding · Aula

UTF-8 e caracteres

Tratamento de Unicode

UTF-8 e caracteres é uma aula grátis de Learn Rust Coding 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 Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

As strings de Rust são UTF-8

Cada String e &str de Rust é codificado como UTF-8. Isso significa que o texto pode incluir qualquer caractere Unicode, não apenas ASCII.

fn main() {
    let s = String::from("caf\u{e9}");
    println!("{}", s);
}

O que é UTF-8?

UTF-8 codifica cada caractere Unicode usando de um a quatro bytes. Caracteres ASCII usam um único byte; letras acentuadas e emojis usam mais.

fn main() {
    let ascii = "A";          // 1 byte
    let accent = "\u{e9}";    // 2 bytes (e-acute)
    println!("{} bytes vs {} bytes", ascii.len(), accent.len());
}

Bytes e caracteres

Por causa da codificação com vários bytes, len() retorna bytes, enquanto o número de caracteres pode ser menor.

fn main() {
    let s = "caf\u{e9}";
    println!("bytes {}", s.len());
    println!("chars {}", s.chars().count());
}

O tipo char é Unicode

Um char de Rust é um valor de 4 bytes que pode conter qualquer valor escalar Unicode, muito além de um único byte.

fn main() {
    let letter = 'Z';
    let accented = '\u{f1}'; // n with tilde
    println!("{} {}", letter, accented);
}

Percorrendo caracteres

Use chars() para percorrer o texto caractere por caractere. Isso trata corretamente caracteres com vários bytes.

fn main() {
    let s = "a\u{e9}z";
    for c in s.chars() {
        println!("{}", c);
    }
}

Por que não é possível indexar por número

Rust não permite usar s[0] em uma string. Como os caracteres variam em tamanho de bytes, indexar por um único número seria ambíguo e inseguro.

fn main() {
    let s = "hello";
    // let c = s[0]; // error: cannot index a str
    let first = s.chars().next().unwrap();
    println!("{}", first);
}

Obtendo o caractere nth

Use o método de iterador nth para obter um caractere por posição. Ele retorna um Option.

fn main() {
    let s = "abcdef";
    let third = s.chars().nth(2);
    println!("{:?}", third);
}

Percorrendo bytes

Quando você realmente precisar dos bytes brutos, use bytes(), que produz valores u8.

fn main() {
    let s = "AB";
    for b in s.bytes() {
        println!("{}", b);
    }
}

Criando fatias em limites de bytes

Fatias de string usam índices de bytes. A fatia precisa terminar em um limite válido de caractere; caso contrário, o programa entra em pânico.

fn main() {
    let s = "hello";
    let part = &s[0..3]; // valid ASCII boundary
    println!("{}", part);
}

Métodos de char

O tipo char tem métodos úteis como is_alphabetic, is_numeric e to_uppercase.

fn main() {
    let c = 'k';
    println!("alpha {} numeric {}", c.is_alphabetic(), c.is_numeric());
    println!("upper {}", c.to_uppercase());
}

Contando caracteres específicos

Combine chars com filter para contar caracteres que correspondem a uma condição.

fn main() {
    let s = "banana";
    let a_count = s.chars().filter(|&c| c == 'a').count();
    println!("a appears {} times", a_count);
}

Verificação rápida

Relembre por que o comprimento de uma string pode surpreender você.

Recapitulação

UTF-8 e chars em Rust:

Strings são UTF-8; os caracteres usam de 1 a 4 bytes.
len() fornece bytes; chars().count() fornece caracteres.
Não é possível indexar uma string por número; use chars() ou nth.
As fatias precisam ficar dentro dos limites de caracteres.

fn main() {
    let s = "sm\u{ee}le";
    println!("bytes {} chars {}", s.len(), s.chars().count());
    for c in s.chars() {
        print!("{} ", c);
    }
    println!();
}

Perguntas Frequentes

A aula “UTF-8 e caracteres” é grátis?

Sim — o texto completo de “UTF-8 e caracteres” é 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 Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “UTF-8 e caracteres”?

Tratamento de Unicode Você pratica Learn Rust Coding 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 Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding 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 “UTF-8 e caracteres”?

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 Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding 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 Learn Rust Coding