0Pricing
Learn Rust Coding · Урок

Определение и реализация трейтов

Освойте трейты для определения общего поведения разных типов — аналога интерфейсов в других языках.

«Определение и реализация трейтов» — бесплатный урок Learn Rust Coding на CoddyKit. Это урок 2 из 3. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения Learn Rust Coding, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс Learn Rust Coding содержит 3 уроков всего.

Что такое трейты в Rust?

В Rust трейты — это мощный способ определить общее поведение для разных типов. Представьте их как интерфейсы в других языках.

Трейт сообщает Rust, что определённый тип обладает некоторой функциональностью. Если тип реализует трейт, это означает, что он предоставляет методы, определённые этим трейтом.

  • Трейты обеспечивают полиморфизм: позволяют единообразно работать с разными типами.
  • Они играют ключевую роль в системе типов Rust и безопасных абстракциях.

Объявление Вашего первого трейта

Трейт определяется с помощью ключевого слова trait. Внутри перечисляются сигнатуры методов (имена, параметры и возвращаемые типы), которые должен предоставить любой реализующий его тип.

Давайте определим простой трейт Summary для элементов, которые можно кратко описать.

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.");
}

Реализация трейтов для типов

Чтобы тип использовал трейт, применяется синтаксис impl Trait for Type. Затем для каждого метода, определённого в трейте, предоставляется конкретная реализация.

Здесь мы реализуем Summary для структуры 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());
}

Использование функций с ограничениями трейтов

После того как тип реализует трейт, можно писать функции, принимающие любой тип, реализующий этот трейт. Это позволяет создавать гибкий обобщённый код.

Функция notify может принимать любой тип, реализующий 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 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());
}

Обобщённые функции с трейтами

При написании обобщённых функций или структур можно использовать ограничения трейтов, чтобы указать: обобщённый параметр типа T должен реализовывать определённый трейт.

Это гарантирует доступность для 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
}

Объединение нескольких ограничений трейтов

Иногда обобщённому типу требуется реализовать несколько трейтов. Указать несколько ограничений трейтов можно с помощью оператора +.

В более сложных случаях, особенно при большом количестве обобщённых параметров, предложение where может улучшить читаемость.

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

Возврат типов с помощью `impl Trait`

Синтаксис impl Trait предназначен не только для параметров функций: его также можно использовать в возвращаемых типах. Это удобно, когда нужно вернуть тип, реализующий определённый трейт, но не хочется раскрывать его точный конкретный тип.

Он упрощает сигнатуры функций и сохраняет гибкость Вашего 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());
}

Построение супер-трейтов

Иногда один трейт логически зависит от другого. Rust позволяет определять супер-трейты: это означает, что трейт может требовать, чтобы любой реализующий его тип также реализовывал другой конкретный трейт.

Это делается с помощью синтаксиса trait SubTrait: SuperTrait. Иными словами: «если Вы умеете делать X, то должны также уметь делать 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();
}

Проверьте знания о трейтах

Рассмотрите следующий фрагмент кода на Rust. Какое из следующих утверждений о трейтах и ограничениях трейтов является TRUE?

Трейты: Ваш набор инструментов для поведения

Мы изучили мощную систему трейтов Rust!

  • Трейты определяют набор методов, которые может реализовать тип, и действуют подобно интерфейсам.
  • Трейты реализуются для конкретных типов с помощью impl Trait for Type.
  • Ограничения трейтов (T: Trait) позволяют обобщённым функциям и структурам работать с любым типом, реализующим требуемый трейт.
  • У трейтов могут быть реализации по умолчанию; также можно указывать несколько ограничений трейтов (T: Trait1 + Trait2) или использовать супертрейты.
  • impl Trait также можно использовать в возвращаемых значениях, чтобы скрыть конкретные типы.

Трейты необходимы для написания гибкого, повторно используемого и безопасного кода на Rust!

Часто задаваемые вопросы

Урок «Определение и реализация трейтов» бесплатный?

Да — полный текст урока «Определение и реализация трейтов» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс Learn Rust Coding, подпишись на CoddyKit PRO. Курс Learn Rust Coding содержит 3 уроков всего.

Чему я научусь в уроке «Определение и реализация трейтов»?

Освойте трейты для определения общего поведения разных типов — аналога интерфейсов в других языках. Ты практикуешь Learn Rust Coding с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать Learn Rust Coding?

Предыдущий опыт не требуется. Learn Rust Coding на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 2 из 3.

Сколько времени занимает урок «Определение и реализация трейтов»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке Learn Rust Coding?

Да. Каждый урок Learn Rust Coding включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

  1. Написание обобщённого кода на Rust
  2. Определение и реализация трейтов
  3. Продвинутое использование трейтов: связанные типы
← Назад к Learn Rust Coding