Такие читатели, как вы, помогают поддерживать MUO. Когда вы совершаете покупку по ссылкам на нашем сайте, мы можем получать партнерскую комиссию. Читать далее.

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

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

Целые числа в Rust

Rust предоставляет целочисленные типы со знаком и без знака, классифицированные на основе количества битов. Целочисленные типы со знаком i8, i16, i32, и i64 представляющие 8-битные, 16-битные, 32-битные и 64-битные целые числа со знаком соответственно. Он также поддерживает беззнаковые целые типы.

instagram viewer
U8, U16, U32, и u64, представляющий 8-битные, 16-битные, 32-битные и 64-битные целые числа без знака.

// целые числа со знаком
позволять а: i8 = -10;
позволять б: i16 = -2048;
позволять с: i32 = -2147483648;
позволять д: i64 = -9223372036854775808;
// целые числа без знака
позволять е: у8 = 255;
позволять ж: и16 = 65535;
позволять г: и32 = 4294967295;
позволять ч: и64 = 18446744073709551615;

Руст использует i32 тип для целочисленных литералов по умолчанию.

Типы с плавающей запятой Rust

Rust предоставляет ф32 и ф64 как типы с плавающей запятой, которые представляют числа с плавающей запятой одинарной и двойной точности. ф32 тип использует 32 бита для хранения значений, а ф64 тип использует 64 бита.

Числа с плавающей запятой в Rust соответствуют стандарту IEEE 754 для арифметики с плавающей запятой.

позволять а = 3.14159265358979323_f32;
позволять б = 2.718281828459045235_f64;

Использование логических выражений Rust

Rust предоставляет логический тип для представления истинный или ЛОЖЬ ценности. Логические значения часто используются в условных операторах и операторах потока управления для принятия программных решений.

позволять переменная_1: логическое значение = истинный;
позволять переменная_2: логическое значение = ЛОЖЬ;

Вы можете сравнивать логические значения с оператором равенства, ==, и оператор неравенства, !=. Rust не определяет операторы сравнения, , <=, и >=, для логический ценности.

позволять переменная_1: логическое значение = истинный;
позволять переменная_2: логическое значение = ЛОЖЬ;
если переменная_1 == переменная_2 {
 распечатать!("переменная_1 равна переменной_2");
} ещеесли переменная_1 != переменная_2 {
 распечатать!("переменная_1 не равна переменной_2");
}

Тип символа

Ржавчина уголь type представляет собой одно скалярное значение Unicode, которое может представлять любой символ в стандарт Юникод. Вы можете указать уголь значение с помощью одинарных кавычек.

// Объявление символьного значения
позволять с = а;

уголь type полезен для работы с эмодзи в Rust.

Кортежи в Rust

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

Вот как вы можете объявить кортеж с 32-битными целыми числами, строками и значениями float64.

позволять tup: (i32, &str, f64) = (500, "Привет", 3.14);

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

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

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

позволять my_tuple = (10, "Привет, мир!", ЛОЖЬ);
позволять (х, у, г) = мой_кортеж;
распечатать!("Первый элемент: {}", Икс);
распечатать!("Второй элемент: {}", у);
распечатать!("Третий элемент: {}", г);

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

позволять my_tuple = (10, "Привет, мир!", ЛОЖЬ);
печать!("первыйэлементявляется: {}", my_tuple.0);
печать!("второйэлементявляется: {}", my_tuple.1);
печать!("третийэлементявляется: {}", my_tuple.2);

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

Массивы в Rust

Массив — это набор элементов одного типа фиксированной длины. Вы пишете массивы Rust в виде списка значений в квадратных скобках, разделенных запятыми.

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

позволять прибытие = [1, 2, 3, 4, 5];

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

позволять мут my_array = [1, 2, 3, 4, 5];
// Доступ к элементам
печать!("первыйэлементявляется: {}", мой_массив[0]);


// Изменение элементов
мой_массив[0] = 100;
печать!("первыйэлементпослемодификацияявляется: {}", мой_массив[0]);


// Цикл по массиву и манипулирование элементами
дляяв 0..мой_массив.лен() {
 мой_массив[i] *= 2;
}
// печать массива
распечатать!("Массив после манипуляции: {:?}", мой_массив);

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

Работа с кусочками ржавчины

Срез — это структура данных, которая позволяет ссылаться на непрерывную последовательность элементов в коллекции. Срезы представлены &[Т] type, где T — тип элементов, хранящихся в срезе.

фн основной(){
// объявить массив
позволять мой_массив = [1, 2, 3, 4, 5];
// создаем срез из массива
позволять мой_срез = &мой_массив[1..3];
// распечатать срез
 распечатать!("Кусочек: {:?}", мой_срез);
}

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

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

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

Вы можете создавать интерфейсные веб-приложения на основе WebAssembly в Rust

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

WebAssembly — это низкоуровневый двоичный формат, который работает в современных веб-браузерах с производительностью, близкой к исходной. Он позволяет писать код на разных языках и транслировать его в WebAssembly.

WebAssembly набирает популярность благодаря Rust. Существует множество фреймворков, таких как Yew, Sycamore и Seed, которые вы можете использовать для создания интерфейсов на основе WebAssembly с помощью Rust.