Все, что вам нужно знать, чтобы начать писать на Rust

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

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

Начало работы с Rust

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

После того, как вы установили Rust, вы можете начать писать программы в файлах Rust с

.rs расширение. Rust универсален и прост в освоении. Вы найдете это простым, если у вас есть предыдущий опыт программирования.

Переменные и константы в Rust

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

Вот как вы можете объявить переменные в Rust:

позволять а: Нить;
позволять б: i32;
позволять с: () = ();

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

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

фносновной(){
позволять возраст: Нить = Нить::от("пять лет");
позволять возраст = 5; // эквивалентно let age: i32 = 5;
распечатать!("{}", возраст);
}

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

Вам не нужно указывать тип данных переменной при ее объявлении. Компилятор Rust выводит тип из типа данных значения во время компиляции.

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

константа возраст: &ул = "пять лет";

Вы не можете изменить значение переменной, объявленной как константа.

Rust предоставляет функциональность для однострочных и блочных комментариев. Вы можете использовать двойную косую черту (//) для однострочных комментариев:

фносновной() {
// Это строчный комментарий
позволять х = 5; // Этот комментарий объясняет назначение переменной `x`
}

Для многострочных комментариев (блочных комментариев) используйте косую черту, за которой следует звездочка (/*) и закройте блок звездочкой, за которой следует косая черта (*/):

фносновной() {
/*
 Это блочный комментарий, занимающий несколько строк.
 Он часто используется для описания более крупного блока кода.
 */
позволять х = 5;
}

Ваши комментарии должны быть краткими и прямыми.

Массивы в Rust

Массивы представляют собой набор фиксированного размера элементов одного типа данных. Rust по умолчанию размещает массивы в стеке.

Вот как вы можете объявлять массивы в Rust:

фносновной() {
позволять числа = [1, 2, 3, 4, 5];
}

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

фносновной() {
позволять числа = [1, 2, 3, 4, 5];
позволять х = числа [3];
распечатать!("{}", Икс)
}

основной функция печатает Икс переменная, которая обращается к четвертому элементу массива.

Векторы в Rust

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

Вот как вы можете объявить векторы в Rust:

фносновной() {
позволять мой_век: Век<i32> = век![1, 2, 3, 4, 5];
позволять х = мой_век[3];
распечатать!("{}", Икс)
}

my_vec вектор представляет собой вектор 32-битных целых чисел. Икс переменная обращается к четвертому элементу вектора, а основной функция выводит значение на консоль.

Условные операторы Rust

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

Вот если оператор, который выводит на консоль строку на основе равенства двух целых чисел.

фносновной() {
позволять а: i32 = 12;
если а == 12 {
распечатать!("равно двенадцати");
 }
}

основной функция печатает строку с распечатать! макрос, так как переменная равна 12.

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

фносновной() {
позволять а: i32 = 12;
если а == 123 {
распечатать!("равно двенадцати");
 } еще {
распечатать!("а не равно двенадцати");
 }
}

В этом примере еще Оператор выполняется, потому что значение a не равно 123.

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

фносновной() {
позволять возраст: i32 = 7;
соответствовать возраст {
1 => распечатать!("один"),
2 => распечатать!("два"),
3 => распечатать!("три"),
 _ => распечатать!("нуль"),
 }
}

основной функция соответствует возраст варьируется в зависимости от случаев в соответствовать оператор и выполняет выражение, соответствующее значению. Подчеркивание (_) — это оператор по умолчанию, который запускается, если есть совпадение со значением.

Циклы в Rust

Rust предоставляет циклы для повторяющихся задач. В Rust есть три основных типа циклов: петля, пока, и для петли.

петля ключевое слово создает бесконечный цикл, который выполняется до тех пор, пока не встретит ключевое слово break:

фносновной() {
петля {
распечатать!("повторно печатается, пока не встретится оператор break.");
перерыв;
 }
}

пока Цикл удобен, когда вы хотите повторить блок кода, пока условие оценивается как истинное:

фносновной() {
позволятьмут количество = 0;
пока количество < 5 {
распечатать!("Счетчик {}", считать);
 количество += 1;
 }
}

А для Цикл хорош для перебора набора элементов, например массива:

фносновной() {
позволять числа = [1, 2, 3, 4, 5];
для элемент в числа.iter () {
распечатать!("Текущий элемент {}", элемент);
 }
}

Этот для цикл повторяется через числа массив и выводит каждый элемент на консоль.

Объявление и вызов функций Rust

Использовать фн ключевое слово для объявить функцию Rust, за которым следует имя функции, список параметров и тип возвращаемого значения (если есть).

Вот как вы можете объявить функцию с параметрами и типом возвращаемого значения:

фндобавлять(а: i32, б: i32) -> i32 {
возвращаться а + б;
}

добавлять Функция принимает два 32-битных целых числа и возвращает 32-битное целое число, сумму двух параметров.

Чтобы вызвать функцию из другого места кода, просто укажите имя и аргументы (если есть):

фносновной() {
позволять результат = добавить(2, 3);
распечатать!("2 + 3 = {}", результат);
}

результат переменная содержит результат вызова добавлять функция. основной функция выводит результат на консоль с помощью распечатать! макрос.

Структуры в Rust

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

Вот как вы можете объявить структуру:

структураЧеловек {
 имя: Нить,
 возраст: U32,
 is_male: логический,
}

Человек Структура имеет три поля: строку, 32-разрядное целое число без знака и логическое значение.

После определения структуры вы можете создавать ее экземпляры в других частях вашей программы:

фносновной() {
позволять человек1 = человек {
 имя: Нить::от("Кэндис Флинн"),
 возраст: 16,
 is_male: ЛОЖЬ,
 };
}

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

Вы можете реализовать концепции ООП в Rust

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

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