Основы Rust: синтаксис и структуры данных

Привет, Хабр!

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

В этой статье рассмотрим основы Rust.

Настройка окружения

На сайте раста есть инструкции по установке Rust на любую ОС. Процесс установки прост и интуитивно понятен и ее может выполнить любой школьник.

После установки Rust и Cargo, убедимся, что они работают правильно. Открываем терминал и юзаем команду:

rustc --version

Команда должна вернуть текущую версию компилятора Rust, установленную на ПК.

Проверяем версию Cargo:

cargo --version

Если обе команды успешно возвращают версии инструментов, то все ок.

Создание первой программы на Rust

Для создания нового проекта на Rust, можно воспользоваться командой cargo new hello_rust. Cargo - это универсальный инструмент для управления зависимостями в расте. Команда создаст каталог с именем hello_rust, который будет содержать структуру проекта Rust. Внутри этого каталога лежит файл main.rs, в нем напишем код:

По классике поздорваемся с миром:

fn main() {
    println!("Hello, World!");
}

После этого можно перейти в терминал, перейти в каталог проекта и выполнить команду cargo run

Синтаксис Rust

Переменные и их мутабельность

Одна из особенностей Rust - это строгая система типов, которая помогает избежать множества ошибок на этапе компиляции:

let x = 42; // Неизменяемая переменная
let mut y = 24; // Изменяемая переменная

let используется для объявления переменных. Первая переменная x неизменяема, что означает, что после присвоения значения 42, она не может быть изменена. Вторая переменная y объявлена как изменяемая, поэтому можно изменять ее значение.

Операторы и контроль потока

Rust поддерживает все базовые операторы, включая арифметические, логические и сравнительные операторы:

fn ariph() {
    let a = 10;
    let b = 3;
    
    let sum = a + b; // Сложение
    let difference = a - b; // Вычитание
    let product = a * b; // Умножение
    let quotient = a / b; // Деление
    let remainder = a % b; // Остаток от деления

fn logic() {
    let is_sunny = true;
    let is_warm = false;
    
    let is_good_weather = is_sunny && is_warm; // Логическое И
    let is_raining = !is_sunny; // Логическое НЕ
}

fn sravn() {
    let x = 5;
    let y = 10;
    
    let is_equal = x == y; // Равно
    let is_not_equal = x != y; // Не равно
    let is_greater = x > y; // Больше
    let is_less = x < y; // Меньше
    let is_greater_or_equal = x >= y; // Больше или равно
    let is_less_or_equal = x <= y; // Меньше или равно
}

Условные операторы: if, else if, else

fn main() {
    let age = 25;

    if age < 18 {
        println!("Вы несовершеннолетний");
    } else if age >= 18 && age < 65 {
        println!("Вы взрослый");
    } else {
        println!("Вы пенсионер");
    }
}

Циклы: for, while

Циклы позволяют нам выполнять определенные блоки кода несколько раз. В Rust есть два основных типа циклов: for и while:

fn main() {
    // Цикл for
    for i in 1..=5 {
        println!("Итерация {}", i);
    }

    // Цикл while
    let mut counter = 0;
    while counter < 3 {
        println!("Повторение {}", counter);
        counter += 1;
    }
}

В for используем диапазон чисел 1..=5 для выполнения блока кода пять раз. В случае цикла while, выполняем блок кода, пока значение переменной counter меньше 3, и увеличиваем его после каждой итерации.

Match-выражения

Match-выражения позволяют сравнивать значение с несколькими возможными вариантами и выполнять соответствующий блок кода:

fn main() {
    let language = "Rust";

    match language {
        "Rust" => println!("Вы выбрали Rust - отличный выбор!"),
        "Python" | "JavaScript" => println!("Тоже хорошие языки!"),
        _ => println!("Неизвестный язык программирования"),
    }
}

Если значение соответствует "Rust", выводим сообщение о выборе Rust. Если оно соответствует "Python" или "JavaScript", выводим общее сообщение. В противном случае, используем _, чтобы обработать все остальные значения.

Объявление функций

fn main() {
    // Вызов функции
    greet("Alice");

    // Вызов функции с возвращаемым значением
    let result = add(3, 5);
    println!("Сумма: {}", result);
}

// Объявление функции без возвращаемого значения
fn greet(name: &str) {
    println!("Привет, {}!", name);
}

// Объявление функции с возвращаемым значением
fn add(a: i32, b: i32) -> i32 {
    a + b
}

Параметры функций

fn main() {
    let a = 5;
    let b = 3;
    let sum = add(a, b);
    println!("Сумма: {}", sum);
}

fn add(x: i32, y: i32) -> i32 {
    x + y
}

add принимает два параметра x и y, их значения передаются из функции main при вызове функции add.

Возвращаемые значения функций

Возвращаемый тип указывается после параметров функции и определяет тип данных, который функция вернет:

fn main() {
    let result = multiply(4, 6);
    println!("Произведение: {}", result);
}

fn multiply(a: i32, b: i32) -> i32 {
    a * b // Это выражение будет возвращено из функции
}

multiply возвращает произведение двух чисел типа i32.

Структуры данных

Целые числа

let integer: i32 = 42; // 32-битное целое число со знаком
let unsigned_integer: u64 = 100; // 64-битное целое число без знака

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

let float: f32 = 3.14159265359; // 32-битное число с плавающей точкой
let double: f64 = 2.71828182845; // 64-битное число с плавающей точкой (по умолчанию)

Булевы значения

let is_rust_cool: bool = true; // Логическое значение true
let is_open_source: bool = false; // Логическое значение false

Символы и строки

let char_type: char = 'A'; // Символ
let string_type: &str = "Hello, Rust!"; // Строка (неизменяемая)

Векторы

В Rust векторы можно создавать и изменять в размере по мере необходимости:

fn main() {
    // Создание вектора целых чисел
    let mut numbers: Vec<i32> = Vec::new();
    
    // Добавление элементов в вектор
    numbers.push(42);
    numbers.push(24);
    numbers.push(12);
    
    // Доступ к элементам вектора
    let first = numbers[0];
    
    // Итерация по вектору
    for num in &numbers {
        println!("Число: {}", num);
    }
    
    // Размер вектора
    let length = numbers.len();
    
    // Удаление элемента из вектора
    let removed = numbers.pop();
}

Создали пустой вектор numbers для хранения целых чисел, добавили элементы в него с помощью метода push, получили доступ к элементу по индексу и прошлись по всем элементам вектора.

Массивы

fn main() {
    // Создание массива строк
    let colors: [&str; 3] = ["Red", "Green", "Blue"];
    
    // Доступ к элементам массива
    let first_color = colors[0];
    
    // Итерация по массиву
    for color in &colors {
        println!("Цвет: {}", color);
    }
    
    // Размер массива (известен на этапе компиляции)
    let length = colors.len();
}

Создали массив colors, содержащий три строки. Массивы в Rust имеют фиксированный размер, который задается при объявлении.

Какой контейнер выбрать - вектор или массив? Выбор зависит от конкретной задачи. Если нужна динамичность и возможность изменять размер данных во времени, то векторы оч. хорошо подходят. Если же вы знаете точный размер данных заранее, то массивы более адекватным выбором.

Структуры

Структуры - это способ объединить несколько переменных разных типов в одну логическую единицу:

// Определение структуры Point
struct Point {
    x: f64,
    y: f64,
}

fn main() {
    // Создание экземпляра структуры Point
    let origin = Point { x: 0.0, y: 0.0 };
    
    // Доступ к полям структуры
    println!("Координаты точки: ({}, {})", origin.x, origin.y);
}

Определили структуру Point, содержащую два поля типа f64 - x и y. Затем создали экземпляр структуры origin и получили доступ к полям.

Перечисления

// Определение перечисления Animal
enum Animal {
    Dog,
    Cat,
    Bird,
}

fn main() {
    // Использование перечисления
    let pet = Animal::Dog;
    
    // Проверка значения перечисления
    match pet {
        Animal::Dog => println!("Это собачка!"),
        Animal::Cat => println!("Это котик!"),
        Animal::Bird => println!("Это птиц!"),
    }
}

Определили перечисление Animal, которое может принимать одно из трех значений. Затем создали переменную pet и с помощью match сравнили ее значение с вариантами перечисления.

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

---

Также в Rust реализовано хорошее и безопасное управление памятью, у меня есть статья на эту тему: как работает управление памятью в Rust без сборщика мусора.

В целом Rust очень даже хороший ЯП и набирает свою популярность.

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