Métodos padrão
Padrões de traits
Métodos padrão é 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.
Métodos com um corpo
Os métodos de um traço não precisam ser apenas assinaturas. Um traço pode fornecer uma implementação padrão — um corpo de método que os implementadores recebem automaticamente.
Isso reduz o código repetitivo entre muitos tipos.
Um método padrão
Escreva o corpo diretamente dentro do traço. Os tipos que implementam o traço o herdam gratuitamente, sem código adicional.
trait Greet {
fn hello(&self) -> String {
String::from("Hello there")
}
}
struct Robot;
impl Greet for Robot {}
fn main() {
println!("{}", Robot.hello());
}Substituindo um padrão
Qualquer implementador pode substituir um padrão fornecendo sua própria versão. A substituição toma o lugar do padrão para aquele tipo.
trait Greet {
fn hello(&self) -> String { String::from("Hello there") }
}
struct Robot;
struct Pirate;
impl Greet for Robot {}
impl Greet for Pirate {
fn hello(&self) -> String { String::from("Arr!") }
}
fn main() {
println!("{}", Robot.hello());
println!("{}", Pirate.hello());
}Padrões chamando métodos obrigatórios
Um método padrão pode chamar outros métodos do mesmo traço, inclusive aqueles sem padrão. Este é um padrão poderoso: os implementadores fornecem um pequeno núcleo, e os padrões constroem um comportamento mais rico sobre ele.
trait Summary {
fn title(&self) -> String;
fn preview(&self) -> String {
format!("Read more about: {}", self.title())
}
}
struct Article { headline: String }
impl Summary for Article {
fn title(&self) -> String { self.headline.clone() }
}
fn main() {
let a = Article { headline: String::from("Rust Rocks") };
println!("{}", a.preview());
}O padrão do método-modelo
Essa combinação de métodos obrigatórios e padrões é o padrão de método-modelo. O traço define o fluxo geral nos padrões e deixa as partes variáveis como métodos obrigatórios.
trait Report {
fn body(&self) -> String;
fn render(&self) -> String {
format!("=== REPORT ===\n{}\n==============", self.body())
}
}
struct Sales;
impl Report for Sales {
fn body(&self) -> String { String::from("Sales up 10%") }
}
fn main() {
println!("{}", Sales.render());
}Vários padrões
Um traço pode combinar livremente métodos obrigatórios e padrões. Os implementadores só precisam fornecer os métodos obrigatórios.
trait Animal {
fn name(&self) -> String;
fn legs(&self) -> u32 { 4 }
fn describe(&self) -> String {
format!("{} has {} legs", self.name(), self.legs())
}
}
struct Dog;
impl Animal for Dog {
fn name(&self) -> String { String::from("Dog") }
}
fn main() {
println!("{}", Dog.describe());
}Padrões e traços padrão
Muitos traços padrão dependem de padrões. Por exemplo, Iterator exige apenas next; cada adaptador e consumidor é um método padrão construído sobre ele.
É por isso que um método desbloqueia todo o conjunto de ferramentas.
Substituindo para obter desempenho
Às vezes, um padrão funciona, mas uma versão especializada é mais rápida. Os implementadores podem substituir apenas esse método e manter os demais padrões.
trait Counter {
fn items(&self) -> Vec<i32>;
fn total(&self) -> i32 {
self.items().iter().sum()
}
}
struct Fast { precomputed: i32 }
impl Counter for Fast {
fn items(&self) -> Vec<i32> { vec![] }
fn total(&self) -> i32 { self.precomputed }
}
fn main() {
println!("{}", Fast { precomputed: 99 }.total());
}Mantendo os traços ergonômicos
Um bom design de traço exige um conjunto pequeno de métodos e fornece padrões convenientes para o restante. Os implementadores fazem um trabalho mínimo, mas obtêm uma interface completa.
Uma ressalva
Um método padrão só pode usar outros métodos do traço e o tipo por trás de self por meio deles; ele não pode acessar diretamente os campos de um implementador desconhecido. Crie padrões com base nos próprios métodos do traço.
Padrões e obrigatórios em resumo
Um método de traço com um corpo é um padrão; um método que tem apenas uma assinatura é obrigatório. Os implementadores devem fornecer todos os métodos obrigatórios, mas podem deixar os padrões inalterados.
trait Logger {
fn line(&self) -> String;
fn log(&self) {
println!("LOG: {}", self.line());
}
}
struct App;
impl Logger for App {
fn line(&self) -> String { String::from("started") }
}
fn main() {
App.log();
}Verificação rápida
Teste sua compreensão dos métodos padrão.
Recapitulação
Você aprendeu sobre padrões de traços:
- Um método de traço pode incluir um corpo como implementação padrão
- Os implementadores o herdam gratuitamente e podem substituí-lo
- Os padrões podem chamar métodos obrigatórios, permitindo o padrão de método-modelo
- Isso mantém os traços ergonômicos, com uma pequena superfície obrigatória
Perguntas Frequentes
A aula “Métodos padrão” é grátis?
Sim — o texto completo de “Métodos padrão” é 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 “Métodos padrão”?
Padrões de traits 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 “Métodos padrão”?
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.