Введение в язык программирования Rust

Урок №1: Введение в Rust — Программируем как настоящие инженеры!

Добро пожаловать в мир Rust!

Привет, будущий программист! Сегодня мы начинаем удивительное путешествие в мир языка Rust. Ты когда-нибудь задумывался, как создаются программы, которые работают на твоём компьютере, в браузере или даже в космических ракетах? Rust — это именно тот язык, который используют инженеры, чтобы делать программы быстрыми, надёжными и безопасными.

Представь, что обычный язык программирования — это как велосипед. На нём можно ездить, но он может сломаться, если неправильно крутить педали. А Rust — это как космический корабль. Он сам следит за тем, чтобы ты не ошибся, и не даёт программе "упасть" в самый ответственный момент. Звучит круто? Поехали!

Что такое Rust и почему он особенный?

Rust — это язык программирования, который придумали в компании Mozilla (той самой, что делает браузер Firefox). Его главная фишка — безопасность памяти. Не пугайся сложного слова! Давай разберём на примере.

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

Это делает программы на Rust очень быстрыми (как на C или C++) и одновременно безопасными (никаких неожиданных ошибок). Именно поэтому Rust используют в браузерах, играх, операционных системах и даже в NASA!

Установка Rust: готовим инструменты

Прежде чем писать код, нам нужно установить Rust. Это очень просто!

1. Зайди на официальный сайт: rustup.rs
2. Скачай и запусти установщик (он называется rustup).
3. Следуй инструкциям на экране. На вопрос "какой компонент установить?" просто нажми Enter.
4. После установки открой терминал (командную строку) и введи: rustc --version. Если ты видишь номер версии (например, rustc 1.75.0), то всё получилось!

Поздравляю! Теперь у тебя есть суперсила — компилятор rustc. Он превращает твой код в работающую программу.

Первая программа: "Привет, мир!"

Давай напишем нашу первую программу. Это традиция всех программистов — начинать с фразы "Hello, world!" ("Привет, мир!").

Создай папку для проекта, например, my_first_rust. Внутри создай файл main.rs (расширение .rs означает, что это файл на Rust). Открой его в любом текстовом редакторе (подойдёт даже Блокнот, но лучше использовать Visual Studio Code).

Напиши следующий код:

// Это комментарий. Он не влияет на программу, просто объяснение.
// Функция main() — это точка входа. Программа начинается отсюда.
fn main() {
    // println! — это макрос (специальная команда), который печатает текст.
    println!("Привет, мир!");
}

Теперь сохрани файл. В терминале перейди в папку с файлом (команда cd в Windows или cd в Mac/Linux) и выполни:

rustc main.rs

Компилятор создаст исполняемый файл. В Windows это main.exe, в Mac/Linux — просто main. Запусти его:

• В Windows: main.exe
• В Mac/Linux: ./main

Ты увидишь на экране: Привет, мир!

Ура! Ты только что написал свою первую программу на Rust! Давай разберём, что здесь произошло.

Анатомия программы: разбираем по косточкам

Каждая программа на Rust состоит из функций. Функция — это как рецепт: набор инструкций, которые выполняются по порядку. Главная функция всегда называется main. Без неё программа не запустится.

Строка fn main() { означает:

• fn — сокращение от function (функция).
• main — имя функции.
• () — скобки для параметров (пока они пустые).
• { } — фигурные скобки, внутри которых находится тело функции.

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

Запомни! В Rust каждая инструкция заканчивается точкой с запятой ;. Это как точка в конце предложения. Если забыть точку с запятой, компилятор "обидится" и выдаст ошибку.

Переменные: коробки для данных

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

В Rust переменные объявляются с помощью ключевого слова let:

fn main() {
    // Создаём переменную "имя" и кладём в неё текст "Алиса"
    let имя = "Алиса";
    
    // Создаём переменную "возраст" и кладём в неё число 12
    let возраст = 12;
    
    // Выводим на экран
    println!("Привет, меня зовут {} и мне {} лет.", имя, возраст);
}

Запусти эту программу. Ты увидишь: Привет, меня зовут Алиса и мне 12 лет.

Обрати внимание на фигурные скобки {} внутри println!. Они работают как "дырки", в которые подставляются значения переменных. Первая {} заменяется на значение первой переменной после строки, вторая — на вторую и так далее.

Типы данных: числа, буквы и правда/ложь

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

Основные типы:

• Числа: i32 (целое число, например, 42), f64 (число с плавающей точкой, например, 3.14).
• Текст: &str (строка текста, например, "Привет").
• Логический: bool (правда или ложь: true или false).

Rust может сам догадаться о типе, если это очевидно. Но иногда нужно указать тип явно:

fn main() {
    let число: i32 = 10;      // Явно указываем, что это целое число
    let дробь: f64 = 3.1415;  // Это число с плавающей точкой
    let правда: bool = true;  // Логическое значение
    
    println!("Число: {}, Дробь: {}, Правда: {}", число, дробь, правда);
}

Изменяемые и неизменяемые переменные

В Rust есть важное правило: по умолчанию все переменные неизменяемые (immutable). Это значит, что если ты положил значение в коробку, ты не можешь его заменить. Звучит странно? На самом деле это защита от ошибок!

Попробуй изменить значение переменной:

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

Компилятор выдаст ошибку. Чтобы разрешить изменение, нужно добавить ключевое слово mut (от mutable — изменяемый):

fn main() {
    let mut x = 5;  // Теперь x можно менять
    println!("Сначала x = {}", x);
    
    x = 6;  // Меняем значение
    println!("Теперь x = {}", x);
}

Вывод программы:

Сначала x = 5
Теперь x = 6

Правило простое: если переменная не mut, её нельзя изменить. Это помогает избежать случайных изменений, которые могут сломать программу.

Комментарии: общаемся с будущим собой

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

В Rust два вида комментариев:

• Однострочный: начинается с //. Всё, что после // до конца строки — комментарий.
• Многострочный: начинается с /* и заканчивается */. Можно писать несколько строк.

fn main() {
    // Это однострочный комментарий
    let x = 10; // И это комментарий
    
    /*
        Это многострочный комментарий.
        Он может занимать несколько строк.
        Удобно для больших пояснений.
    */
    let y = 20;
    
    println!("x + y = {}", x + y);
}

Совет: всегда комментируй сложные части кода. Через месяц ты скажешь себе спасибо!

Математические операции: считаем как компьютер

Rust умеет выполнять все основные математические операции:

• + — сложение
• - — вычитание
• * — умножение
• / — деление (целые числа делятся без остатка)
• % — остаток от деления (например, 7 % 3 = 1)

fn main() {
    let a = 10;
    let b = 3;
    
    let сумма = a + b;
    let разность = a - b;
    let произведение = a * b;
    let частное = a / b;       // Целочисленное деление: 10 / 3 = 3
    let остаток = a % b;       // Остаток: 10 % 3 = 1
    
    println!("Сумма: {}", сумма);
    println!("Разность: {}", разность);
    println!("Произведение: {}", произведение);
    println!("Частное: {}", частное);
    println!("Остаток: {}", остаток);
}

Обрати внимание: при делении целых чисел результат — тоже целое число. Если нужно получить дробный результат, используй числа с плавающей точкой (f64):

fn main() {
    let a: f64 = 10.0;
    let b: f64 = 3.0;
    let частное = a / b;  // Теперь будет 3.333...
    println!("Частное: {}", частное);
}

Ввод данных: программа спрашивает, пользователь отвечает

Пока наши программы только выводят текст. Но настоящие программы ещё и читают ввод от пользователя! Давай научимся это делать.

Для ввода нам понадобится стандартная библиотека std::io. Вот пример:

use std::io;  // Подключаем модуль для ввода/вывода

fn main() {
    println!("Как тебя зовут?");
    
    let mut имя = String::new();  // Создаём пустую строку
    
    io::stdin()                   // Получаем доступ к стандартному вводу
        .read_line(&mut имя)      // Читаем строку из ввода
        .expect("Не удалось прочитать строку");  // Обработка ошибки
    
    println!("Привет, {}!", имя.trim());  // trim() удаляет лишние пробелы и переносы строк
}

Давай разберём:

• use std::io; — говорим Rust, что будем использовать модуль ввода-вывода.
• String::new() — создаём новую пустую строку.
• io::stdin().read_line(&mut имя) — читаем строку из консоли и сохраняем в переменную имя.
• .expect(...) — если чтение не удалось, программа завершится с сообщением об ошибке.
• имя.trim() — обрезаем лишние пробелы и символы новой строки.

Попробуй запустить программу, ввести своё имя и увидеть приветствие!

Условные операторы: если... то...

В жизни мы постоянно принимаем решения: "Если пойдёт дождь, возьми зонт". В программировании то же самое — используются условные операторы if, else if и else.

fn main() {
    let возраст = 15;
    
    if возраст >= 18 {
        println!("Ты взрослый!");
    } else if возраст >= 13 {
        println!("Ты подросток!");
    } else {
        println!("Ты ребёнок!");
    }
}

Условие записывается в круглых скобках. Внутри условия можно использовать:

• == — равно
• != — не равно
• >, <, >=, <= — больше, меньше и т.д.
• && — логическое "И" (оба условия истинны)
• || — логическое "ИЛИ" (хотя бы одно истинно)

fn main() {
    let температура = 25;
    let солнечно = true;
    
    if температура > 20 && солнечно {
        println!("Отличная погода для прогулки!");
    } else if температура > 20 || солнечно {
        println!("Погода неплохая.");
    } else {
        println!("Лучше остаться дома.");
    }
}

Циклы: повторение — мать учения

Компьютеры отлично умеют повторять одно и то же много раз. Для этого служат циклы. В Rust есть три вида циклов: loop, while и for.

Бесконечный цикл loop

loop повторяется бесконечно, пока его не прервать командой break:

fn main() {
    let mut счётчик = 0;
    
    loop {
        println!("Счёт: {}", счётчик);
        счётчик += 1;
        
        if счётчик >= 5 {
            break;  // Выходим из цикла, когда счётчик станет 5
        }
    }
    
    println!("Цикл завершён!");
}

Цикл while: пока условие истинно

while выполняется, пока условие истинно:

fn main() {
    let mut число = 3;
    
    while число > 0 {
        println!("{}", число);
        число -= 1;
    }
    
    println!("Пуск!");
}

Цикл for: перебор элементов

for используется, когда нужно пройтись по диапазону чисел или элементам списка:

fn main() {
    // Диапазон от 1 до 5 (не включая 5)
    for i in 1..5 {
        println!("i = {}", i);
    }
    
    // Диапазон от 0 до 4 включительно
    for j in 0..=4 {
        println!("j = {}", j);
    }
}

Вывод программы:

i = 1
i = 2
i = 3
i = 4
j = 0
j = 1
j = 2
j = 3
j = 4

Обрати внимание: 1..5 — это диапазон от 1 до 4 (5 не входит), а 0..=4 — от 0 до 4 включительно.

Функции: создаём свои рецепты

Мы уже видели функцию main. Но можно создавать и свои функции! Это как написать собственный рецепт, который можно использовать много раз.

// Функция, которая приветствует пользователя
fn приветствие(имя: &str) {
    println!("Привет, {}! Добро пожаловать в мир Rust!", имя);
}

fn main() {
    приветствие("Алиса");
    приветствие("Боб");
    приветствие("Чарли");
}

Функции могут принимать параметры (данные на вход) и возвращать значение (результат):

// Функция складывает два числа и возвращает результат
fn сложить(a: i32, b: i32) -> i32 {
    a + b  // Последнее выражение возвращается (без точки с запятой!)
}

fn main() {
    let результат = сложить(5, 3);
    println!("5 + 3 = {}", результат);
    
    let ещё = сложить(10, 20);
    println!("10 + 20 = {}", ещё);
}

Обрати внимание: если функция возвращает значение, после параметров ставится стрелка -> и тип возвращаемого значения. Внутри функции последнее выражение (без точки с запятой) становится возвращаемым значением.

Что мы узнали сегодня?

Поздравляю! Ты сделал первый шаг в мир Rust. Сегодня мы разобрали:

• Что такое Rust и почему он крутой
• Как установить Rust и написать первую программу
• Переменные, типы данных и ключевое слово mut
• Комментарии и математические операции
• Ввод данных от пользователя
• Условные операторы if, else if, else
• Циклы loop, while, for
• Создание собственных функций

Это база, на которой строится всё остальное. В следующем уроке мы узнаем о строках, векторах и других полезных вещах. А пока — практикуйся!

Практические задания

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

Задание 1: Калькулятор возраста

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

Подсказка: let mut год_рождения = String::new(); — прочитай строку, затем преобразуй её в число с помощью .parse().

Задание 2: Таблица умножения

Напиши программу, которая выводит таблицу умножения для числа 7 (от 1 до 10). Используй цикл for. Вывод должен быть таким:

7 x 1 = 7
7 x 2 = 14
...
7 x 10 = 70

Задание 3: Угадай число

Напиши простую игру "Угадай число". Программа загадывает число от 1 до 10 (можно просто задать его в коде, например, let загаданное = 7;). Пользователь вводит своё предположение, а программа говорит, больше оно, меньше или угадано. Используй if и ввод данных.

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

Совет: Не бойся экспериментировать! Если программа не работает — читай сообщения об ошибках. Rust даёт очень понятные подсказки. Удачи!