🦀 Rust

Итоговый практический проект в Rust: подробное руководство

Урок 35 / 35 • Полная теория для чтения

Что это такое и зачем? (аналогия из реальной жизни)

Представь, что ты учишься готовить. Сначала ты узнаёшь, как чистить овощи (переменные). Потом — как резать их разными способами (типы данных). Затем — как смешивать ингредиенты (функции) и как включать духовку по таймеру (циклы). Но настоящее мастерство приходит, когда ты берёшь все эти навыки и готовишь полноценное блюдо — борщ, пиццу или торт. Вот это и есть итоговый практический проект.

В программировании итоговый проект — это твоя первая самостоятельная программа, которая решает реальную задачу. Не просто «выведи Hello, World!», а нечто полезное: калькулятор, заметки, игра, погодный информер. Это твой шанс соединить всё, что ты выучил, в единое целое.

💡 Аналогия из жизни: Представь, что ты собираешь конструктор LEGO. Отдельные кирпичики — это переменные, функции, циклы. Инструкция — это алгоритм. А итоговый проект — это собранный замок, который можно показать друзьям и сказать: «Я это сделал сам!»

Зачем это нужно? Во-первых, проект учит тебя думать как программист. Ты перестаёшь просто повторять за учителем и начинаешь принимать решения: как назвать переменную, как разбить задачу на части, как обработать ошибку. Во-вторых, проект — это твоё портфолио. Когда ты скажешь: «Я написал игру "Змейка" на Rust», — это звучит круче, чем «Я решил 50 задач на codewars».

Теория: как это работает изнутри

Любой проект, даже самый маленький, состоит из трёх слоёв, как пирог:

Ввод-вывод (I/O). Программа должна общаться с внешним миром: читать нажатия клавиш, файлы, данные из интернета. В Rust за это отвечают модули std::io и std::fs.
Логика (бизнес-логика). Это «мозг» программы. Если это калькулятор — то, как складываются числа. Если игра — то, как двигается персонаж. Логика не должна зависеть от того, откуда пришли данные — с клавиатуры или из файла.
Хранение данных. Куда сохранять результаты? В оперативную память (пока программа работает) или на диск (чтобы не потерять после выключения)? В Rust для этого есть структуры, векторы, а для файлов — std::fs::File.

Главная идея: разделение ответственности. Каждая часть программы делает только своё дело. Функция, которая читает ввод, не должна заниматься вычислениями. Функция, которая вычисляет, не должна спрашивать: «А вывести результат на экран?» Это делает код понятным, безопасным и лёгким для изменений.

В Rust есть ещё одна важная особенность — владение (ownership). Когда ты передаёшь данные из одной части программы в другую, Rust строго следит, кто ими владеет. Это предотвращает ошибки, которые в других языках приводят к «вылетам» программы. В проекте это особенно важно: если ты неправильно передашь данные, компилятор просто не даст собрать программу.

⚠️ Важно: В Rust нет «мусорщика» (garbage collector), который сам чистит память. Всё управление памятью происходит через правила владения. Это звучит страшно, но на практике означает, что твоя программа будет работать быстро и без сюрпризов.

Синтаксис в Rust: все формы и варианты

Давай разберём ключевые конструкции, которые тебе понадобятся в любом проекте. Я покажу их в виде таблицы, чтобы было удобно сверяться.

1. Переменные и константы

Конструкция	Описание	Пример
`let x = 5;`	Неизменяемая переменная	`let name = "Анна";`
`let mut y = 10;`	Изменяемая переменная	`let mut score = 0;`
`const MAX: u32 = 100;`	Константа (тип обязателен)	`const PI: f64 = 3.14159;`
`let z: i32 = 42;`	Явное указание типа	`let age: u8 = 16;`

2. Функции

Конструкция	Описание	Пример
`fn name() {}`	Функция без параметров	`fn greet() { println!("Привет!"); }`
`fn name(x: i32) {}`	Функция с параметром	`fn double(x: i32) { println!("{}", x*2); }`
`fn name() -> i32 {}`	Функция, возвращающая значение	`fn five() -> i32 { 5 }`
`fn name(x: i32) -> i32 { x + 1 }`	С параметром и возвратом	`fn add_one(x: i32) -> i32 { x + 1 }`

3. Управляющие конструкции

Конструкция	Описание	Пример
`if x > 5 { } else { }`	Условный оператор	`if age >= 18 { println!("Взрослый"); }`
`loop { }`	Бесконечный цикл	`loop { println!("Бесконечность!"); break; }`
`while x > 0 { }`	Цикл с условием	`while x > 0 { x -= 1; }`
`for i in 0..5 { }`	Цикл по диапазону	`for i in 0..5 { println!("{}", i); }`
`for item in vec { }`	Цикл по коллекции	`for name in names.iter() { }`

4. Структуры и перечисления

Конструкция	Описание	Пример
`struct Point { x: i32, y: i32 }`	Структура с полями	`let p = Point { x: 10, y: 20 };`
`impl Point { fn new() -> Self { } }`	Методы структуры	`impl Point { fn area(&self) -> i32 { self.x * self.y } }`
`enum Color { Red, Green, Blue }`	Перечисление	`let c = Color::Red;`
`match c { Color::Red => {}, _ => {} }`	Сопоставление с образцом	`match c { Color::Red => "красный", _ => "другой" }`

5. Работа с ошибками

Конструкция	Описание	Пример
`Result`	Тип для обработки ошибок	`fn div(x: i32, y: i32) -> Result`
`Ok(value)`	Успешный результат	`Ok(42)`
`Err(msg)`	Ошибка	`Err("Деление на ноль".to_string())`
`?`	Оператор распространения ошибки	`let x = do_something()?;`
`unwrap()`	Извлечение значения (паника при ошибке)	`let x = result.unwrap();`

📌 Совет: В проекте старайся использовать Result и оператор ? вместо unwrap(). Это сделает программу устойчивой к ошибкам.

Примеры кода — от простого к сложному

Теперь перейдём к практике. Каждый пример — это маленький шаг к большому проекту.

Пример 1: Приветствие пользователя

// Самая простая программа с вводом и выводом
use std::io; // Подключаем модуль для работы с вводом/выводом

fn main() {
    // Создаём изменяемую строку для хранения имени
    let mut name = String::new();
    
    // Просим пользователя ввести имя
    println!("Как тебя зовут?");
    
    // Читаем строку из стандартного ввода
    // &mut — передаём изменяемую ссылку на строку
    io::stdin().read_line(&mut name).expect("Ошибка чтения");
    
    // Убираем символ переноса строки в конце
    let name = name.trim();
    
    // Выводим приветствие
    println!("Привет, {}! Добро пожаловать в мир Rust!", name);
}

Объяснение: Здесь мы учимся базовому вводу-выводу. read_line читает строку, trim() убирает лишние пробелы и переносы строки. expect — это простой способ обработать ошибку: если чтение не удалось, программа остановится с сообщением.

Пример 2: Простой калькулятор (сложение)

use std::io;

fn main() {
    println!("Введите первое число:");
    let mut input1 = String::new();
    io::stdin().read_line(&mut input1).expect("Ошибка");
    
    println!("Введите второе число:");
    let mut input2 = String::new();
    io::stdin().read_line(&mut input2).expect("Ошибка");
    
    // Преобразуем строки в числа. parse() возвращает Result
    let a: i32 = input1.trim().parse().expect("Это не число!");
    let b: i32 = input2.trim().parse().expect("Это не число!");
    
    let sum = a + b;
    println!("{} + {} = {}", a, b, sum);
}

Объяснение: Мы научились преобразовывать строку в число с помощью parse(). Если пользователь введёт не число, программа сообщит об ошибке и завершится.

Пример 3: Функция для вычисления площади прямоугольника

// Определяем структуру для прямоугольника
struct Rectangle {
    width: f64,
    height: f64,
}

// Реализуем методы для структуры
impl Rectangle {
    // Метод для вычисления площади
    fn area(&self) -> f64 {
        self.width * self.height
    }
    
    // Метод для проверки, является ли прямоугольник квадратом
    fn is_square(&self) -> bool {
        self.width == self.height
    }
}

fn main() {
    // Создаём экземпляр структуры
    let rect = Rectangle {
        width: 5.0,
        height: 3.0,
    };
    
    println!("Площадь: {}", rect.area());
    println!("Это квадрат? {}", rect.is_square());
}

Объяснение: Мы создали структуру с двумя полями и реализовали для неё методы. &self — это ссылка на текущий объект. Методы позволяют группировать логику, относящуюся к одному типу данных.

Пример 4: Работа с вектором и циклом

fn main() {
    // Создаём вектор с числами
    let numbers = vec![10, 20, 30, 40, 50];
    
    // Переменная для хранения суммы
    let mut sum = 0;
    
    // Проходим по всем элементам вектора
    for num in &numbers {
        sum += num;
        println!("Текущее число: {}, сумма: {}", num, sum);
    }
    
    // Вычисляем среднее арифметическое
    let average = sum as f64 / numbers.len() as f64;
    println!("Сумма: {}, Среднее: {:.2}", sum, average);
}

Объяснение: vec! — макрос для создания вектора. for num in &numbers — мы берём ссылки на элементы, чтобы не перемещать их. as f64 — преобразование типа для точного деления.

Пример 5: Обработка ошибок с Result

use std::io;

// Функция, которая может вернуть ошибку
fn divide(a: f64, b: f64) -> Result {
    if b == 0.0 {
        // Возвращаем ошибку
        Err("На ноль делить нельзя!".to_string())
    } else {
        // Возвращаем успешный результат
        Ok(a / b)
    }
}

fn main() {
    println!("Введите делимое:");
    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    let a: f64 = input.trim().parse().unwrap_or(0.0);
    
    println!("Введите делитель:");
    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    let b: f64 = input.trim().parse().unwrap_or(0.0);
    
    // Обрабатываем результат с помощью match
    match divide(a, b) {
        Ok(result) => println!("Результат: {}", result),
        Err(error) => println!("Ошибка: {}", error),
    }
}

Объяснение: Функция divide возвращает Result. В main мы используем match для обработки обоих вариантов: успеха и ошибки. unwrap_or — если преобразование не удалось, используем значение по умолчанию.

Пример 6: Чтение и запись в файл

use std::fs::File;
use std::io::{self, Write, Read};

fn main() -> io::Result<()> {
    // Создаём или открываем файл для записи
    let mut file = File::create("notes.txt")?;
    
    // Записываем строку в файл
    file.write_all(b"Привет, файл!
Это вторая строка.")?;
    
    // Закрываем файл (произойдёт автоматически при выходе из области видимости)
    // Теперь читаем файл
    let mut file = File::open("notes.txt")?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    
    println!("Содержимое файла:
{}", contents);
    
    Ok(())
}

Объяснение: File::create создаёт файл (или перезаписывает существующий). write_all записывает байты. File::open открывает для чтения. Оператор ? автоматически возвращает ошибку, если что-то пошло не так. Функция main возвращает io::Result<()>, чтобы можно было использовать ?.

Пример 7: Простая игра «Угадай число»

use std::io;
use std::cmp::Ordering;
use rand::Rng; // Для генерации случайных чисел

fn main() {
    println!("Угадай число от 1 до 100!");
    
    // Генерируем случайное число
    let secret_number = rand::thread_rng().gen_range(1..=100);
    
    loop {
        println!("Введи своё предположение:");
        
        let mut guess = String::new();
        io::stdin().read_line(&mut guess).expect("Ошибка");
        
        // Преобразуем в число. Если не число — просим ввести снова
        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("Пожалуйста, введите число!");
                continue;
            }
        };
        
        // Сравниваем с загаданным числом
        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Слишком мало!"),
            Ordering::Greater => println!("Слишком много!"),
            Ordering::Equal => {
                println!("Поздравляю! Ты угадал!");
                break;
            }
        }
    }
}

Объяснение: Это полноценная игра. Мы используем rand::Rng для генерации случайного числа. cmp сравнивает два числа и возвращает Ordering. match обрабатывает три варианта. Если пользователь вводит не число, мы не паникуем, а просим ввести снова.

Пример 8: TODO-список (консольное приложение)

use std::io::{self, Write};

struct Task {
    description: String,
    completed: bool,
}

impl Task {
    fn new(description: String) -> Task {
        Task {
            description,
            completed: false,
        }
    }
    
    fn mark_done(&mut self) {
        self.completed = true;
    }
    
    fn display(&self, index: usize) {
        let status = if self.completed { "[✓]" } else { "[ ]" };
        println!("{} {}: {}", status, index + 1, self.description);
    }
}

fn main() {
    let mut tasks: Vec = Vec::new();
    
    loop {
        println!("
--- Мой TODO-список ---");
        println!("1. Добавить задачу");
        println!("2. Показать все задачи");
        println!("3. Отметить задачу как выполненную");
        println!("4. Выйти");
        print!("Выбери действие: ");
        io::stdout().flush().unwrap();
        
        let mut choice = String::new();
        io::stdin().read_line(&mut choice).unwrap();
        let choice: u32 = match choice.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };
        
        match choice {
            1 => {
                print!("Введи описание задачи: ");
                io::stdout().flush().unwrap();
                let mut desc = String::new();
                io::stdin().read_line(&mut desc).unwrap();
                tasks.push(Task::new(desc.trim().to_string()));
                println!("Задача добавлена!");
            }
            2 => {
                if tasks.is_empty() {
                    println!("Список пуст!");
                } else {
                    for (i, task) in tasks.iter().enumerate() {
                        task.display(i);
                    }
                }
            }
            3 => {
                print!("Введи номер задачи: ");
                io::stdout().flush().unwrap();
                let mut num = String::new();
                io::stdin().read_line(&mut num).unwrap();
                let num: usize = match num.trim().parse() {
                    Ok(n) if n > 0 && n <= tasks.len() => n - 1,
                    _ => {
                        println!("Неверный номер!");
                        continue;
                    }
                };
                tasks[num].mark_done();
                println!("Задача отмечена!");
            }
            4 => {
                println!("До свидания!");
                break;
            }
            _ => println!("Неверный выбор!"),
        }
    }
}

Объяснение: Это уже полноценное приложение. Мы используем структуру Task, вектор для хранения задач, цикл для меню. flush() нужен, чтобы текст появился на экране до того, как программа запросит ввод. enumerate() даёт нам индекс элемента.

Сравнение с Python: чем похоже и чем отличается

Характеристика	Rust	Python
Скорость выполнения	Очень быстрый (компилируемый)	Медленнее (интерпретируемый)
Управление памятью	Владение (ownership) — без сборщика мусора	Автоматический сборщик мусора
Безопасность	Максимальная — компилятор ловит ошибки на этапе сборки	Ошибки могут проявиться во время выполнения
Синтаксис	Строгий, требует явного указания типов	Гибкий, динамическая типизация
Обучение	Крутой старт, но потом легче	Лёгкий старт, но сложнее в больших проектах
Экосистема	Меньше библиотек, но качественные	Огромное количество библиотек
Применение	Системное программирование, игры, веб-серверы	Наука о данных, веб, автоматизация
Обработка ошибок	`Result` и `Option` — явная	Исключения (try/except)
Параллелизм	Безопасный по умолчанию	Требует осторожности

Главное отличие: В Python ты можешь написать x = 5, а потом x = "строка" — и это сработает. В Rust так нельзя: тип переменной фиксирован. Это кажется неудобным, но именно это делает Rust-программы надёжными. Ты тратишь 10 минут на исправление ошибок компиляции, но потом программа работает годами без сбоев.

Сходство: Оба языка поддерживают функциональный стиль (замыкания, итераторы), оба имеют понятные синтаксис для циклов и условий. Если ты знаешь Python, ты быстро освоишь Rust — нужно только привыкнуть к строгости.

Типичные ошибки и подводные камни

Забыл mut. Хочешь изменить переменную? Напиши let mut. Иначе компилятор скажет: «Нельзя изменить неизменяемое».
Ошибка заимствования. Нельзя иметь изменяемую и неизменяемую ссылку одновременно. Например:
```
let mut v = vec![1, 2, 3];
let first = &v[0];  // неизменяемая ссылка
v.push(4);          // ОШИБКА: изменяемая ссылка уже существует
println!("{}", first);
```
Решение: используй first до того, как изменишь v.
Паника при unwrap(). Если ты уверен, что ошибки нет — используй unwrap(). Но в проекте лучше обрабатывать ошибки через match или ?.
Забыл & в цикле. for item in vec перемещает владение. Если тебе нужно только прочитать — пиши for item in &vec.
Несоответствие типов. Нельзя сложить i32 и f64 без явного преобразования: let x = 5i32 + 5.0f64; — ошибка. Нужно: let x = 5i32 as f64 + 5.0;
Бесконечный цикл без break. Если используешь loop, не забудь условие выхода.
Игнорирование предупреждений компилятора. Rust часто подсказывает, как улучшить код. Не игнорируй warning — они могут указывать на потенциальные ошибки.

🔥 Совет: Если компилятор выдаёт ошибку — прочитай её полностью. Rust славится понятными сообщениями об ошибках. Часто там даже написано, как её исправить.

Лучшие практики и советы профессионалов

Начинай с малого. Не пытайся написать идеальный проект сразу. Сначала сделай минимальную работающую версию (MVP). Потом добавляй функции.
Используй cargo. cargo new project_name создаст структуру проекта. cargo build соберёт, cargo run запустит. cargo check проверит код без сборки.
Разбивай на модули. Когда проект становится большим, выноси логику в отдельные файлы. mod utils; — и создавай файл utils.rs.
Пиши тесты. Rust поддерживает тестирование «из коробки». Добавь #[test] перед функцией и запускай cargo test.
Документируй код. /// — это doc-комментарии. Они превращаются в документацию командой cargo doc.
Используй clippy. Установи cargo clippy — это линтер, который найдёт стилистические ошибки и предложит улучшения.
Не бойся переписывать. Первый проект редко бывает идеальным. Напиши, проанализируй, перепиши — это нормально.
Читай чужой код. Зайди на GitHub, найди проекты на Rust, посмотри, как устроены популярные библиотеки.

Вопросы для самопроверки

Вопрос: Что такое Result и зачем он нужен?
Ответ: Result — это перечисление, которое может быть Ok(T) (успех) или Err(E) (ошибка). Он нужен для явной обработки ошибок, чтобы программа не падала неожиданно.
Вопрос: Чем отличается let x = 5 от let mut x = 5?
Ответ: В первом случае x неизменяемая — её нельзя изменить после инициализации. Во втором — изменяемая, можно присвоить новое значение.
Вопрос: Почему в Rust нельзя одновременно иметь изменяемую и неизменяемую ссылку?
Ответ: Это защищает от гонок данных. Если бы можно было читать и писать одновременно, программа могла бы прочитать некорректные данные.
Вопрос: Что делает оператор ? в функции, возвращающей Result?
Ответ: Если результат Ok — извлекает значение. Если Err — немедленно возвращает ошибку из функции.
Вопрос: Как создать вектор с числами от 1 до 10?
Ответ: let v: Vec<i32> = (1..=10).collect();
Вопрос: Что такое match и для чего он используется?
Ответ: match — это конструкция сопоставления с образцом. Она позволяет обработать все возможные варианты значения (например, варианты перечисления или Result).
Вопрос: Как прочитать строку из стандартного ввода?
Ответ:
```
let mut input = String::new();
std::io::stdin().read_line(&mut input).expect("Ошибка");
```
Вопрос: Что такое cargo?
Ответ: Это система сборки и пакетный менеджер Rust. Позволяет создавать проекты, управлять зависимостями, собирать и тестировать код.
Вопрос: Как объявить

← Предыдущая Тестирование кода в Rust: подробное руководство