Введение в Rust

Rust — это системный язык программирования, разрабатываемый под руководством Mozilla Research, сбезопасностью памяти、абстракциями с нулевой стоимостьюибесстрашной конкурентностьюв качестве основных целей дизайна.

Rust появился в 2006 году как личный проект сотрудника Mozilla Грейдона Хоара, а позже, в 2009 году, был официально поддержан Mozilla, которая сформировала команду для его разработки.

Изначальной целью дизайна Rust было решить давние болевые точки C/C++ в системном программировании:проблемы безопасности памяти(нулевые указатели, висячие указатели, переполнения буфера) исложность конкурентного программирования(гонки данных, взаимоблокировки).

Философия дизайна Rust — «устранять ошибки на этапе компиляции»: с помощью мощной системы типов и механизма владения компилятор помогает ловить ошибки памяти и гонки данных, а не обнаруживать проблемы во время выполнения.

Талисман языка Rust — краб по имени Ferris, дружелюбный и милый, олицетворяющий дружелюбную и инклюзивную культуру сообщества Rust.

Ключевые цели дизайна Rust можно кратко сформулировать так:

Цель дизайнаОписание
Безопасность памяти (без GC)Гарантирует безопасность памяти на этапе компиляции с помощью системы владения, без необходимости в сборщике мусора
Абстракции с нулевой стоимостьюВысокоуровневые возможности языка не создают накладных расходов во время выполнения после компиляции, обеспечивая производительность, сопоставимую с написанным вручную низкоуровневым кодом
Бесстрашная конкурентностьСистема типов и правила владения устраняют гонки данных на этапе компиляции
ПрактичностьПозволяет писать как ядра операционных систем, так и веб-приложения, охватывая сценарии полного стека
Мощный вывод типовКомпилятор автоматически выводит большинство типов, сокращая шаблонный код
Богатый инструментарийCargo (управление пакетами + сборка), rustfmt (форматирование), clippy (линтинг) готовы к использованию сразу из коробки

История языка Rust

Rust прошёл почти два десятилетия разработки: от личного проекта до широко распространённого в мире системного языка.

ВремяВерсия/СобытиеОписание
2006Личный проектГрейдон Хоар начал проектировать язык Rust
2009Спонсорство MozillaMozilla официально поддержала разработку Rust и сформировала команду
2010Первое публичное объявлениеВпервые публично представили компилятор Rust (написанный на OCaml) на саммите Mozilla
2011Бутстрап завершёнКомпилятор Rust был переписан на самом Rust, что устранило зависимость от OCaml
Май 2015Rust 1.0Выпущена первая стабильная версия, что ознаменовало официальную готовность языка к промышленному использованию
Декабрь 2018Rust 2018 EditionВыпущена первая редакция, оптимизированы синтаксис и система модулей (представлена NLL-проверка заимствований)
2019Асинхронная экосистема обретает формуСинтаксис async/await стабилизирован, асинхронные среды выполнения, такие как Tokio, достигли зрелости
2021Основан Rust FoundationAWS, Google, Huawei, Microsoft и Mozilla совместно основали Rust Foundation
Октябрь 2021Rust 2021 EditionПредставлены улучшения, такие как раздельный захват и IntoIterator для массивов
2022Принят ядром LinuxВ Linux 6.1 официально добавлена поддержка Rust, что сделало Rust вторым языком для разработки ядра
Февраль 2024Rust 2024 EditionДальнейшая оптимизация согласованности языка и опыта разработчиков

Основание Rust Foundation в 2021 году стало вехой. Пять технологических гигантов — AWS, Google, Huawei, Microsoft и Mozilla — совместно обязались обеспечивать долгосрочное независимое развитие Rust, ослабив опасения сообщества по поводу «доминирования одной компании».

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


Ключевые особенности языка Rust

Набор возможностей Rust вращается вокруг трёх измерений: «безопасный, эффективный, практичный». Ниже мы разберём самые основные языковые особенности Rust по одной.

Система владения

Владение — самая уникальная и важная особенность Rust. Оно управляет памятью во время компиляции, без сборщика мусора и без ручного malloc/free.

У владения есть три основных правила:

ПравилоОписаниеЗначение
У каждого значения ровно один владелецЗначением может владеть только одна переменная в каждый момент времениУстраняет двойное освобождение и висячие указатели
Когда владелец выходит из области видимости, значение освобождаетсяКогда переменная выходит из области видимости, Rust автоматически вызывает drop, чтобы освободить памятьНе нужно вручную управлять памятью
В любой момент: либо одна изменяемая ссылка, либо несколько неизменяемых ссылокВзаимоисключающие чтение/запись, сосуществующие чтение/чтениеУстраняет гонки данных на этапе компиляции

Интуитивный опыт на уровне кода: когда переменная присваивается другой переменной, владение передаётся (move), а исходная переменная становится недействительной.

Пример

fn main() {
    // s1 получает владение строкой (данные хранятся в куче)
    let s1 = String::from("Hello, EXAMPLE!");

    // Владение перемещается из s1 в s2; после этого s1 больше не действителен
    let s2 = s1;

    // println!("{}", s1); // Ошибка компиляции! s1 был перемещён
    println!("{}", s2);    // Верно: s2 теперь владелец

    // Базовые типы (хранящиеся в стеке) реализуют трейт Copy, поэтому перемещение не происходит
    let x = 42;
    let y = x;  // x по-прежнему допустим, потому что i32 реализует Copy
    println!("x = {}, y = {}", x, y); // Оба можно использовать

    // Неизменяемые ссылки: несколько могут существовать одновременно
    let s3 = &s2; // Неизменяемое заимствование
    let s4 = &s2; // Ещё одно неизменяемое заимствование, разрешено
    println!("s3 = {}, s4 = {}", s3, s4);

    // Изменяемая ссылка: одновременно может существовать только одна
    let mut data = String::from("example");
    let r = &mut data; // Изменяемое заимствование
    r.push_str("!");   // Изменить исходное значение через изменяемую ссылку
    println!("После изменения: {}", r);
    // Области видимости s3 и s4 завершились, поэтому можно создавать изменяемые ссылки
}

Система владения — это «крутой склон» в кривой обучения Rust. Новички часто «борются» с компилятором, но как только вы это поймёте, вы обнаружите, что ошибки, которые ловит компилятор, могли бы быть фатальными ошибками времени выполнения в C/C++.

Сопоставление с образцом

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

Пример

fn main() {
    // match с сопоставлением чисел
    let score = 85;
    match score {
        90..=100 => println!("ПРИМЕР Оценка: A"), // Сопоставление диапазонов
        60..=89  => println!("ПРИМЕР Оценка: B"),
        0..=59   => println!("ПРИМЕР Оценка: C"),
        _ => println!("Неверная оценка"),                // Подстановочный знак, соответствует всем остальным случаям
    }

    // match с деструктуризацией кортежа
    let pair = (3, 7);
    match pair {
        (0, y) => println!("Первое — 0, второе — {}", y),
        (x, 0) => println!("Первое — {}, второе — 0", x),
        (x, y) => println!("Два значения: {} и {}", x, y),
    }
}

Перечисления и Option/Result

Перечисления Rust могут содержать данные, а в сочетании с match они обеспечивают безопасное и выразительное управление потоком.

В стандартной библиотеке,Option<T>иResult<T, E>являются двумя самыми основными типами перечислений, обрабатывающими сценарии «возможно отсутствует» и «возможно ошибочный» соответственно — в Rust нет null или исключений.

Пример

use std::fs;

fn main() {
    // Option<T>: значение может существовать или отсутствовать (заменяет null)
    let numbers = vec![10, 20, 30];
    let first = numbers.get(0);   // Возвращает Option<&i32>
    let missing = numbers.get(5); // Возвращает Option<&i32>

    match first {
        Some(&val) => println!("Первый элемент: {}", val),
        None => println!("Не найдено"),
    }

    // Более лаконичный способ: if let
    if let Some(&val) = missing {
        println!("Найдено: {}", val);
    } else {
        println!("Индекс 5 не существует");  // Эта ветка ожидается
    }

    // Result<T, E>: операция может успешно завершиться или завершиться ошибкой (заменяет исключения)
    let content = fs::read_to_string("config.txt");
    match content {
        Ok(text) => println!("Содержимое файла: {}", text),
        Err(e) => println!("Ошибка чтения: {}", e),
    }
}

В Rust нет значений null и нет механизма исключений try-catch. Option и Result проверяются на этапе компиляции — если вы забудете выполнить проверку, код не скомпилируется. Это принципиально исключает исключения, связанные с нулевыми указателями, и неперехваченные исключения.

Абстракции с нулевой стоимостью

Высокоуровневые возможности Rust (итераторы, замыкания, дженерики) после компиляции полностью эквивалентны написанным вручную низкоуровневым циклам, без дополнительных накладных расходов во время выполнения.

Это означает, что вы можете писать код в функциональном стиле, достигая производительности на уровне C.

Пример

fn main() {
    let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    // Цепочка итераторов — выглядит как высокоуровневая абстракция
    // После компиляции разворачивается в машинный код, эквивалентный написанному вручную циклу for.
    let result: Vec<i32> = data
        .iter()            // Получить итератор
        .filter(|&x| x % 2 == 0) // Отфильтровать чётные числа
        .map(|&x| x * x)         // Возвести в квадрат
        .collect();              // Собрать в Vec

    println!("{:?}", result); // [4, 16, 36, 64, 100]
}

Бесстрашная конкурентность

Система типов Rust и правила владенияво время компиляцииустраняют гонки данных. Трейты Send и Sync автоматически помечают, можно ли безопасно передавать тип между потоками или совместно использовать его.

Если вы попытаетесь совместно использовать непотокобезопасные данные между потоками, компилятор сразу сообщит об ошибке — а не будет ждать, пока в продакшене во время выполнения появятся странные ошибки конкурентности.

Пример

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    // Arc (атомарный подсчёт ссылок) используется для совместного владения между потоками
    // Mutex обеспечивает взаимоисключающий доступ
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for i in 0..10 {
        // Клонируйте Arc, чтобы каждый поток хранил ссылку на одни и те же данные
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            // lock() захватывает мьютекс и возвращает MutexGuard
            let mut num = counter.lock().unwrap();
            *num += 1; // Измените внутреннее значение путём разыменования
            println!("Поток {} завершил накопление, текущее значение: {}", i, *num);
        });
        handles.push(handle);
    }

    // Дождаться завершения всех потоков
    for handle in handles {
        handle.join().unwrap();
    }

    println!("Итоговое значение: {}", *counter.lock().unwrap());
}

Cargo: универсальный инструмент сборки

Cargo — официальный менеджер пакетов и система сборки Rust, объединяющая управление зависимостями, компиляцию, тестирование, генерацию документации и публикацию.

По сравнению с фрагментированным опытом в экосистеме C/C++, где требуется вручную настраивать CMake/Makefile и менеджеры пакетов, Cargo предлагает универсальное решение "из коробки".

КомандаФункцияТипичный сценарий
cargo new projectСоздать новый проектИнициализировать проект, автоматически создавая Cargo.toml и src/main.rs
cargo buildСкомпилировать проект (режим отладки)Разработка и отладка
cargo build --releaseСкомпилировать проект (режим оптимизации)Релизная сборка для production со всеми оптимизациями компилятора
cargo runСкомпилировать и запуститьБыстро протестировать код
cargo testЗапустить тестыМодульные тесты, интеграционные тесты, тесты документации
cargo checkБыстро проверить, компилируется ли код (без генерации бинарного файла)Проверка синтаксиса в реальном времени в IDE
cargo doc --openСгенерировать и открыть документациюПросмотр документации API библиотек-зависимостей
cargo clippyПроверка стиля кода (lint)Выявление нерекомендуемых практик и потенциальных проблем
cargo fmtФорматирование кодаПриведение стиля кода к единому виду
cargo publishПубликация в crates.ioПубликация библиотеки с открытым исходным кодом

cargo check — очень полезная команда в процессе разработки. Она проверяет только синтаксис и типы и не создаёт исполняемый файл, поэтому гораздо быстрее, чем cargo build. Большинство плагинов Rust для IDE автоматически запускают cargo check при сохранении файлов.


Области применения языка Rust

Благодаря безопасности памяти и высокой производительности Rust стремительно распространяется во множестве областей.

Системное программирование и высокопроизводительные серверы

Это «родная стихия» Rust — подходит для сценариев, требующих экстремальной производительности и высокой безопасности памяти. Асинхронный runtimeTokioи веб-фреймворкиActix Web、Axumотлично показывают себя в сценариях с высокой конкурентностью.

WebAssembly

Rust —один из лучших языков для компиляции в WebAssembly. Его абстракции с нулевой стоимостью и отсутствие GC делают артефакты Wasm небольшими и высокопроизводительными.

Фронтенд-фреймворкиYewиLeptosпозволяют писать SPA-приложения на Rust. Figma, Cloudflare Workers и т. д. активно используют Rust + Wasm в продакшене.

Встраиваемые системы и IoT

Режимno_stdв Rust позволяет работать на «голом железе» без операционной системы, что подходит для устройств с ограниченными ресурсами, таких как MCU и датчики.

RTIC(фреймворк конкурентности с прерываниями в реальном времени) иEmbassy(асинхронный встраиваемый фреймворк) — показательные проекты встраиваемого Rust.

CLI-инструменты

Rust компилируется в автономные бинарники с отличной производительностью, создавая множество звёздных CLI-инструментов:

ИнструментФункцияЗаменяет
ripgrep (rg)Сверхбыстрый поиск по кодуgrep
fdБыстрый поиск файловнайти
batПросмотр файлов с подсветкой синтаксисаcat
дельтаGit diff с подсветкой синтаксисаgit diff
zoxideУмная навигация по каталогамcd
dustАнализ дискового пространстваdu

Блокчейн и Web3

Rust занимает важное место в области блокчейна.SolanaЯдро цепочки написано на Rust,Sui、Aptos、Polkadot(Substrate)а другие новые публичные блокчейны также используют Rust в качестве основного языка разработки.

Базы данных и инфраструктура данных

Высокопроизводительные базы данных и системы обработки данных — сильная сторона Rust:TiKV(распределённое KV-хранилище, слой хранения TiDB),SurrealDB、Polars(библиотека DataFrame),Databend(облачное хранилище данных), и т. д. — все они созданы на Rust.

Операционные системы и инфраструктура

Rust вошёл в ядро Linux (6.1+). Google переписывает стеки Bluetooth и Wi-Fi на Rust в Android, а Microsoft также переписывает некоторые компоненты в ядре Windows с использованием Rust.

Для хобби-проектов,Redox OS— это Unix-подобная операционная система, полностью написанная с нуля на Rust.


Быстрый старт

Rust официально предоставляет чрезвычайно удобный инструмент установки rustup, который управляет компилятором, менеджером пакетов и документацией одной командой.

Установка Rust

# Unix/macOS
$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# 验证安装
$ rustc --version
rustc 1.85.0 (4d91de4e4 2025-02-17)

$ cargo --version
cargo 1.85.0

Ваша первая программа на Rust

Использование Cargo для создания проекта — наиболее рекомендуемый подход; он автоматически создаёт стандартную структуру проекта.

# 创建新项目
$ cargo new hello_example
     Created binary (application) `hello_example` package

# 项目结构
hello_example/
├── Cargo.toml     # 项目元数据和依赖配置
└── src/
    └── main.rs    # 程序入口文件

Cargo.toml — это файл конфигурации проекта, аналогичный package.json в Node.js:

Пример

[package]
name = "hello_example"           # Имя пакета (обязательно, разделяется подчёркиваниями)
version = "0.1.0"               # Номер версии (обязательно, следует семантическому версионированию)
edition = "2024"                # Редакция Rust (обязательно, влияет на правила синтаксиса языка)

[dependencies]
# Объявите зависимости проекта здесь, например:
# serde = { version = "1.0", features = ["derive"] }

Сгенерированный main.rs по умолчанию содержит простую программу Hello World:

Пример

// Путь к файлу: src/main.rs
// Точка входа программы на Rust: каждая исполняемая программа должна иметь функцию main

fn main() {
    // println! — это макрос (обратите внимание на символ ! после него)
    // Макросы раскрываются в более сложный код во время компиляции
    println!("Привет, EXAMPLE!");
    println!("Добро пожаловать в мир языка Rust");
}
# 编译并运行
$ cargo run
   Compiling hello_example v0.1.0
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.52s
     Running `target/debug/hello_example`
Hello, EXAMPLE!
欢迎来到 Rust 语言的世界

Обзор базового синтаксиса

Синтаксис Rust заимствует сильные стороны функциональных языков и системных языков. Ниже — краткий обзор наиболее часто используемых элементов синтаксиса; каждый пример — это законченная программа, которую можно запустить напрямую.

Переменные и изменяемость

Переменные в RustНеизменяемы по умолчанию(immutable). Это заставляет разработчиков явно указывать, какие данные могут изменяться, делая намерение кода более ясным и облегчая компилятору оптимизацию.

Пример

fn main() {
    // Неизменяемая переменная (по умолчанию): не может быть переприсвоена после объявления
    let name = "EXAMPLE";
    // name = "other"; // Ошибка компиляции! Неизменяемым переменным нельзя присвоить новое значение
    println!("Name: {}", name);

    // Изменяемая переменная: явно объявлена с помощью ключевого слова mut
    let mut score = 0;
    println!("Initial score: {}", score);
    score = 100;       // Можно изменять
    println!("Обновлённый счёт: {}", score);

    // Затенение переменной: повторное объявление переменной с тем же именем с помощью let
    let x = 5;
    let x = x + 1;      // Новая переменная x затеняет старую x со значением 6
    let x = x * 2;      // Снова затенена со значением 12
    println!("Итоговое значение x: {}", x);

    // Константа: определяется во время компиляции, тип должен быть указан, в именовании принято использовать только заглавные буквы
    const MAX_POINTS: u32 = 100_000;
    println!("Максимальное количество очков: {}", MAX_POINTS);
}

Затенение переменной — это не то же самое, что mut. Затенение использует let для повторного объявления новой переменной с тем же именем, что может изменить тип; mut просто позволяет изменять значение той же переменной, при этом тип остаётся неизменным.

Базовые типы данных

Rust — статически типизированный язык; компилятор должен знать тип каждой переменной во время компиляции.

КатегорияTypeПримерОписание
Целые числа со знакомi8, i16, i32, i64, i128, isizelet x: i32 = -42;Целочисленный тип по умолчанию — i32
Беззнаковые целые числаu8, u16, u32, u64, u128, usizelet y: u64 = 100;usize используется для индексации и представления длин
Числа с плавающей запятойf32, f64let pi: f64 = 3.14;Тип с плавающей запятой по умолчанию — f64
Booleanboollet ok: bool = true;true или false
Символcharlet c = 'R';4 байта, представляющие скалярное значение Unicode
Tuple(T1, T2, ...)let t: (i32, f64) = (10, 3.14);Фиксированная длина, элементы могут иметь разные типы
Массив[T; N]let a: [i32; 3] = [1, 2, 3];Фиксированная длина, одинаковый тип, выделяется в стеке
Срез&[T]let s: &[i32] = &a[..];Ссылочное представление массива или Vec
Динамический массивVec<T>let v: Vec<i32> = vec![1,2,3];Переменная длина, выделяется в куче
StringString / &strlet s = String::from("hi");String изменяем, &str — это ссылка

Управление потоком

Поток управления в Rust включаетif、loop、while、forиmatch. Среди них if и loop могут возвращать значения как выражения.

Пример

fn main() {
    let score = 75;

    // if — это выражение и может возвращать значение (все ветви должны возвращать один и тот же тип)
    let grade = if score >= 90 {
        "A"
    } else if score >= 60 {
        "B"
    } else {
        "C"
    };
    println!("EXAMPLE rating: {}", grade);

    // loop — это бесконечный цикл (выход через break, может возвращать значение)
    let mut count = 0;
    let result = loop {
        count += 1;
        if count == 5 {
            break count * 2; // break, за которым следует значение, действует как возвращаемое значение цикла
        }
    };
    println!("loop return value: {}", result);

    // цикл while с условием
    let mut n = 3;
    while n > 0 {
        println!("Обратный отсчет: {}", n);
        n -= 1;
    }

    // итерация for in (используется чаще всего)
    let items = ["яблоко", "банан", "вишня"];
    for (i, item) in items.iter().enumerate() {
        println!("Элемент {}: {}", i + 1, item);
    }

    // итерация for in по диапазону
    for num in 1..=3 { // 1..=3 представляет 1, 2, 3 (включая оба конца)
        println!("Число: {}", num);
    }
}

Функции

Функции Rust используют ключевое словоfnдля объявления, а параметры и возвращаемые значения должны быть явно аннотированы типами. Значение последнего выражения является возвращаемым значением (ключевое слово return не нужно).

Пример

// Обычная функция: принимает два i32, возвращает их сумму
fn add(a: i32, b: i32) -> i32 {
    a + b  // Последнее выражение автоматически используется как возвращаемое значение (обратите внимание, в конце нет точки с запятой)
}

// Возврат нескольких значений: используйте кортеж, чтобы вернуть несколько значений
fn divide(a: f64, b: f64) -> (f64, String) {
    if b == 0.0 {
        return (0.0, String::from("Ошибка: делитель не может быть нулём"));
    }
    (a / b, String::from("OK")) // Возвращает кортеж
}

// Обобщённая функция: использует ограничения типажей, чтобы ограничить поведение параметров типа
fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];
    for item in list {
        if item > largest {
            largest = item;
        }
    }
    largest
}

fn main() {
    // Вызов обычной функции
    let sum = add(10, 20);
    println!("10 + 20 = {}", sum);

    // Вызов функции с несколькими возвращаемыми значениями
    let (result, msg) = divide(10.0, 2.0);
    println!("10 / 2 = {} ({})", result, msg);

    // Случай деления на ноль
    let (result, msg) = divide(10.0, 0.0);
    println!("10 / 0 = {} ({})", result, msg);

    // Вызов обобщённой функции
    let nums = vec![3, 7, 2, 9, 5];
    println!("ПРИМЕР максимальное число: {}", largest(&nums));
}

Структуры и блоки impl

Rust используетstructдля определения структур данных и используетimplблоки для реализации методов для структур. Это похоже на стиль определения методов в Go, но организация языка более компактна.

Пример

// Определяет структуру (похожую на struct в C, но более мощную)
struct User {
    name: String,         // Тип String, владеет данными
    email: String,
    active: bool,
    login_count: u64,     // u64 — это беззнаковое 64-битное целое число
}

// блок impl реализует методы для User
impl User {
    // Ассоциированная функция (как статический метод): создаёт новый экземпляр
    fn new(name: String, email: String) -> Пользователь {
        Пользователь {
            name,
            email,
            active: true,     // Значение по умолчанию
            login_count: 0,   // Значение по умолчанию
        }
    }

    // Метод: &self представляет неизменяемую ссылку на экземпляр
    fn summary(&self) -> String {
        format!("{} ({}) - Количество входов: {}", self.name, self.email, self.login_count)
    }

    // Метод: &mut self представляет изменяемую ссылку на экземпляр
    fn login(&mut self) {
        self.login_count += 1;
    }
}

fn main() {
    // Создает экземпляр с помощью ассоциированной функции
    let mut user = User::new(
        String::from("example"),
        String::from("example@example.com"),
    );

    println!("{}", user.summary());

    // Имитирует вход
    user.login();
    user.login();
    println!("Вы вошли {} раз", user.login_count);
}

Типичные примеры

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

Создание сервиса HTTP API

Используйте фреймворк Axum (основанный на асинхронной среде выполнения Tokio) для создания HTTP API с JSON-ответами.

Сначала добавьте зависимости в Cargo.toml:

# Cargo.toml
[dependencies]
axum = "0.8"              # Web 框架
tokio = { version = "1", features = ["full"] }  # 异步运行时
serde = { version = "1", features = ["derive"] } # 序列化
serde_json = "1"           # JSON 支持

Пример

// Путь к файлу: src/main.rs
use axum::{
    extract::Query,
    response::Json,
    routing::get,
    Router,
};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

// Структура параметров запроса (десериализация)
#[derive(Deserialize)]
struct HelloParams {
    name: Option<String>, // Option обозначает необязательный параметр
}

// Структура ответа (сериализация)
#[derive(Serialize)]
struct ApiResponse {
    code: u16,
    message: String,
    data: Option<HashMap<String, String>>, // Необязательное поле data
}

// Обрабатывает запросы GET /hello
// Query(HelloParams) автоматически извлекает name из параметров запроса URL
async fn hello_handler(Query(params): Query<HelloParams>) -> Json<ApiResponse> {
    let name = params.name.unwrap_or_else(|| String::from("EXAMPLE"));

    let mut data = HashMap::new();
    data.insert("name".to_string(), name.clone());

    Json(ApiResponse {
        code: 200,
        message: format!("Привет, {}! Добро пожаловать в HTTP-сервис на Rust", name),
        data: Some(data),
    })
}

// Макрос #[tokio::main] преобразует async fn main в среду выполнения Tokio
#[tokio::main]
async fn main() {
    // Создание маршрутизатора
    let app = Router::new()
        .route("/hello", get(hello_handler));

    // Привязывает адрес и запускает сервис
    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080")
        .await
        .unwrap();

    println!("ПРИМЕР: сервер запущен, прослушивается по адресу: http://localhost:8080");
    println!("Пример доступа: http://localhost:8080/hello?name=Rust开发者");

    axum::serve(listener, app).await.unwrap();
}
$ cargo run
EXAMPLE 服务器启动,监听地址: http://localhost:8080
访问示例: http://localhost:8080/hello?name=Rust开发者

# 使用 curl 测试
$ curl http://localhost:8080/hello?name=Rust开发者
{"code":200,"message":"你好,Rust开发者!欢迎访问 Rust HTTP 服务","data":{"name":"Rust开发者"}}

$ curl http://localhost:8080/hello
{"code":200,"message":"你好,EXAMPLE!欢迎访问 Rust HTTP 服务","data":{"name":"EXAMPLE"}}

Axum — один из самых популярных веб-фреймворков в экосистеме Rust, поддерживаемый командой Tokio. Он в полной мере использует систему типов Rust для проверки таких операций, как извлечение параметров маршрута и совместное использование состояния, во время компиляции, что значительно снижает количество ошибок времени выполнения.

Инструмент пакетной обработки файлов

Это инструмент CLI, близкий к реальным сценариям: он рекурсивно обходит каталоги, подсчитывает количество строк и размеры всех файлов и агрегирует их по расширению.

Добавьте зависимости в Cargo.toml:

# Cargo.toml
[dependencies]
walkdir = "2"  # 递归遍历目录

Пример

// Путь к файлу: src/main.rs
use std::collections::HashMap;
use std::fs;
use walkdir::WalkDir; // Сторонняя библиотека для рекурсивного обхода каталогов

fn main() {
    let path = "."; // Сканирование, начиная с текущего каталога

    // Статистика: сгруппировано по расширению файлов
    // HashMap<extension, (количество файлов, всего строк, всего байт)>
    let mut stats: HashMap<String, (usize, usize, u64)> = HashMap::new();

    // WalkDir рекурсивно обходит каталоги, автоматически пропуская скрытые файлы и каталог .git
    for entry in WalkDir::new(path)
        .into_iter()
        .filter_map(|e| e.ok()) // Отфильтровывает недоступные записи
        .filter(|e| e.file_type().is_file()) // Обрабатывать только файлы
    {
        // Получить расширение файла
        let ext = entry
            .path()
            .extension()
            .and_then(|e| e.to_str())
            .unwrap_or("(без расширения)")
            .to_lowercase();

        // Читать содержимое файла (только текстовые файлы; двоичные файлы могут отображаться как искажённый текст, но это не повлияет на статистику)
        if let Ok(content) = fs::read_to_string(entry.path()) {
            let line_count = content.lines().count();
            let size = entry.metadata().map(|m| m.len()).unwrap_or(0);

            let (count, lines, total_size) = stats.entry(ext).or_insert((0, 0, 0));
            *count += 1;
            *lines += line_count;
            *total_size += size;
        }
    }

    // Сортировать по количеству файлов в порядке убывания и вывести
    let mut sorted: Vec<_> = stats.into_iter().collect();
    sorted.sort_by(|a, b| b.1 .0.cmp(&a.1 .0));

    println!("=== ПРИМЕР Статистика файлов в каталоге ===");
    println!("{:<15} {:>8} {:>10} {:>12}", "Расширение", "Количество файлов", "Всего строк", "Общий размер (байт)");
    println!("{}", "-".repeat(50));
    for (ext, (count, lines, size)) in &sorted {
        println!("{:<15} {:>8} {:>10} {:>12}", ext, count, lines, size);
    }
}
$ cargo run --release
=== EXAMPLE 目录文件统计 ===
扩展名            文件数       总行数   总大小(bytes)
--------------------------------------------------
rs                  12        856        28432
toml                 3         45         1534
md                   2        120         3412
html                 1        510        14256
(无扩展名)            1          8          210

Справочник по общим инструментам и командам

Помимо встроенных возможностей Cargo, экосистема Rust предоставляет ряд инструментов для повышения эффективности разработки:

КомандаФункцияОписание
rustup updateОбновить набор инструментов RustОбновить rustc, cargo и т. д. до последней стабильной версии
rustup component add rustfmtУстановить инструмент форматирования кодаАвтоматически форматировать код при сохранении
rustup component add clippyУстановить инструмент линтинга кодаНайти нерекомендуемые шаблоны кода и потенциальные ошибки
rustup docОткрыть локальную документациюПросмотреть стандартную библиотеку и The Book офлайн
cargo add <crate>Добавить зависимостьАвтоматически редактировать Cargo.toml и загружать последнюю версию
cargo updateОбновить версии зависимостейОбновить Cargo.lock в соответствии с ограничениями версий в Cargo.toml
cargo treeПросмотреть дерево зависимостейВизуализировать полную схему зависимостей проекта
cargo benchЗапуск бенчмарковИзмерение производительности кода
cargo install <tool>Установка CLI-инструментов, написанных на Rustнапример, cargo install ripgrep

Примечания и типичные проблемы

Ниже перечислены проблемы, с которыми чаще всего сталкиваются начинающие Rust-разработчики, и рекомендации по лучшим практикам.

Борьба с компилятором — это нормально

Кривая обучения Rust, как широко известно, сначала крутая, а затем более пологая.Владение и проверка заимствований— это самое большое препятствие на старте.

Когда компилятор раз за разом отклоняет написанный вами код, не унывайте — это как раз показывает, что компилятор помогает вам отлавливать потенциальные ошибки времени выполнения. По мере накопления опыта вы постепенно привыкнете думать на Rust, и компилятор станет вашим самым надёжным партнёром, а не врагом.

Разница между String и &str

Это концепция, которую начинающие в Rust путают чаще всего.String— это владеющая строка, выделенная в куче (изменяемая),&str— неизменяемая ссылка на строковые данные (заимствованное представление), обычно получаемая путём автоматического разыменования &String.

Пример

fn main() {
    // String: владеет данными, изменяемая, находится в куче
    let mut s = String::from("Hello");

    // &str: ссылка, неизменяемая, обычно используется как параметр функции
    let slice: &str = "EXAMPLE"; // Строковые литералы сами являются &str

    s.push_str(", world!"); // String можно изменять
    println!("{}", s);
    println!("{}", slice);

    // Использование &str (а не String) для параметров функции более гибко
    greet("EXAMPLE");          // Можно передать &str напрямую
    greet(&s);                // Также может автоматически преобразовываться из &String в &str
}

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

Обработка ошибок: panic! против Result

Rust различаетнеустранимые ошибки(используяpanic!, программа завершается) ивосстанавливаемые ошибки(используяResult, вызывающая сторона решает, как с ними обращаться).

В библиотечном коде следует возвращать Result, а не panic!, предоставляя вызывающей стороне выбор. В приложениях можно решать в зависимости от конкретной ситуации.

unsafe: используйте с осторожностью, но это необходимо

Rust предоставляет ключевое словоunsafe, которое позволяет выполнять низкоуровневые операции, такие как работа с сырыми указателями и вызов внешних функций (FFI).

unsafe не означает «отключение проверок безопасности»; скорее, он возлагает на разработчиков ответственность за ту часть безопасности, которую компилятор не может автоматически гарантировать. Большинству прикладного кода не нужно использовать unsafe — если вы замечаете, что используете его часто, это может быть признаком того, что вашу архитектуру нужно скорректировать.

Длительное время компиляции

Rust известен долгим временем компиляции, особенно в крупных проектах. Это связано с тем, что компилятор выполняет множество проверок (анализ владения, проверку времён жизни, разрешение трейтов и т. д.) и оптимизаций во время компиляции.

Меры смягчения: используйтеcargo checkвместо cargo build для повседневной разработки; разбивайте большие крейты на подкрейты, чтобы задействовать инкрементальную компиляцию; используйтеsccacheдля кэширования результатов компиляции; обновляйте аппаратное обеспечение (особенно SSD и больше ядер CPU).

Рекомендации по пути обучения

Для начинающих изучать Rust рекомендуется следующий порядок обучения:

  • ПрочитайтеThe Rust Programming Language(официальная книга, бесплатная), уделяя особое внимание главам о владении
  • Читайте и пишите код на Rust Playground (play.rust-lang.org), чтобы получать немедленную обратную связь от компилятора
  • С помощьюRustlingsвыполняйте небольшие упражнения, чтобы закрепить синтаксис
  • ЧитайтеRust by Example, учитесь на примерах
  • Попробуйте переписать небольшой проект, с которым вы знакомы, на Rust, чтобы на практике понять проектные компромиссы Rust

Итог

Благодаря своимбезопасности памяти (без GC),、абстракциям с нулевой стоимостьюибезбоязненной конкурентности —трём ключевым преимуществам — Rust занимает уникальную нишу в таких областях, как системное программирование, высокопроизводительные сервисы, WebAssembly и блокчейн.

Хотя кривая обучения крутая, строгие проверки компилятора оборачиваются чрезвычайно высоким качеством кода и сопровождаемостью в долгосрочных проектах — вот почему всё больше компаний и проектов с открытым исходным кодом выбирают Rust.

Преимущества Rust и подходящие сценарии использования кратко изложены ниже:

ИзмерениеПроизводительность Rust
Кривая обученияКрутая (система владения требует понимания и адаптации), но концепции стабильны; освоив их однажды, вы получаете пользу на всю жизнь
Скорость компиляцииОтносительно медленная (многочисленные проверки на этапе компиляции), но компенсируется с помощью cargo check и инкрементальной компиляции
Производительность во время выполненияНа том же уровне, что C/C++, значительно превосходя языки с GC
Безопасность памятиГарантируется на этапе компиляции, GC не требуется, нет нулевых указателей, висячих указателей или переполнений буфера
Безопасность конкурентностиУстраняет гонки данных на этапе компиляции, бесстрашная конкурентность
Зрелость экосистемыБыстро растёт, уже очень зрелая в системном программировании, WebAssembly и блокчейне
Лучше всего подходит дляСистемное программирование, высокопроизводительные бэкенды, WebAssembly, встраиваемые системы, блокчейн, инструменты CLI, базы данных
Не очень подходит дляБыстрое прототипирование (время компиляции), настольные GUI-приложения, разработка игр (по сравнению со зрелыми движками)
Другие расширения