Learn Rust Coding · Lección

Métodos predeterminados

Valores predeterminados de los traits

Métodos predeterminados es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.

Métodos con cuerpo

Los métodos de los traits no tienen por qué ser solo firmas. Un trait puede proporcionar una implementación predeterminada: un cuerpo de método que los tipos que lo implementen reciben automáticamente.

Esto reduce el código repetitivo entre muchos tipos.

Un método predeterminado

Escriba el cuerpo directamente dentro del trait. Los tipos que implementen el trait lo heredan gratuitamente, sin código adicional.

trait Greet {
    fn hello(&self) -> String {
        String::from("Hello there")
    }
}

struct Robot;
impl Greet for Robot {}

fn main() {
    println!("{}", Robot.hello());
}

Sobrescribir un valor predeterminado

Cualquier tipo que implemente el trait puede sobrescribir el valor predeterminado proporcionando su propia versión. La sobrescritura reemplaza el valor predeterminado para ese 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());
}

Valores predeterminados que llaman a métodos obligatorios

Un método predeterminado puede llamar a otros métodos del mismo trait, incluso a los que no tienen implementación predeterminada. Este es un patrón muy potente: quienes implementan el trait proporcionan un núcleo pequeño y los métodos predeterminados construyen comportamientos más completos sobre él.

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());
}

El patrón Template Method

Esta combinación de métodos obligatorios y predeterminados es el patrón template method. El trait define el flujo general mediante métodos predeterminados y deja las partes variables como métodos obligatorios.

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());
}

Múltiples métodos predeterminados

Un trait puede combinar libremente métodos obligatorios y predeterminados. Quienes lo implementan solo tienen que proporcionar los obligatorios.

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());
}

Métodos predeterminados y traits estándar

Muchos traits estándar se basan en métodos predeterminados. Por ejemplo, Iterator solo requiere next; cada adaptador y consumidor es un método predeterminado construido sobre él.

Por eso, un solo método permite acceder a todo el conjunto de herramientas.

Sobrescritura para mejorar el rendimiento

A veces un método predeterminado funciona, pero una versión especializada es más rápida. Quienes implementan el trait pueden sobrescribir solo ese método y conservar el resto de los métodos predeterminados.

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());
}

Diseñar traits ergonómicos

Un buen diseño de trait consiste en exigir un conjunto pequeño de métodos y proporcionar métodos predeterminados convenientes para el resto. Quienes lo implementan realizan un trabajo mínimo, pero obtienen una interfaz completa.

Una salvedad

Un método predeterminado solo puede usar otros métodos del trait y el tipo subyacente a self a través de ellos; no puede acceder directamente a los campos de un tipo cuya implementación desconoce. Diseñe los métodos predeterminados en torno a los propios métodos del trait.

Métodos predeterminados y obligatorios: resumen

Un método de un trait que tiene un cuerpo es predeterminado; uno que solo tiene una firma es obligatorio. Quienes implementan el trait deben proporcionar todos los métodos obligatorios, pero pueden dejar intactos los predeterminados.

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();
}

Comprobación rápida

Compruebe cuánto entiende los métodos predeterminados.

Resumen

Ha aprendido cómo funcionan los métodos predeterminados de los traits:

Un método de un trait puede incluir un cuerpo como implementación predeterminada
Quienes implementan el trait la heredan gratuitamente y pueden sobrescribirla
Los métodos predeterminados pueden llamar a métodos obligatorios, lo que permite usar el patrón template method
Esto mantiene los traits ergonómicos, con una superficie mínima de métodos obligatorios

Preguntas frecuentes

¿La lección «Métodos predeterminados» es gratis?

Sí — el texto completo de «Métodos predeterminados» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.

¿Qué aprenderé en «Métodos predeterminados»?

Valores predeterminados de los traits Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Learn Rust Coding?

No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Métodos predeterminados»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?

Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Learn Rust Coding