Горячие клавиши

Нажмите ← или → для перехода между главами

Нажмите S или / для поиска по книге

Нажмите ?, чтобы показать эту справку

Нажмите Esc, чтобы скрыть эту справку

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

Как упоминалось в разделе «Хранение значений с помощью переменных», по умолчанию переменные неизменяемы. Это один из многих приёмов, которыми Rust подталкивает писать код так, чтобы использовать преимущества безопасности и простой конкурентности, которые предлагает Rust. Однако по-прежнему есть возможность сделать переменные изменяемыми. Далее рассматривается, как и почему Rust поощряет предпочтение неизменяемости и почему иногда может возникнуть желание от неё отказаться.

Когда переменная неизменяема, после привязки значения к имени это значение нельзя изменить. Чтобы проиллюстрировать это, создайте новый проект с именем variables в каталоге projects, выполнив команду cargo new variables.

Затем в новом каталоге variables откройте src/main.rs и замените его код следующим кодом, который пока не будет компилироваться:

Имя файла: src/main.rs

fn main() {
    let x = 5;
    println!("The value of x is: {x}");
    x = 6;
    println!("The value of x is: {x}");
}

Сохраните и запустите программу с помощью cargo run. Должно появиться сообщение об ошибке, связанное с неизменяемостью, как показано в этом выводе:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
error[E0384]: cannot assign twice to immutable variable `x`
 --> src/main.rs:4:5
  |
2 |     let x = 5;
  |         - first assignment to `x`
3 |     println!("The value of x is: {x}");
4 |     x = 6;
  |     ^^^^^ cannot assign twice to immutable variable
  |
help: consider making this binding mutable
  |
2 |     let mut x = 5;
  |         +++

For more information about this error, try `rustc --explain E0384`.
error: could not compile `variables` (bin "variables") due to 1 previous error

Этот пример показывает, как компилятор помогает находить ошибки в программах. Ошибки компилятора могут расстраивать, но на самом деле они означают лишь то, что программа ещё не делает безопасно то, что должно делать; они не означают, что вы плохой программист! Опытные Rustaceans по-прежнему получают ошибки компилятора.

Получено сообщение об ошибке cannot assign twice to immutable variable `x`, потому что была предпринята попытка присвоить второе значение неизменяемой переменной x.

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

Но изменяемость может быть очень полезной и делать код удобнее для написания. Хотя переменные по умолчанию неизменяемы, их можно сделать изменяемыми, добавив mut перед именем переменной, как это было сделано в главе 2. Добавление mut также передаёт намерение будущим читателям кода, указывая, что другие части кода будут изменять значение этой переменной.

Например, изменим src/main.rs на следующий код:

Имя файла: src/main.rs

fn main() {
    let mut x = 5;
    println!("The value of x is: {x}");
    x = 6;
    println!("The value of x is: {x}");
}

При запуске программы теперь получаем:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/variables`
The value of x is: 5
The value of x is: 6

При использовании mut разрешено изменять значение, привязанное к x, с 5 на 6. В конечном счёте решение об использовании изменяемости или нет зависит от вас и от того, что, по вашему мнению, яснее в конкретной ситуации.

Объявление констант

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

Во-первых, с константами нельзя использовать mut. Константы не просто неизменяемы по умолчанию — они всегда неизменяемы. Константы объявляются с помощью ключевого слова const вместо ключевого слова let, и тип значения обязательно должен быть аннотирован. Типы и аннотации типов рассматриваются в следующем разделе, «Типы данных», поэтому не стоит беспокоиться о деталях сейчас. Достаточно знать, что тип нужно указывать всегда.

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

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

Вот пример объявления константы:

#![allow(unused)]
fn main() {
const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;
}

Имя константы — THREE_HOURS_IN_SECONDS, а её значение установлено равным результату умножения 60 (количество секунд в минуте) на 60 (количество минут в часе) на 3 (количество часов, которые нужно посчитать в этой программе). Соглашение об именовании констант в Rust — использовать только заглавные буквы с подчёркиваниями между словами. Компилятор способен вычислить ограниченный набор операций во время компиляции, что позволяет записать это значение так, чтобы его было проще понять и проверить, вместо того чтобы задавать эту константу равной значению 10 800. См. раздел справочника Rust о константных вычислениях для получения дополнительной информации о том, какие операции можно использовать при объявлении констант.

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

Именование жёстко закодированных значений, используемых во всей программе, константами полезно для передачи смысла этого значения будущим сопровождающим кода. Это также помогает иметь только одно место в коде, которое нужно было бы изменить, если бы жёстко закодированное значение потребовалось обновить в будущем.

Затенение

Как было показано в руководстве по игре в угадайку в главе 2, можно объявить новую переменную с тем же именем, что и предыдущая переменная. Rustaceans говорят, что первая переменная затенена второй, что означает, что компилятор будет видеть вторую переменную при использовании имени переменной. Фактически вторая переменная заслоняет первую, забирая себе все использования имени переменной до тех пор, пока она сама не будет затенена или пока не закончится область видимости. Затенить переменную можно, используя то же имя переменной и повторив использование ключевого слова let следующим образом:

Имя файла: src/main.rs

fn main() {
    let x = 5;

    let x = x + 1;

    {
        let x = x * 2;
        println!("The value of x in the inner scope is: {x}");
    }

    println!("The value of x is: {x}");
}

Эта программа сначала привязывает x к значению 5. Затем она создаёт новую переменную x, повторяя let x =, беря исходное значение и добавляя 1, так что значение x становится 6. Затем во внутренней области видимости, созданной с помощью фигурных скобок, третья инструкция let также затеняет x и создаёт новую переменную, умножая предыдущее значение на 2, так что x получает значение 12. Когда эта область видимости заканчивается, внутреннее затенение заканчивается, и x снова становится 6. При запуске этой программы будет выведено следующее:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/variables`
The value of x in the inner scope is: 12
The value of x is: 6

Затенение отличается от пометки переменной как mut, потому что при случайной попытке переприсвоить этой переменной значение без использования ключевого слова let будет получена ошибка времени компиляции. Используя let, можно выполнить несколько преобразований над значением, но после завершения этих преобразований переменная будет неизменяемой.

Другое различие между mut и затенением состоит в том, что, поскольку при повторном использовании ключевого слова let фактически создаётся новая переменная, можно изменить тип значения, сохранив то же имя. Например, пусть программа просит пользователя показать, сколько пробелов он хочет между некоторым текстом, введя пробельные символы, а затем требуется сохранить этот ввод как число:

fn main() {
    let spaces = "   ";
    let spaces = spaces.len();
}

Первая переменная spaces имеет строковый тип, а вторая переменная spaces имеет числовой тип. Таким образом, затенение избавляет от необходимости придумывать другие имена, такие как spaces_str и spaces_num; вместо этого можно повторно использовать более простое имя spaces. Однако при попытке использовать mut для этого, как показано здесь, будет получена ошибка времени компиляции:

fn main() {
    let mut spaces = "   ";
    spaces = spaces.len();
}

В ошибке говорится, что изменять тип переменной не разрешено:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
error[E0308]: mismatched types
 --> src/main.rs:3:14
  |
2 |     let mut spaces = "   ";
  |                      ----- expected due to this value
3 |     spaces = spaces.len();
  |              ^^^^^^^^^^^^ expected `&str`, found `usize`

For more information about this error, try `rustc --explain E0308`.
error: could not compile `variables` (bin "variables") due to 1 previous error

Теперь, когда рассмотрено, как работают переменные, можно перейти к другим типам данных, которые они могут иметь.