Введение в 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 | Спонсорство Mozilla | Mozilla официально поддержала разработку Rust и сформировала команду |
| 2010 | Первое публичное объявление | Впервые публично представили компилятор Rust (написанный на OCaml) на саммите Mozilla |
| 2011 | Бутстрап завершён | Компилятор Rust был переписан на самом Rust, что устранило зависимость от OCaml |
| Май 2015 | Rust 1.0 | Выпущена первая стабильная версия, что ознаменовало официальную готовность языка к промышленному использованию |
| Декабрь 2018 | Rust 2018 Edition | Выпущена первая редакция, оптимизированы синтаксис и система модулей (представлена NLL-проверка заимствований) |
| 2019 | Асинхронная экосистема обретает форму | Синтаксис async/await стабилизирован, асинхронные среды выполнения, такие как Tokio, достигли зрелости |
| 2021 | Основан Rust Foundation | AWS, Google, Huawei, Microsoft и Mozilla совместно основали Rust Foundation |
| Октябрь 2021 | Rust 2021 Edition | Представлены улучшения, такие как раздельный захват и IntoIterator для массивов |
| 2022 | Принят ядром Linux | В Linux 6.1 официально добавлена поддержка Rust, что сделало Rust вторым языком для разработки ядра |
| Февраль 2024 | Rust 2024 Edition | Дальнейшая оптимизация согласованности языка и опыта разработчиков |
Основание Rust Foundation в 2021 году стало вехой. Пять технологических гигантов — AWS, Google, Huawei, Microsoft и Mozilla — совместно обязались обеспечивать долгосрочное независимое развитие Rust, ослабив опасения сообщества по поводу «доминирования одной компании».
Rust придерживаетсявыпуска стабильной версии каждые шесть неделькак релизного цикла, а также используетмеханизм Edition(выпускается примерно каждые 3 года) для обработки несовместимых изменений языка. Один проект может смешивать крейты из разных Edition, а компилятор гарантирует обратную совместимость.
Ключевые особенности языка Rust
Набор возможностей Rust вращается вокруг трёх измерений: «безопасный, эффективный, практичный». Ниже мы разберём самые основные языковые особенности Rust по одной.
Система владения
Владение — самая уникальная и важная особенность Rust. Оно управляет памятью во время компиляции, без сборщика мусора и без ручного malloc/free.
У владения есть три основных правила:
| Правило | Описание | Значение |
|---|---|---|
| У каждого значения ровно один владелец | Значением может владеть только одна переменная в каждый момент времени | Устраняет двойное освобождение и висячие указатели |
| Когда владелец выходит из области видимости, значение освобождается | Когда переменная выходит из области видимости, Rust автоматически вызывает drop, чтобы освободить память | Не нужно вручную управлять памятью |
| В любой момент: либо одна изменяемая ссылка, либо несколько неизменяемых ссылок | Взаимоисключающие чтение/запись, сосуществующие чтение/чтение | Устраняет гонки данных на этапе компиляции |
Интуитивный опыт на уровне кода: когда переменная присваивается другой переменной, владение передаётся (move), а исходная переменная становится недействительной.
Пример
// 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-выражения чрезвычайно мощны; компилятор будетисчерпывающе проверятьвсе случаи, гарантируя, что ни одна ветвь не будет пропущена.
Пример
// 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 или исключений.
Пример
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.
Пример
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::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:
Пример
name = "hello_example" # Имя пакета (обязательно, разделяется подчёркиваниями)
version = "0.1.0" # Номер версии (обязательно, следует семантическому версионированию)
edition = "2024" # Редакция Rust (обязательно, влияет на правила синтаксиса языка)
[dependencies]
# Объявите зависимости проекта здесь, например:
# serde = { version = "1.0", features = ["derive"] }
Сгенерированный main.rs по умолчанию содержит простую программу Hello World:
Пример
// Точка входа программы на 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). Это заставляет разработчиков явно указывать, какие данные могут изменяться, делая намерение кода более ясным и облегчая компилятору оптимизацию.
Пример
// Неизменяемая переменная (по умолчанию): не может быть переприсвоена после объявления
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, isize | let x: i32 = -42; | Целочисленный тип по умолчанию — i32 |
| Беззнаковые целые числа | u8, u16, u32, u64, u128, usize | let y: u64 = 100; | usize используется для индексации и представления длин |
| Числа с плавающей запятой | f32, f64 | let pi: f64 = 3.14; | Тип с плавающей запятой по умолчанию — f64 |
| Boolean | bool | let ok: bool = true; | true или false |
| Символ | char | let 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]; | Переменная длина, выделяется в куче |
| String | String / &str | let s = String::from("hi"); | String изменяем, &str — это ссылка |
Управление потоком
Поток управления в Rust включаетif、loop、while、forиmatch. Среди них if и loop могут возвращать значения как выражения.
Пример
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 не нужно).
Пример
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 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 支持
Пример
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" # 递归遍历目录
Пример
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.
Пример
// 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-приложения, разработка игр (по сравнению со зрелыми движками) |