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 = ¬as[..2];
let segundo_semestre = ¬as[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(¬as));
// 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: umaStringemprestada (&clientevira&strsozinho) 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 ob),a..=b(com ob),..b,a..e... - Em texto, os índices contam bytes. Cortar no meio de uma letra acentuada causa
panic!. &[T]é a fatia de array ouVec. Parâmetros como&stre&[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"));
}