Learn Rust Coding · Lezione

Definizione dei trait

Comportamento condiviso

Definizione dei trait è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 1 di 4. 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 4 lezioni in totale.

Che cos'è un trait?

Un trait definisce un comportamento condiviso, ossia un insieme di metodi che un tipo può implementare. È simile a un'interfaccia presente in altri linguaggi.

I trait permettono a tipi diversi di rispettare un contratto comune.

Dichiarare un trait

Utilizzi la parola chiave trait seguita dalle firme dei metodi. Le firme dichiarano ciò che le implementazioni devono fornire.

trait Greet {
    fn hello(&self) -> String;
}

fn main() {
    println!("trait declared");
}

Implementare un trait

Utilizzi impl TraitName for Type per fornire i metodi. La firma deve corrispondere esattamente a quella del trait.

trait Greet {
    fn hello(&self) -> String;
}

struct Dog;

impl Greet for Dog {
    fn hello(&self) -> String {
        String::from("Woof")
    }
}

fn main() {
    let d = Dog;
    println!("{}", d.hello());
}

Molti tipi, un solo trait

Più tipi possono implementare lo stesso trait, ciascuno a modo proprio. È così che i trait unificano il comportamento di tipi non correlati.

trait Greet { fn hello(&self) -> String; }

struct Dog;
struct Cat;

impl Greet for Dog { fn hello(&self) -> String { String::from("Woof") } }
impl Greet for Cat { fn hello(&self) -> String { String::from("Meow") } }

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

Trait come parametri di funzione

La sintassi impl Trait accetta qualsiasi tipo che implementi il trait. La funzione opera in modo uniforme senza conoscere il tipo concreto.

trait Greet { fn hello(&self) -> String; }
struct Dog;
impl Greet for Dog { fn hello(&self) -> String { String::from("Woof") } }

fn announce(g: &impl Greet) {
    println!("It says: {}", g.hello());
}

fn main() {
    announce(&Dog);
}

Vincoli dei trait sui generics

Può richiedere che un tipo generico implementi un trait utilizzando un vincolo di trait. In questo modo i metodi del trait sono disponibili all'interno della funzione.

trait Greet { fn hello(&self) -> String; }
struct Cat;
impl Greet for Cat { fn hello(&self) -> String { String::from("Meow") } }

fn shout<T: Greet>(g: &T) {
    println!("{}!", g.hello().to_uppercase());
}

fn main() {
    shout(&Cat);
}

Più vincoli con +

Richieda più trait contemporaneamente con +. In questo caso un valore deve implementare sia un trait personalizzato sia il trait standard Clone.

trait Named { fn name(&self) -> String; }

#[derive(Clone)]
struct Item { label: String }

impl Named for Item {
    fn name(&self) -> String { self.label.clone() }
}

fn describe<T: Named + Clone>(t: &T) {
    let copy = t.clone();
    println!("named {}", copy.name());
}

fn main() {
    describe(&Item { label: String::from("box") });
}

La clausola where

In presenza di molti vincoli, una clausola where mantiene leggibile la firma spostando i requisiti sotto di essa.

use std::fmt::Debug;

fn print_all<T>(items: &[T])
where
    T: Debug,
{
    for it in items {
        println!("{:?}", it);
    }
}

fn main() {
    print_all(&[1, 2, 3]);
}

I trait possono avere più metodi

Un trait può dichiarare molti metodi. Le implementazioni devono fornire tutti quelli richiesti, dando al tipo un insieme completo di comportamenti.

trait Shape {
    fn area(&self) -> f64;
    fn name(&self) -> String;
}

struct Square { side: f64 }

impl Shape for Square {
    fn area(&self) -> f64 { self.side * self.side }
    fn name(&self) -> String { String::from("square") }
}

fn main() {
    let s = Square { side: 3.0 };
    println!("{} area {}", s.name(), s.area());
}

Perché i trait sono importanti

I trait abilitano il polimorfismo senza ereditarietà. Sono alla base dei generics, dell'overloading degli operatori (Add), della formattazione (Display) e di gran parte della libreria standard.

Sono il cuore del modello di astrazione di Rust.

Regola di coerenza

La regola dell'orfano stabilisce che può implementare un trait per un tipo solo se possiede il trait oppure il tipo. In questo modo si impediscono implementazioni in conflitto tra crate.

Verifica rapida

Verifichi la Sua comprensione dei trait.

Riepilogo

Ha imparato a definire e utilizzare i trait:

trait dichiara un comportamento condiviso
impl Trait for Type fornisce i metodi
I vincoli dei trait (T: Trait, +, where) limitano i generics
La regola dell'orfano mantiene coerenti le implementazioni

Domande Frequenti

La lezione «Definizione dei trait» è gratuita?

Sì — il testo completo di «Definizione dei 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 4 lezioni in totale.

Cosa imparerò in «Definizione dei trait»?

Comportamento condiviso 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 1 di 4.

Quanto tempo richiede la lezione «Definizione dei 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

← Torna a Learn Rust Coding