Pular para o conteúdo
Rust em Português

Lição 10 de 18 · 20 min

Slices

Aprenda a emprestar só um pedaço de um texto ou de uma lista, entenda a diferença entre &str e String e evite bugs com índices soltos.

Ao terminar, você vai saber:

  • Explicar a diferença entre String e &str
  • Criar fatias de texto, arrays e vetores com ranges
  • Escrever uma função que devolve um pedaço de um texto
  • Entender por que slices evitam bugs com índices

Na lição Referências e empréstimo você viu como emprestar um valor inteiro sem tomar a posse dele. Agora vem um passo a mais: emprestar só um pedaço. Esse pedaço tem nome: slice (fatia, em português).

Uma slice é uma referência para uma parte contínua de uma coleção. Ela não copia nada. Só aponta para onde o pedaço começa e diz quantos itens ele tem.

String e &str

Você já usou os dois tipos de texto do Rust, talvez sem perceber a diferença.

  • String é um texto que pertence à variável. Ele mora na memória dinâmica (o heap), pode crescer e é liberado quando o dono sai de escopo.
  • &str é uma fatia de texto emprestada. Só leitura. Aponta para um texto que pertence a outra pessoa.
fn main() {
    // Texto literal: já é um &str, gravado dentro do próprio programa
    let saudacao: &str = "Bom dia";

    // String: dona do texto, pode crescer
    let mut pedido = String::from("Pão francês");
    pedido.push_str(" e café");

    // Uma fatia da String: um &str que aponta para dentro dela
    let primeira_parte: &str = &pedido[0..3];

    println!("{saudacao}! Pedido: {pedido}");
    println!("Começa com: {primeira_parte}");
}

O &pedido[0..3] lê assim: “empreste os bytes da posição 0 até antes da 3”. O resultado é Pão? Quase. Rode e veja: aparece Pã. O ã ocupa dois bytes em UTF-8, então três bytes cobrem P, ã, e nada mais. Guarde isso: os índices de uma fatia de texto contam bytes, não letras. Na lição Coleções você vai ver como lidar com acentos com calma. Se o corte cair no meio de uma letra, o programa para com um panic!.

Por isso, nos exemplos com fatias por posição, vamos usar texto sem acento ou cortar em lugares seguros, como espaços.

Ranges: o jeito de dizer “de onde até onde”

Um range escreve um intervalo. Há quatro formas que você vai usar muito:

fn main() {
    let texto = String::from("Rust no Brasil");

    let a = &texto[0..4]; // do 0 até antes do 4: "Rust"
    let b = &texto[..4]; // mesmo que 0..4
    let c = &texto[8..]; // do 8 até o fim: "Brasil"
    let d = &texto[..]; // o texto todo

    println!("{a} | {b} | {c} | {d}");
}

O fim nunca entra. 0..4 pega 0, 1, 2 e 3. Se quiser incluir o último, use 0..=3.

Fatias de array e de Vec

Slices não são só para texto. Qualquer array ou Vec pode ser fatiado do mesmo jeito. O tipo da fatia é &[T], onde T é o tipo dos itens.

fn media(notas: &[f64]) -> f64 {
    let soma: f64 = notas.iter().sum();
    soma / notas.len() as f64
}

fn main() {
    // Notas do ano: quatro bimestres
    let notas = [6.5, 7.0, 8.5, 9.0];

    let primeiro_semestre = &notas[..2];
    let segundo_semestre = &notas[2..];

    println!("Média do 1º semestre: {:.2}", media(primeiro_semestre));
    println!("Média do 2º semestre: {:.2}", media(segundo_semestre));
    println!("Média do ano: {:.2}", media(&notas));

    // Com Vec funciona igual
    let precos = vec![4.50, 12.00, 3.25, 8.90];
    println!("Média dos dois primeiros: {:.2}", media(&precos[..2]));
}

Repare na assinatura fn media(notas: &[f64]). A mesma função aceita um array inteiro, um pedaço dele ou um Vec. Escrever o parâmetro como slice deixa a função mais útil.

Função primeira_palavra

Um exemplo clássico: achar a primeira palavra de uma frase. A ideia é andar pelos bytes até achar um espaço e devolver a fatia do começo até ali.

fn primeira_palavra(frase: &str) -> &str {
    for (i, byte) in frase.bytes().enumerate() {
        if byte == b' ' {
            return &frase[..i];
        }
    }
    // Não achou espaço: a frase inteira é uma palavra só
    frase
}

fn main() {
    let cliente = String::from("Maria da Silva");
    let nome = primeira_palavra(&cliente);
    println!("Olá, {nome}!");

    // Também funciona com texto literal
    println!("{}", primeira_palavra("padaria"));
}

Dois detalhes:

  • O parâmetro é &str, não &String. Assim a função aceita as duas coisas: uma String emprestada (&cliente vira &str sozinho) e um texto literal.
  • b' ' é o byte do espaço. Como o espaço tem um byte só em UTF-8, cortar ali nunca quebra uma letra acentuada.

Por que slice evita bug

Imagine a versão sem slice: a função devolve só a posição onde a palavra termina, um número solto.

fn fim_da_primeira_palavra(frase: &str) -> usize {
    frase.find(' ').unwrap_or(frase.len())
}

fn main() {
    let mut frase = String::from("Pix recebido");
    let fim = fim_da_primeira_palavra(&frase);

    frase.clear(); // a frase agora está vazia

    // `fim` ainda vale 3, mas não aponta para nada que exista
    println!("Fim guardado: {fim}, tamanho atual: {}", frase.len());
}

Isso compila e roda. O número fim não tem ligação nenhuma com a frase. Se você tentar usar &frase[..fim] depois do clear, o programa quebra em tempo de execução.

Agora a versão com slice:

fn primeira_palavra(frase: &str) -> &str {
    match frase.find(' ') {
        Some(i) => &frase[..i],
        None => frase,
    }
}

fn main() {
    let mut frase = String::from("Pix recebido");
    let palavra = primeira_palavra(&frase);

    frase.clear(); // erro: a frase está emprestada

    println!("Primeira palavra: {palavra}");
}
error[E0502]: cannot borrow `frase` as mutable because it is also borrowed as immutable
  |     let palavra = primeira_palavra(&frase);
  |                                    ------ immutable borrow occurs here
  |     frase.clear();
  |     ^^^^^^^^^^^^^ mutable borrow occurs here
  |     println!("Primeira palavra: {palavra}");
  |                                 --------- immutable borrow later used here

O compilador não deixa. Enquanto palavra estiver em uso, ela é um empréstimo de leitura da frase, e o clear precisa de um empréstimo de escrita. É a mesma regra da lição anterior: ou várias leituras, ou uma escrita. O borrow checker transformou um bug de execução em erro de compilação.

Para corrigir, use a palavra antes de mexer na frase:

fn primeira_palavra(frase: &str) -> &str {
    match frase.find(' ') {
        Some(i) => &frase[..i],
        None => frase,
    }
}

fn main() {
    let mut frase = String::from("Pix recebido");
    let palavra = primeira_palavra(&frase);
    println!("Primeira palavra: {palavra}");

    frase.clear(); // agora pode: `palavra` não é mais usada
    println!("Tamanho depois de limpar: {}", frase.len());
}

Resumo

  • Slice é uma referência para um pedaço contínuo de uma coleção. Não copia nada.
  • String é dona do texto; &str é uma fatia emprestada dele.
  • Ranges: a..b (sem o b), a..=b (com o b), ..b, a.. e ...
  • Em texto, os índices contam bytes. Cortar no meio de uma letra acentuada causa panic!.
  • &[T] é a fatia de array ou Vec. Parâmetros como &str e &[T] deixam a função mais flexível.
  • Como a slice é um empréstimo, o compilador impede que o dono mude enquanto ela estiver em uso.

Desafio

Escreva fn ultima_palavra(frase: &str) -> &str que devolve a última palavra de uma frase. Teste com "Nota fiscal emitida" (deve dar emitida) e com "CPF" (deve dar CPF).

Ver uma resposta
fn ultima_palavra(frase: &str) -> &str {
    match frase.rfind(' ') {
        // i é a posição do último espaço; a palavra começa logo depois
        Some(i) => &frase[i + 1..],
        None => frase,
    }
}

fn main() {
    println!("{}", ultima_palavra("Nota fiscal emitida"));
    println!("{}", ultima_palavra("CPF"));
}
Salvo só neste navegador.