К содержимому
← Вернуться в блог

Rust: владение памятью и явная обработка ошибок — разбор типичных ошибок

Rust часто описывают через две особенности, которые отличают его от большинства популярных языков: памятью управляет не сборщик мусора, а система владения, проверяемая на этапе компиляции, а ошибки не «бросаются» невидимо, а возвращаются как обычные значения. Для одних это обещание надёжности, для других — набор ограничений, из-за которых код «не компилируется». На практике второе чаще связано не с языком, а с типичными ошибками, которые делают почти все, кто переходит в Rust с Python, JavaScript, PHP или C++.

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

Как устроен Rust: владение вместо сборщика мусора

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

Основа всего — владение. Правила компактные:

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

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

Перемещение выглядит так:

let s = String::from("Tallinn");
let t = s;              // владение строкой перешло к t
// println!("{}", s);   // ошибка компиляции: s больше не владеет значением
println!("{}", t);

Ссылки бывают двух видов: &T — только чтение, &mut T — изменение. Правило, которое объясняет большинство ошибок заимствования: одновременно может существовать либо много неизменяемых ссылок, либо одна изменяемая, но не то и другое сразу. Так компилятор исключает целый класс гонок ещё до запуска программы.

Когда одно значение нужно в нескольких местах, используют типы с разделяемым владением: Rc<T> — счётчик ссылок в пределах одного потока, Arc<T> — атомарный счётчик, пригодный для нескольких потоков. Для изменения данных через общую ссылку есть RefCell<T> (правила заимствования проверяются во время выполнения) и Mutex<T> (блокировка для потоков). Это не отмена правил, а явное указание на то, что у разделения есть цена.

Язык развивается изданиями (editions) — так добавляют изменения, не ломая существующий код. Актуальный список изданий и их отличия стоит смотреть в официальной документации, а не в пересказах.

Типичные ошибки при работе с владением и заимствованием

Сообщения borrow checker поначалу выглядят как стена текста, но почти всегда речь об одном из трёх сценариев.

Клонировать всё подряд, чтобы компилятор замолчал

Самая распространённая реакция на ошибку заимствования — поставить .clone() и двигаться дальше. Иногда это оправдано, но как привычка клонирование скрывает суть: код начинает копировать строки, векторы и целые структуры там, где достаточно передать ссылку. На горячем пути это превращается в лишние аллокации, а в остальном коде — в путаницу: непонятно, какая копия считается «настоящей».

Практический признак проблемы: если .clone() появляется в каждом втором вызове, стоит остановиться и понять, кто на самом деле должен владеть значением. Часто помогает изменить сигнатуру функции — принимать &str вместо String и &[T] вместо Vec<T>, — а владение оставить там, где значение создаётся.

Классический конфликт заимствований, который и провоцирует «клонирование на всякий случай»:

let mut v = vec![1, 2, 3];
let first = &v[0];
v.push(4);              // ошибка: v уже заимствован
println!("{}", first);

Здесь достаточно закончить работу с first до вызова push или взять значение по индексу — и клонирование не понадобится.

Обходить borrow checker через unsafe

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

Важно: unsafe уместен для узких задач — взаимодействия с внешним кодом, низкоуровневых структур данных, работы с платформенными API. Если вы не можете словами объяснить, какие именно инварианты гарантируете вручную, этот участок лучше переписать в безопасном коде.

Хранить ссылку дольше, чем живёт владелец

Третья ошибка — структуры, хранящие ссылки, и функции, возвращающие ссылку на локальные данные. В таких местах компилятор требует явно описать время жизни:

struct Parser<'a> {
    input: &'a str,
}

В большинстве функций аннотации не нужны — они выводятся автоматически. Но как только ссылка попадает в структуру или возвращается наружу, время жизни приходится указывать, и это не формальность: аннотация документирует, сколько данные должны существовать.

Если структура должна «владеть собой» — например, парсер хранит и исходный текст, и разобранные фрагменты, ссылающиеся на него, — проще хранить индексы или диапазоны, а не ссылки, либо использовать Rc<T>. Самоссылающиеся структуры в Rust проектируют осознанно, а не собирают случайно.

Явная обработка ошибок: Option, Result и оператор «?»

В Rust нет исключений в привычном виде: сбой — это значение. Два типа покрывают большинство ситуаций.

Option<T> означает, что значения может не быть (Some или None). Это замена null: компилятор не даст обратиться к значению, не обработав вариант None.

Result<T, E> означает, что операция может завершиться ошибкой (Ok или Err). Так оформляют всё, что зависит от внешнего мира: чтение файла, сетевые запросы, разбор пользовательского ввода.

Оператор ? сокращает обработку: если результат Err, ошибка возвращается из функции, иначе извлекается значение. Требование одно — функция сама должна возвращать Result (или Option).

use std::fs;
use std::io;

fn read_config(path: &str) -> Result<String, io::Error> {
    let text = fs::read_to_string(path)?;
    Ok(text)
}

Большинство задач закрывается методами без разветвлённого match:

  • map и map_err — преобразовать значение или ошибку;
  • and_then — выстроить цепочку операций, каждая из которых может завершиться ошибкой;
  • unwrap_or, unwrap_or_else, unwrap_or_default — подставить значение по умолчанию;
  • ok_or и ok_or_else — превратить Option в Result с описанием ошибки;
  • is_some, is_none, is_ok, is_err — быстрая проверка без извлечения значения.

Для собственных типов ошибок используют перечисления и реализацию типажа std::error::Error; преобразования между типами удобно описывать через From — тогда ? работает автоматически. В экосистеме есть крейты вроде thiserror (описание своих ошибок) и anyhow (прикладной код, где важнее контекст, чем конкретный тип). Их стоит подключать, когда базовые конструкции уже понятны: иначе легко потерять представление о том, что происходит под капотом.

Ошибки в обработке ошибок: unwrap, expect и потеря контекста

Разобравшись с Result, легко уйти в противоположную крайность — обрабатывать всё формально.

unwrap и expect в библиотечном коде. Оба метода вызывают панику, если значения нет. В прототипе или тесте это нормально, но в коде, который работает с файлами, сетью или пользовательским вводом, — нет: паника обрушит поток или процесс вместо понятного сообщения. expect отличается тем, что позволяет оставить текст, объясняющий ожидание, — это минимальная форма документации.

let port: u16 = config.port.parse().expect("порт должен быть числом");

Потеря контекста. Сообщение «No such file or directory» без указания пути и шага бесполезно в логах. Стоит добавлять контекст: какой файл читали, какой запрос отправляли, какой параметр разбирали. В прикладном коде для этого удобны обёртки с сообщением и цепочкой причин.

Молчаливое проглатывание. Конструкция вида let _ = do_something(); или ветка Err с пустым телом скрывает сбой: программа продолжает работу в неверном состоянии, и найти причину потом сложно. Если ошибка действительно не важна, это стоит написать явно и хотя бы залогировать.

Паника как управление потоком. panic! предназначен для ситуаций, которые считаются ошибкой программиста — нарушен инвариант, которого не должно быть. Для ожидаемых сбоев вроде «пользователь ввёл не то» есть Result.

Смешивание уровней. Если функция возвращает Result, не стоит внутри неё печатать сообщение об ошибке и возвращать Ok(()): вызывающий код теряет возможность решить, что делать. Логирование уместно на границе приложения, а библиотека должна возвращать ошибку и не навязывать способ её показа.

Как учиться Rustу и не бросить на второй неделе

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

  1. Начните с небольших программ: разбор аргументов командной строки, обработчик CSV, консольная утилита. Они дают практику с Result, Option и владением без лишней сложности.
  2. Читайте сообщения компилятора целиком: в них обычно есть и объяснение, и предлагаемое исправление. Это самый быстрый источник знаний о языке.
  3. Держите под рукой официальную книгу «The Rust Programming Language» и документацию стандартной библиотеки — они обновляются вместе с языком.
  4. Пишите тесты сразу: cargo test, модульные тесты рядом с кодом и интеграционные в отдельной папке. В Rust тесты — обычная часть проекта, а не надстройка.
  5. Подключите rustfmt и clippy: форматирование и линтер снимают споры о стиле и подсказывают идиоматичные конструкции.
  6. Разберитесь с Cargo: зависимости, профили сборки, рабочее пространство (workspace) из нескольких крейтов. Без этого не обходится ни один реальный проект.

Совет: после каждой ошибки компилятора формулируйте своими словами, кто владеет значением и как долго живёт ссылка. Через несколько недель такие вопросы перестанут возникать — но именно эта привычка ускоряет переход.

Для портфолио полезны небольшие открытые проекты: утилита, библиотека с тестами, разбор чужого кода в репозиториях. Если вы ищете работу в Эстонии, имеет смысл смотреть и локальные площадки, и международные: часть команд, работающих с Rust, распределённые. Конкретные требования, стек и условия оплаты проверяйте в актуальных объявлениях — они быстро меняются и сильно зависят от отрасли.

Когда Rust уместен, а когда лучше выбрать другое

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

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

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

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

Чем владение в Rust отличается от сборки мусора?

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

Что такое borrow checker и можно ли его обойти?

Borrow checker — часть компилятора, которая проверяет правила заимствования: либо много неизменяемых ссылок, либо одна изменяемая. Обойти его формально можно блоком unsafe или типами вроде RefCell и Mutex, но это не отмена правил, а перенос ответственности: в первом случае проверки делает разработчик, во втором — код во время выполнения. В большинстве случаев правильнее перестроить структуру данных, чем искать обход.

Зачем в Rust Result, если в других языках есть исключения?

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

Когда допустимо использовать unwrap?

unwrap уместен в тестах, в прототипах и там, где отсутствие значения действительно означает ошибку программиста, а не ожидаемый сбой. В коде, работающем с файлами, сетью или вводом пользователя, лучше вернуть Result или использовать expect с осмысленным сообщением — но и он вызывает панику, поэтому не заменяет нормальную обработку.

Подходит ли Rust для встраиваемых систем?

Да, у языка есть режим без стандартной библиотеки (no_std) и экосистема для работы с микроконтроллерами. Rust даёт контроль над памятью без сборщика мусора и проверки на этапе компиляции, что удобно при ограниченных ресурсах. Конкретные платформы, HAL-библиотеки и требования к инструментам стоит проверять в документации выбранного микроконтроллера и соответствующих крейтов.

Сложно ли выучить Rust?

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