Переменные, типы данных и вывод типов в Rust

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

1. Переменные в Rust

1.1 Объявление переменных

В Rust переменные объявляются с помощью ключевого слова let. По умолчанию переменные неизменяемые (immutable), что способствует безопасности данных:

let x = 5; // Неизменяемая переменная
// x = 10; // Ошибка: нельзя изменить неизменяемую переменную

Для создания изменяемой переменной используется ключевое слово mut:

let mut y = 10;
y = 20; // Корректно, так как y объявлена как изменяемая

1.2 Затенение (Shadowing)

Rust позволяет “затенять” переменные, объявляя новую переменную с тем же именем:

let z = 5;
let z = z + 1; // Новая переменная z = 6
let z = "теперь строка"; // Тип переменной изменен на &str

Затенение полезно для преобразования значений без создания новых имен.

2. Скалярные типы данных

Скалярные типы представляют одиночные значения. В Rust к ним относятся:

2.1 Целочисленные типы

Rust предоставляет целые числа разных размеров и знаков:

Знаковые: i8, i16, i32 (по умолчанию), i64, i128, isize.
Беззнаковые: u8, u16, u32, u64, u128, usize.

Примеры:

let a: i32 = -42; // Знаковое 32-битное число
let b: u8 = 255;  // Беззнаковое 8-битное число

2.2 Числа с плавающей точкой

Поддерживаются типы f32 и f64 (по умолчанию):

let c = 3.14; // f64
let d: f32 = 2.718; // f32

2.3 Логический тип

Тип bool имеет два значения: true и false:

let is_valid: bool = true;

2.4 Символьный тип

Тип char представляет Unicode-символ и занимает 4 байта:

let emoji: char = '🚀';

3. Составные типы данных

Составные типы группируют несколько значений. Базовыми в Rust являются кортежи и массивы.

3.1 Кортежи (Tuples)

Кортежи позволяют хранить значения разных типов фиксированной длины:

let tuple: (i32, f64, char) = (42, 3.14, 'R');

Доступ к элементам:

let first = tuple.0; // 42
let (x, y, z) = tuple; // Деструктуризация

3.2 Массивы (Arrays)

Массивы хранят элементы одного типа фиксированного размера:

let arr: [i32; 3] = [1, 2, 3];
let zeros = [0; 5]; // [0, 0, 0, 0, 0]

Доступ по индексу:

let first = arr[0]; // 1

4. Вывод типов

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

4.1 Примеры вывода

let x = 5; // Выводится как i32
let y = 3.14; // Выводится как f64
let z = vec![1, 2, 3]; // Vec<i32>

4.2 Вывод в функциях

Компилятор анализирует контекст использования переменных. Например:

let numbers = vec![1, 2, 3];
let doubled: Vec<_> = numbers.iter().map(|x| x * 2).collect();
// Тип x выводится как &i32, результат коллекции — Vec<i32>

4.3 Когда требуется явная аннотация

В некоторых случаях вывод невозможен. Например:

let parsed: i32 = "42".parse().expect("Не число!"); // Тип результата parse() нужно указать явно.

5. Заключение

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

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

Эти концепции формируют основу для работы с данными в Rust и способствуют созданию надежных приложений.