0Pricing
Learn Rust Coding · Lezione

Definire e implementare i trait

Padroneggi i trait per definire comportamenti condivisi tra tipi diversi, in modo simile alle interfacce di altri linguaggi.

Definire e implementare i trait è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 2 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 3 lezioni in totale.

Cosa sono i trait in Rust?

In Rust, i trait sono un modo potente per definire comportamenti condivisi tra tipi diversi. Si possono considerare simili alle interfacce di altri linguaggi.

Un trait indica a Rust che un determinato tipo dispone di certe funzionalità. Se un tipo implementa un trait, significa che fornisce i metodi definiti da quel trait.

  • I trait abilitano il polimorfismo: consentono di lavorare con tipi diversi in modo uniforme.
  • Sono fondamentali per il sistema dei tipi e per le astrazioni sicure di Rust.

Dichiarare il primo trait

Si definisce un trait usando la parola chiave trait. Al suo interno si elencano le firme dei metodi (nomi, parametri e tipi restituiti) che ogni tipo che lo implementa deve fornire.

Definiamo un semplice trait Summary per gli elementi di cui è possibile fornire un riepilogo.

trait Summary {
  fn summarize(&self) -> String;
}

fn main() {
  // Traits are definitions, not directly executable.
  // We will implement and use them in later scenes!
  println!("Trait 'Summary' defined.");
}

Implementare trait per i tipi

Per fare in modo che un tipo usi un trait, si utilizza la sintassi impl Trait for Type. Si fornisce quindi l'implementazione concreta per ogni metodo definito nel trait.

Qui implementiamo Summary per una struct NewsArticle.

trait Summary {
  fn summarize(&self) -> String;
}

struct NewsArticle {
  headline: String,
  location: String,
  author: String,
  content: String,
}

impl Summary for NewsArticle {
  fn summarize(&self) -> String {
    format!("{}, by {} ({})", self.headline, self.author, self.location)
  }
}

fn main() {
  let article = NewsArticle {
    headline: String::from("Penguins win Stanley Cup!"),
    location: String::from("Pittsburgh, PA"),
    author: String::from("Iceburgh"),
    content: String::from("The Pittsburgh Penguins have won..."),
  };

  println!("New article summary: {}", article.summarize());
}

Usare funzioni con trait bound

Una volta che un tipo implementa un trait, è possibile scrivere funzioni che accettano qualsiasi tipo che implementi quel trait. Questo consente di scrivere codice flessibile e generico.

La funzione notify può accettare qualsiasi tipo che implementi Summary.

trait Summary {
  fn summarize(&self) -> String;
}

struct NewsArticle {
  headline: String,
  location: String,
  author: String,
  content: String,
}

impl Summary for NewsArticle {
  fn summarize(&self) -> String {
    format!("{}, by {} ({})", self.headline, self.author, self.location)
  }
}

struct Tweet {
  username: String,
  content: String,
  reply: bool,
  retweet: bool,
}

impl Summary for Tweet {
  fn summarize(&self) -> String {
    format!("{}: {}", self.username, self.content)
  }
}

fn notify(item: &impl Summary) { // impl Summary is syntax sugar for a trait bound
  println!("Breaking news! {}", item.summarize());
}

fn main() {
  let tweet = Tweet {
    username: String::from("horse_ebooks"),
    content: String::from("of course, as you probably already know, people"),
    reply: false,
    retweet: false,
  };

  let article = NewsArticle {
    headline: String::from("Rust is awesome!"),
    location: String::from("Internet"),
    author: String::from("Rustacean"),
    content: String::from("Rust's type system is amazing."),
  };

  notify(&tweet);
  notify(&article);
}

Trait con comportamento predefinito

I trait possono anche fornire implementazioni predefinite per i propri metodi. Ciò significa che i tipi non devono implementare ogni metodo se ne viene fornita un'implementazione predefinita.

Possono scegliere di usare quella predefinita oppure sostituirla con la propria logica.

trait Summary {
  fn summarize_author(&self) -> String; // New required method
  fn summarize(&self) -> String { // Default implementation
    format!("(Read more from {})", self.summarize_author())
  }
}

struct Tweet {
  username: String,
  content: String,
  reply: bool,
  retweet: bool,
}

impl Summary for Tweet {
  fn summarize_author(&self) -> String { // Must implement required method
    format!("@{}", self.username)
  }
  // We are using the default summarize() method here!
}

fn main() {
  let tweet = Tweet {
    username: String::from("dog_lover"),
    content: String::from("My dog is the best!"),
    reply: false,
    retweet: false,
  };

  println!("Tweet summary: {}", tweet.summarize());
}

Funzioni generiche con i trait

Quando si scrivono funzioni o struct generiche, è possibile usare i trait bound per specificare che un parametro di tipo generico T deve implementare un determinato trait.

In questo modo si garantisce che i metodi di quel trait siano disponibili per T.

trait Displayable {
  fn display(&self);
}

struct Point<T> {
  x: T,
  y: T,
}

// Implement Displayable for Point<i32>
impl Displayable for Point<i32> {
  fn display(&self) {
    println!("Point: ({}, {})", self.x, self.y);
  }
}

// Generic function that works for any type T that implements Displayable
fn print_item<T: Displayable>(item: T) {
  item.display();
}

fn main() {
  let p = Point { x: 10, y: 20 };
  print_item(p);
  // This function only works for types that implement Displayable
  // let s = String::from("Hello");
  // print_item(s); // This would cause a compile-time error
}

Combinare più trait bound

A volte un tipo generico deve implementare più di un trait. È possibile specificare più trait bound usando l'operatore +.

In scenari più complessi, soprattutto con molti parametri generici, la clausola where può migliorare la leggibilità.

use std::fmt::Debug;

trait Printable {
  fn print_info(&self);
}

struct Book {
  title: String,
  pages: u32,
}

impl Printable for Book {
  fn print_info(&self) {
    println!("Book: '{}' ({} pages)", self.title, self.pages);
  }
}

impl Debug for Book { // Book also implements Debug trait
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    write!(f, "Book {{ title: {}, pages: {} }}", self.title, self.pages)
  }
}

// A function that requires its argument to be both Printable and Debug
fn process_item<T: Printable + Debug>(item: T) {
  item.print_info();
  println!("Debug info: {:?}", item);
}

fn main() {
  let my_book = Book {
    title: String::from("The Rust Book"),
    pages: 600,
  };

  process_item(my_book);
}

Restituire tipi con `impl Trait`

La sintassi impl Trait non serve solo per i parametri delle funzioni: può essere usata anche nelle posizioni di ritorno. È utile quando si desidera restituire un tipo che implementa un determinato trait, senza esporne il tipo concreto esatto.

Semplifica le firme delle funzioni e mantiene flessibile l'API.

trait Greeter {
  fn greet(&self) -> String;
}

struct FriendlyGreeter;
impl Greeter for FriendlyGreeter {
  fn greet(&self) -> String {
    String::from("Hello there!")
  }
}

struct FormalGreeter;
impl Greeter for FormalGreeter {
  fn greet(&self) -> String {
    String::from("Greetings and salutations.")
  }
}

// This function returns *some* type that implements Greeter
// The caller doesn't need to know if it's FriendlyGreeter or FormalGreeter
fn get_greeter(formal: bool) -> impl Greeter {
  if formal {
    FormalGreeter
  } else {
    FriendlyGreeter
  }
}

fn main() {
  let casual_greet = get_greeter(false);
  println!("{}", casual_greet.greet());

  let formal_greet = get_greeter(true);
  println!("{}", formal_greet.greet());
}

Costruire sui supertrait

A volte un trait può dipendere logicamente da un altro. Rust consente di definire i supertrait, ovvero trait che richiedono che ogni tipo che li implementa implementi anche un altro trait specifico.

Si usa la sintassi trait SubTrait: SuperTrait. È come dire: "se si è in grado di fare X, si deve anche essere in grado di fare Y".

trait Printable {
  fn print_content(&self);
}

// Debug is a supertrait of PrintableDebug
// Any type implementing PrintableDebug must also implement Debug
trait PrintableDebug: Printable + std::fmt::Debug {
  fn print_debug_and_content(&self) {
    self.print_content();
    println!("Debug info: {:?}", self);
  }
}

struct Item {
  id: u32,
  name: String,
}

impl Printable for Item {
  fn print_content(&self) {
    println!("Item ID: {}, Name: {}", self.id, self.name);
  }
}

impl std::fmt::Debug for Item {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    write!(f, "Item {{ id: {}, name: {} }}", self.id, self.name)
  }
}

// Now we can implement PrintableDebug because Item implements both Printable and Debug
impl PrintableDebug for Item {}

fn main() {
  let my_item = Item {
    id: 101,
    name: String::from("Widget A"),
  };
  my_item.print_debug_and_content();
}

Verifichi le proprie conoscenze sui trait

Consideri il seguente frammento di codice Rust. Quale delle seguenti affermazioni sui trait e sui trait bound è VERA?

Trait: il proprio strumento per i comportamenti

Abbiamo esplorato il potente sistema dei trait di Rust!

  • I trait definiscono un insieme di metodi che un tipo può implementare, svolgendo un ruolo simile alle interfacce.
  • Si implementano i trait per tipi specifici usando impl Trait for Type.
  • I trait bound (T: Trait) consentono a funzioni e struct generiche di operare su qualsiasi tipo che implementi il trait richiesto.
  • I trait possono avere implementazioni predefinite e si possono specificare più trait bound (T: Trait1 + Trait2) o usare i supertrait.
  • impl Trait può essere usato anche nelle posizioni di ritorno per nascondere i tipi concreti.

I trait sono fondamentali per scrivere codice Rust flessibile, riutilizzabile e sicuro!

Domande Frequenti

La lezione «Definire e implementare i trait» è gratuita?

Sì — il testo completo di «Definire e implementare i trait» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 3 lezioni in totale.

Cosa imparerò in «Definire e implementare i trait»?

Padroneggi i trait per definire comportamenti condivisi tra tipi diversi, in modo simile alle interfacce di altri linguaggi. Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Learn Rust Coding?

Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 3.

Quanto tempo richiede la lezione «Definire e implementare i trait»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?

Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Scrivere codice generico in Rust
  2. Definire e implementare i trait
  3. Uso avanzato dei trait: tipi associati
← Torna a Learn Rust Coding