المتغيرات وأنواع البيانات في Rust

Что это и зачем?

Представь, что ты играешь в компьютерную игру. У тебя есть инвентарь: меч, зелье здоровья, карта сокровищ. Каждый предмет — это переменная. Ты можешь взять меч (положить его в ячейку), выпить зелье (изменить значение) или выбросить карту (удалить).

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

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

Зачем это нужно? Представь, что ты пишешь программу для калькулятора. Если ты скажешь компьютеру: "Сложи 2 и 3", он должен знать, что это числа, а не буквы. Иначе он подумает, что ты хочешь склеить "2" и "3" в "23". Типы данных помогают избежать таких ошибок.

Синтаксис и примеры кода

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

Вот как это выглядит:

// Объявляем неизменяемую переменную
let имя = "Алиса";
// имя = "Боб"; // Ошибка! Нельзя изменить

// Объявляем изменяемую переменную
let mut возраст = 10;
возраст = 11; // Теперь можно
println!("Привет, {}! Тебе {} лет.", имя, возраст);

Пример 1: Числа (целые и дробные)

// Целые числа (i32 — самый распространённый тип)
let монетки: i32 = 100; // Можно указать тип явно
let жизней = 3; // Или Rust сам догадается

// Дробные числа (f64 — для точности)
let температура = 36.6; // f64 по умолчанию
let пи: f64 = 3.14159;

println!("У тебя {} монеток и {} жизней.", монетки, жизней);
println!("Температура: {}°C, число Пи: {}", температура, пи);

Пример 2: Текст (строки)

// Строка — это текст в кавычках
let имя_пользователя = "Вася"; // &str — строковый срез
let mut сообщение = String::from("Привет, "); // String — изменяемая строка
сообщение.push_str(имя_пользователя); // Добавляем текст
сообщение.push('!'); // Добавляем символ

println!("{}", сообщение); // Выведет: "Привет, Вася!"

Пример 3: Логический тип (да/нет)

// bool — только true (истина) или false (ложь)
let солнце_светит = true;
let дождь_идет = false;

if солнце_светит {
    println!("Идём гулять!");
} else if дождь_идет {
    println!("Берём зонт.");
} else {
    println!("Смотрим в окно.");
}

Пример 4: Кортеж (набор разных типов)

// Кортеж — как рюкзак, где можно положить разные вещи
let игрок = ("Алиса", 10, true); // имя, уровень, онлайн ли
let (имя, уровень, онлайн) = игрок; // Распаковываем

println!("Игрок {} имеет уровень {}", имя, уровень);
if онлайн {
    println!("Он сейчас в игре!");
}

Пример 5: Массив (список одинаковых вещей)

// Массив — как пенал с ручками одного цвета
let инвентарь = [1, 2, 3, 4, 5]; // Пять целых чисел
let первый_предмет = инвентарь[0]; // Нумерация с 0!
println!("Первый предмет: {}", первый_предмет);

// Массив строк
let дни_недели = ["Пн", "Вт", "Ср", "Чт", "Пт", "Сб", "Вс"];
println!("Сегодня {}", дни_недели[2]); // "Ср"

Сравнение с Python

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

Идея	Python	Rust
Объявление переменной	name = "Алиса"	let name = "Алиса";
Изменение переменной	Можно всегда	Только если let mut
Тип числа	Не указываем	Нужно указать или Rust сам догадается
Строка	"текст"	"текст" (но есть нюансы)
Логический тип	True/False	true/false
Список	[1, 2, 3]	[1, 2, 3] (но массив, не список)

В Python ты можешь написать:

x = 5
x = "теперь текст"  # Python разрешит

В Rust так нельзя:

let mut x = 5;
x = "теперь текст"; // Ошибка! Тип не совпадает

Rust защищает тебя от глупых ошибок. Если ты случайно перепутаешь число и текст, компилятор скажет: "Эй, так нельзя!". Python же позволит, но потом программа может упасть в самый неподходящий момент.

Типичные ошибки новичков

Ошибка 1: Забыть точку с запятой

let x = 5 // Ошибка! Нужна ;
let y = 10; // Правильно

Ошибка 2: Пытаться изменить неизменяемую переменную

let имя = "Алиса";
имя = "Боб"; // Ошибка! Нельзя изменить

Решение: используй let mut.

Ошибка 3: Путать типы

let число = 5;
let текст = "5";
let сумма = число + текст; // Ошибка! Нельзя сложить число и текст

Решение: преобразуй типы:

let сумма = число + текст.parse::<i32>().unwrap(); // Превращаем текст в число

Ошибка 4: Выход за границы массива

let массив = [1, 2, 3];
println!("{}", массив[5]); // Ошибка! Индекс 5 не существует

Решение: проверяй длину массива (массив.len()) и используй индексы от 0 до длины минус 1.

Ошибка 5: Забыть про неизменяемость строк

let текст = "Привет";
текст.push_str(", мир!"); // Ошибка! &str нельзя изменить

Решение: используй String::from():

let mut текст = String::from("Привет");
текст.push_str(", мир!"); // Теперь работает

Итог

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

• let — объявляет переменную. По умолчанию неизменяемая.
• let mut — если нужно менять значение.
• Типы: числа (i32, f64), строки (&str, String), логические (bool), кортежи, массивы.
• Rust проверяет типы на этапе компиляции — это как проверка билета перед входом в поезд.
• Ошибки — это нормально. Компилятор подскажет, что не так.

Попробуй написать свою первую программу: объяви переменную с именем, возраст и любимый цвет. Выведи их на экран. Потом измени возраст и выведи снова. Ты увидишь, как Rust заботится о том, чтобы всё было правильно.

Помни: каждый великий программист начинал с переменных. Теперь ты знаешь то же, что и они. Удачи!