Fatias
Visões emprestadas
Fatias é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 2 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.
O que é uma fatia
Uma fatia é uma visão emprestada de uma parte contígua de uma coleção. Ela não é proprietária dos dados — aponta para dados existentes.
As fatias são escritas com um intervalo dentro de colchetes.
fn main() {
let arr = [1, 2, 3, 4, 5];
let part = &arr[1..4];
println!("{:?}", part);
}Sintaxe de intervalo de fatias
Os intervalos selecionam um índice inicial e um final. O final é exclusivo.
&v[1..4]— índices 1, 2 e 3.&v[..3]— do início até 3.&v[2..]— de 2 até o final.
fn main() {
let v = vec![10, 20, 30, 40];
println!("{:?}", &v[..2]);
println!("{:?}", &v[2..]);
}Fatias de string
Uma fatia de string &str é uma visão de parte de uma String. Os intervalos de índices usam posições de bytes.
fn main() {
let s = String::from("hello world");
let hello = &s[0..5];
let world = &s[6..11];
println!("{} {}", hello, world);
}Fatias da coleção inteira
Use &v[..] para criar uma fatia da coleção inteira. É assim que um Vec faz empréstimo como uma fatia.
fn main() {
let v = vec![1, 2, 3];
let whole = &v[..];
println!("{:?}", whole);
}Fatias como parâmetros
Funções que aceitam &[T] funcionam tanto com arrays quanto com vetores. Isso as torna flexíveis.
fn sum(items: &[i32]) -> i32 {
let mut total = 0;
for x in items {
total += x;
}
total
}
fn main() {
let v = vec![1, 2, 3];
let a = [4, 5, 6];
println!("{} {}", sum(&v), sum(&a));
}As fatias fazem empréstimos, não assumem propriedade
Como uma fatia faz um empréstimo, a coleção original precisa permanecer viva enquanto a fatia é usada. O compilador garante isso.
fn main() {
let v = vec![100, 200, 300];
let s = &v[0..2];
println!("slice {:?}, original {:?}", s, v);
}Comprimento da fatia
Assim como outras coleções, as fatias têm um método len() que informa o número de elementos abrangidos.
fn main() {
let v = vec![5, 6, 7, 8, 9];
let middle = &v[1..4];
println!("length {}", middle.len());
}first e last
As fatias fornecem first() e last(), que retornam Options para tratar fatias vazias com segurança.
fn main() {
let data = [10, 20, 30];
let s = &data[..];
println!("{:?} {:?}", s.first(), s.last());
}Percorrendo uma fatia
Você pode percorrer uma fatia da mesma forma que qualquer coleção.
fn main() {
let v = vec![1, 2, 3, 4];
for x in &v[1..3] {
println!("{}", x);
}
}Uma função para a primeira palavra
Um caso de uso comum de fatias é retornar uma fatia de um texto existente, como a primeira palavra de uma frase.
fn first_word(s: &str) -> &str {
let bytes = s.as_bytes();
for (i, &b) in bytes.iter().enumerate() {
if b == b' ' {
return &s[0..i];
}
}
s
}
fn main() {
println!("{}", first_word("hello there"));
}Por que as fatias são seguras
As fatias evitam copiar dados e, ao mesmo tempo, impedem referências pendentes. O verificador de empréstimos garante que os dados subjacentes durem mais que a fatia.
fn main() {
let words = vec!["a", "b", "c", "d"];
let pair = &words[1..3];
println!("{:?}", pair);
}Verificação rápida
Relembre o que uma fatia representa.
Recapitulação
Fatias em Rust:
- Uma visão emprestada:
&v[start..end], com o fim exclusivo. &stré uma fatia de string;&[T]é uma fatia de array ou vetor.- Parâmetros de fatia aceitam tanto arrays quanto vetores.
- O verificador de empréstimos mantém as fatias seguras.
fn average(nums: &[i32]) -> i32 {
nums.iter().sum::<i32>() / nums.len() as i32
}
fn main() {
let v = vec![4, 8, 12];
println!("{}", average(&v[..]));
}Perguntas Frequentes
A aula “Fatias” é grátis?
Sim — o texto completo de “Fatias” é 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 “Fatias”?
Visões emprestadas 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 2 de 4.
Quanto tempo leva a aula “Fatias”?
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.