Rust 2025: Полный роадмап от новичка до профи

Почему Rust — это не просто модный тренд, а твой билет в будущее?

Представь язык программирования, который даёт тебе скорость C++ и безопасность Python. Звучит как фантастика? Добро пожаловать в мир Rust — языка, который четвёртый год подряд признают самым любимым сообществом разработчиков на Stack Overflow. В 2025 году спрос на Rust-разработчиков продолжает расти: его используют в ядре Linux, в браузере Firefox, в системах умного дома и даже в космических аппаратах NASA.

Но есть и плохая новость: Rust — не тот язык, который можно выучить за выходные. Его система владения (ownership) и borrow checker ломают привычные шаблоны мышления. Однако, если ты готов к вызову, этот роадмап проведёт тебя от первой строчки println! до продакшн-микросервисов.

Этап 1: База — не бойся компилятора, подружись с ним

Первое, что нужно понять: компилятор Rust — твой лучший друг. Он будет ругаться на каждую мелочь, но каждая его ошибка — это урок. Начни с установки инструментов:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
rustc --version  # Проверка установки
cargo --version  # Менеджер пакетов

Что нужно выучить на этом этапе:

• Переменные и изменяемость — почему let mut лучше, чем var.
• Система типов — i32, f64, char, bool и кортежи.
• Управляющие конструкции — if, loop, while, for.
• Функции — возвращаемые значения и выражения.

Вот пример, который взорвёт твой мозг, если ты привык к Python:

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // s1 больше не существует!
    // println!("{}", s1); // Ошибка компиляции!
    println!("{}", s2);
}

Это владение (ownership). В Rust нет сборщика мусора — память освобождается, как только переменная выходит из области видимости. На этом этапе используй официальную книгу "The Rust Programming Language" и Rustlings — интерактивные упражнения.

Этап 2: Система владения и заимствования — твой новый образ мыслей

Когда ты научишься писать простые программы, начни разбираться с references и borrowing. Это то, что отличает Rust от всех остальных языков. Запомни три правила:

1. В любой момент у тебя может быть либо одна изменяемая ссылка, либо сколько угодно неизменяемых.
2. Ссылки всегда должны быть валидными.
3. Нельзя иметь ссылку на данные, которые уже удалены.

Попробуй написать функцию, которая меняет два числа местами:

fn swap(x: &mut i32, y: &mut i32) {
    let temp = *x;
    *x = *y;
    *y = temp;
}

fn main() {
    let mut a = 5;
    let mut b = 10;
    swap(&mut a, &mut b);
    println!("a = {}, b = {}", a, b);
}

Этот код безопасен на 100% — никаких segfaults, никаких гонок данных. Если ты осилишь этот этап, дальше будет легче. Рекомендую книгу "Rust in Action" Тима Макнамары — она объясняет всё на реальных примерах.

Этап 3: Структуры, перечисления и сопоставление с образцом

Rust — это не C с кнопочками. У него мощная система типов, которая позволяет моделировать предметную область без наследования. Забудь про классы — используй struct и enum.

Пример: моделируем состояние заказа

enum OrderStatus {
    Pending,
    Shipped { tracking_id: String },
    Delivered { date: String },
    Cancelled { reason: String },
}

struct Order {
    id: u32,
    status: OrderStatus,
    items: Vec<String>,
}

fn process_order(order: Order) {
    match &order.status {
        OrderStatus::Pending => println!("Заказ {} ожидает обработки", order.id),
        OrderStatus::Shipped { tracking_id } => {
            println!("Заказ {} отправлен. Трек: {}", order.id, tracking_id);
        }
        OrderStatus::Delivered { date } => {
            println!("Заказ {} доставлен {}", order.id, date);
        }
        OrderStatus::Cancelled { reason } => {
            println!("Заказ {} отменён: {}", order.id, reason);
        }
    }
}

Обрати внимание на match — это не просто switch, а мощный инструмент деструктуризации. Компилятор проверит, что ты обработал все варианты. Никаких runtime-ошибок пропущенных case'ов.

Этап 4: Управление ошибками — без паники!

В Rust нет исключений. Вместо этого — типы Result<T, E> и Option<T>. Если функция может не сработать, она возвращает Result. Ты обязан обработать ошибку — компилятор не даст тебе её проигнорировать.

use std::fs::File;
use std::io::Read;

fn read_file(path: &str) -> Result<String, std::io::Error> {
    let mut file = File::open(path)?; // ? — оператор распространения ошибки
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}

fn main() {
    match read_file("data.txt") {
        Ok(content) => println!("Файл прочитан: {}", content),
        Err(e) => eprintln!("Ошибка: {}", e),
    }
}

Оператор ? — это синтаксический сахар, который автоматически возвращает ошибку наверх. Поначалу это кажется странным, но через неделю ты полюбишь этот подход. Он заставляет тебя думать о краевых случаях заранее.

Этап 5: Погружение в реальные проекты

Теперь, когда ты знаешь основы, пора переходить к практике. Вот список проектов, которые стоит реализовать:

• CLI-утилита — например, grep на Rust. Используй crate clap для парсинга аргументов.
• HTTP-сервер — напиши простой веб-сервер на hyper или actix-web.
• Парсер — разбери CSV-файл с помощью csv и serde.
• Игра "Змейка" — используй ggez или bevy для графики.

Пример простого веб-сервера на actix-web:

use actix_web::{