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

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

Почему Rust?

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

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

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

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

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

Настройка среды разработки Rust

В рамках данной статьи мы будем рассматривать установку под ОС Linux. Пользователи Windows тоже могут развернуть необходимые компоненты, воспользовавшись инструкцией на сайте проекта https://www.rust‑lang.org/tools/install.

Скачаем и запустим установщик:

$ curl --proto '=https'  --tlsv1.2 -sSf -k https://sh.rustup.rs | sh

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

В процессе установки выбираем стандартную инсталляцию компонентов. После завершения можно проверить корректность, выполнив:

$ rustc –version

Для сборки пакетов в Rust используется менеджер Cargo. Он управляет зависимостями, создает ваш проект и предоставляет множество других полезных функций. Также Cargo предоставляет средства для управления зависимостями, сборки проекта, тестирования и публикации пакетов.

Теперь нам нужно создать новый проект Rust. Для этого в терминале перейдите в каталог, в котором вы хотите создать свой проект и выполните следующую команду:

$ cargo new my_project --bin

В результате Cargo создаст новый каталог с названием проекта и инициализирует новый пакет.

Далее, чтобы создать свой проект, перейдите в каталог project и запустите:

$ cargo build

Мы можем даже его запустить:

$ cargo run

Не написав ни строчки кода, мы тем не менее смогли убедиться в работоспособности нашего проекта, получив сообщение Hello world!. Это основные шаги для начала разработки Rust. Продолжая изучать Rust, вы узнаете больше о функциях Cargo, таких как управление зависимостями, выполнение тестов и публикация ваших пакетов в реестре crates.io.

Теперь, когда вы настроили Rust и Cargo, давайте рассмотрим некоторые фундаментальные концепции Rust.

Основные концепции Rust

Начнем с переменных и типов данных. В отличие от некоторых языков, в Rust используется статическая типизация, то есть при определении переменной необходимо указать тип данных (например, целые числа или строки). Это обеспечивает безопасность ввода и предотвращает ошибки во время компиляции.

let x: u32 = 62; // 32-разрядное целое число без знака
let y: f64 = 2,45; // 64-разрядное число с плавающей запятой.

Теперь поговорим о функциях. Функции — это изменяемые блоки кода, которые выполняют определенные задачи. Они могут принимать аргументы (входные данные) и возвращать значения (выходные данные).

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

Операторы потока управления, такие как if, else, loop и while, определяют порядок выполнения вашей программы на основе условий и повторений.

let x = 5;

if x > 0 {
    println!("Positive number");
} else {
    println!("Non-positive number");
}

Владение и заимствование

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

fn main() {
    let s = String::from("hello"); // s is the owner of the String
    take_ownership(s); // s is moved, no longer valid
    println!("{}", s); // Error: s is no longer valid
}

fn take_ownership(s: String) { // s becomes the owner

    println!("{}", s);

} // s is dropped at the end of the function

Давайте разберемся с пониманием права собственности в Rust. Один владелец за раз: В Rust у каждого фрагмента данных может быть только один владелец за раз. Это право собственности привязано к переменным.

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

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

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

Неизменяемые заимствования (&): Предоставляют доступ к заимствованным данным только для чтения. Вы не можете изменять заимствованные данные с помощью неизменяемого заимствования.

Изменяемые заимствования (&mut): Позволяют изменять заимствованные данные. Однако одновременно для части данных может существовать только одно изменяемое заимствование, что обеспечивает эксклюзивный доступ и предотвращает скачки данных (одновременные модификации).

Пример:

    let x = 5; // x owns the value 5

    let y = x;  // Ownership is moved to y, x is no longer usable  

    let mut numbers = vec![1, 2, 3]; // numbers owns the vector data

    let first = &numbers[0];        // Immutable borrow to the first element

    let mut last = &mut numbers[2];   // Mutable borrow to modify the last element

Переменные и типы данных

Rust предлагает различные встроенные типы данных, такие как целые числа (i32, u64), логические значения (bool), числа с плавающей запятой (f32, f64) и символы (char). При этом, как уже упоминалось, используется строгая система типов: переменные должны быть явно объявлены с указанием их типа данных, что обеспечивает безопасность типов и предотвращает ошибки во время компиляции. Например, вы не можете случайно присвоить строковое значение целочисленной переменной.

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

Создание простого приложения

Мы рассмотрели основные понятия языка Rust и теперь самое время написать первое приложение. Хотя оно будет не намного сложнее классического Hello world! В нем мы используем некоторые понятия Rust, о которых говорили ранее.

Для начала откройте свой терминал и создайте новый проект Rust, используя Cargo:

$ cargo new cli_app

Перейдите в каталог проекта:

$ cd cli_app

Откройте файл src/main.rs в выбранном вами редакторе кода и замените код по умолчанию следующим:

use std::env;

‍fn main() {
    let args: Vec = env::args().collect();

    if args.len() < 2 {
        println!("Please provide a name as an argument.");
        return;
    }

    let name = &args[1];
    println!("Hello, {}!", name);
}

Эта программа считывает аргументы командной строки в первой строке (let args…), проверяет был ли указан как минимум один аргумент, если нет то на выход, и выводит приветствие с первым аргументом в качестве имени.

$ cargo run -- Andrey

Заключение

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

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

Если после первого знакомства с Rust хочется двигаться дальше, стоит системно разобрать Cargo, базовые конструкции и владение/заимствование, а затем закрепить это на практике. На курсе «Rust Developer. Basic» проходят эту базу и учатся читать, собирать и писать приложения — от трейтов до многопоточности и async.

• 25 февраля, 20:00. «Знакомство с Rust. Первые шаги». Записаться

• 18 марта, 20:00. «Универсальный код в Rust: сила без потерь в скорости». Записаться

• 25 марта, 20:00. «Типы данных, переменные и функции в Rust». Записаться

Еще больше бесплатных уроков от преподавателей курсов можно посмотреть в календаре мероприятий.