Immutable vs const в Rust: в чем разница? Гайд 2025

Immutable vs const в Rust: почему путаются даже опытные разработчики?

Вы когда-нибудь писали на Rust и вдруг задумывались: «Стоп, я объявил переменную через let, она неизменяема. А const — это тоже вроде константа. В чем тогда разница?». Если да — вы не одиноки. Вопрос «What is the difference between immutable and const variables in Rust?» на Stack Overflow набрал тысячи просмотров. И это не случайно.

На первый взгляд кажется, что и let x = 5, и const X: i32 = 5 делают одно и то же: запрещают менять значение. Но в Rust, языке, где безопасность памяти и производительность стоят во главе угла, дьявол кроется в деталях. В 2025 году понимание этих деталей — не просто теория, а необходимость для написания эффективного и идиоматичного кода.

В этой статье мы раз и навсегда разберемся: чем отличается immutable переменная от константы, когда что использовать, и какие лучшие практики актуальны прямо сейчас. Поехали!

1. Базовое понимание: что говорит компилятор?

Давайте начнем с самого простого. В Rust переменные по умолчанию иммутабельны (неизменяемы). Это значит, что после присвоения значения вы не можете его перезаписать.

fn main() {
    let x = 5;
    // x = 6; // Ошибка! Нельзя изменить immutable переменную
    println!("x = {}", x);
}

А вот пример с константой:

const MAX_POINTS: u32 = 100_000;

fn main() {
    println!("MAX_POINTS = {}", MAX_POINTS);
}

Визуально — похоже. Но компилятор Rust обрабатывает их совершенно по-разному. И вот тут начинается самое интересное.

1.1. Ключевое отличие №1: где они живут?

• let — объявляет переменную. Она существует в стеке (или куче, если это Box, String и т.д.) и имеет адрес в памяти. Ее можно брать по ссылке, передавать в функции, перемещать.
• const — объявляет константу. Она не имеет фиксированного адреса в памяти. Компилятор инлайнит (встраивает) её значение прямо в код в месте использования.

Это фундаментальная разница. const — это не переменная, это именованное значение, которое подставляется на этапе компиляции.

fn main() {
    let x = 42;
    let y = &x; // Ок, берем ссылку на переменную

    const Z: i32 = 100;
    // let w = &Z; // Ошибка! У константы нет адреса, нельзя взять ссылку
}

2. Глубокое погружение: производительность и семантика

Теперь, когда мы знаем про «место жительства», давайте разберем другие важные аспекты.

2.1. Время жизни и область видимости

Константы живут в глобальной области видимости (или внутри функции, но с static временем жизни). Они существуют все время работы программы. Их можно объявить вне функции, и они будут доступны везде.

Immutable переменные живут только внутри блока (функции, цикла, if). Как только блок заканчивается, память освобождается.

const GLOBAL_CONST: i32 = 10;

fn main() {
    let local_var = 20;
    // local_var живет только внутри main
}
// local_var больше не существует
// GLOBAL_CONST все еще доступен

2.2. Тип и аннотации

Для const обязательно указывать тип данных. Для let — компилятор выведет его сам.

const PI: f64 = 3.14159; // Обязательно: const ИМЯ: Тип = значение;
let pi = 3.14159; // Компилятор сам поймет, что это f64

2.3. Вычисление на этапе компиляции (CTFE)

Значение const должно быть вычислено на этапе компиляции. Это значит, что вы не можете вызвать функцию, которая, например, читает файл, внутри const. Только константные функции (const fn) и литералы.

const fn cube(x: i32) -> i32 {
    x * x * x
}

const CUBE_OF_5: i32 = cube(5); // Ок, вычисляется во время компиляции

fn main() {
    let a = 5;
    // const BAD: i32 = a * 2; // Ошибка! a - runtime переменная
}

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

3. Immutable vs const: таблица сравнения

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

Сводная таблица различий

4. Лучшие практики в 2025 году: что выбрать?

Теперь, когда мы знаем разницу, давайте ответим на главный вопрос: когда что использовать? Вот рекомендации, которые актуальны в 2025 году.

4.1. Используйте const для:

• <