Rust е статично типизиран модерен език за програмиране, предназначен за производителност, надеждност и сигурност. Както в други статично типизирани езици, вие декларирате типовете данни на Rust по време на компилиране. Това улеснява улавянето на типови грешки, преди да стартирате кода си.
Rust предлага скаларни, съставни, референтни типове, структури, enum и низове. Неговото извеждане на типа осигурява функционалност за писане на кратък код, като същевременно поддържа безопасността на статично типизиран език.
Цели числа в Rust
Rust предоставя цели числа със знак и без знак, класифицирани въз основа на броя на битовете. Целочислените типове със знак са i8, i16, i32, и i64 представляващи съответно 8-битови, 16-битови, 32-битови и 64-битови цели числа със знак. Той също така поддържа неподписани цели числа u8, u16, u32, и u64, представляващи 8-битови, 16-битови, 32-битови и 64-битови цели числа без знак.
// цели числа със знак
позволявам a: i8 = -10;
позволявам b: i16 = -2048;
позволявам c: i32 = -2147483648;
позволявам d: i64 = -9223372036854775808;
// цели числа без знак
позволявам e: u8 = 255;
позволявам f: u16 = 65535;
позволявам g: u32 = 4294967295;
позволявам h: u64 = 18446744073709551615;
Rust използва i32 тип за целочислени литерали по подразбиране.
Типове с плаваща запетая на Rust
Rust предоставя f32 и f64 като типове с плаваща запетая, които представляват числа с плаваща запетая с единична и двойна точност. The f32 тип използва 32 бита за съхраняване на стойности и f64 използва 64 бита.
Числата с плаваща запетая в Rust следват стандарта IEEE 754 за аритметика с плаваща запетая.
позволявам а = 3.14159265358979323_f32;
позволявам b = 2.718281828459045235_f64;
Използване на Rust Booleans
Rust предоставя a bool тип за представяне вярно или невярно стойности. Булевите стойности често се използват в изрази за условен и контролен поток за вземане на програмни решения.
позволявам променлива_1: bool = вярно;
позволявам променлива_2: bool = невярно;
Можете да сравнявате булеви стойности с оператора за равенство, ==и операторът за неравенство, !=. Rust не дефинира операторите за сравнение, , <=, и >=, за bool стойности.
позволявам променлива_1: bool = вярно;
позволявам променлива_2: bool = невярно;
ако променлива_1 == променлива_2 {
println!("променлива_1 е равна на променлива_2");
} другоако променлива_1 != променлива_2 {
println!("променлива_1 не е равна на променлива_2");
}
Типът Char
Ръждата въглен тип представлява една скаларна стойност на Unicode, която може да представлява всеки знак в стандарта Unicode. Можете да посочите a въглен стойност с помощта на единични кавички.
// Деклариране на char стойност
позволявам c = "а";
The въглен type е полезен за работа с емотикони в Rust.
Кортежи в Rust
Структурата на кортежните данни ви позволява да групирате повече от една стойност в една съставна стойност. Тези стойности могат да имат един и същи тип или различни типове. Можете да декларирате кортежи, като ги напишете като разделен със запетаи списък със стойности, оградени със скоби.
Ето как можете да декларирате кортеж с 32-битови цели числа, низове и стойности float64.
позволявам tup: (i32, &str, f64) = (500, "Здравейте", 3.14);
Кортежите имат фиксирана дължина и можете да ги използвате, за да върнете множество стойности от функция или да предадете множество стойности на функции като един аргумент.
Можете да осъществите достъп до отделни елементи на кортеж, като го деструктурирате, като използвате съпоставяне на шаблони или директен достъп до отделни елементи, като използвате синтаксис точка (.) и индекс.
Ето как можете да получите достъп до отделни елементи на структура, като използвате съвпадение на шаблони:
позволявам my_tuple = (10, "Здравей свят!", невярно);позволявам (x, y, z) = my_tuple;
println!(„Първият елемент е: {}“, х);
println!(„Вторият елемент е: {}“, y);
println!(„Третият елемент е: {}“, z);
Ето как можете да получите достъп до отделни елементи, като използвате нотация с точки:
позволявам my_tuple = (10, "Здравей свят!", невярно);
println!("Theпървиелементе: {}", моят_кортеж.0);
println!("Theвтороелементе: {}", моят_кортеж.1);
println!("Theтретиелементе: {}", моят_кортеж.2);
Кортежите са много полезни при групиране на свързани данни в една стойност. Те също могат да подобрят четливостта на вашия код, ако ги използвате пестеливо.
Масиви в Rust
Масивът е колекция от елементи от един и същи тип с фиксирана дължина. Пишете масивите на Rust като списък със стойности в квадратни скоби, разделени със запетаи.
Ето как можете да декларирате масиви в Rust:
позволявам arr = [1, 2, 3, 4, 5];
Не можете да промените броя на елементите в масив, след като сте го декларирали, но можете да осъществявате достъп, да модифицирате и манипулирате отделни елементи от масив с помощта на индексиране.
позволявам mut my_array = [1, 2, 3, 4, 5];// Достъп до елементи
println!("Theпървиелементе: {}", моят_масив[0]);// Модифициране на елементи
my_array[0] = 100;
println!("Theпървиелементследмодификацияе: {}", моят_масив[0]);// Цикъл върху масив и манипулиране на елементи
заазв 0..my_array.len() {
my_array[i] *= 2;
}
// отпечатване на масива
println!(„Масивът след манипулация: {:?}“, my_array);
Rust Arrays са съхранявани на стека и имат непрекъснато разпределение на паметта, така че достъпът до елементи от масив е бърз и ефективен. Това прави масивите подходящи за ситуации, в които трябва да съхранявате и обработвате много елементи.
Работа с резени от ръжда
Срезът е структура от данни, която позволява препращане към непрекъсната последователност от елементи в колекция. Срезовете са представени от &[T] тип, където T е типът елементи, съхранявани в среза.
fn основен(){
// деклариране на масив
позволявам my_array = [1, 2, 3, 4, 5];// създаване на срез от масива
позволявам my_slice = &my_array[1..3];
// отпечатване на среза
println!(„Фрагмент: {:?}“, my_slice);
}
Забележете как синтаксисът на диапазона, .., извлича част от масив, като използва началния индекс и индекс, по-голям от края:
Срезовете са динамични, така че Rust може да определи тяхната дължина по време на изпълнение. Можете също така да предавате срезове като аргументи на функции, без да е необходимо разпределение на купчина.
Обикновено ще използвате срезове за операции с низове и за предаване на подмножества от данни към функции. Те са мощен и ефективен инструмент за управление на колекции в Rust, предоставяйки по-гъвкава алтернатива на масивите.
Можете да изграждате уеб приложения, задвижвани от WebAssembly, в Rust
Познаването на типовете данни е от основно значение за вашето пътуване с Rust, тъй като ще ги използвате за повечето операции, докато създавате приложения.
WebAssembly е двоичен формат на ниско ниво, който работи на съвременни уеб браузъри, с почти естествена производителност. Позволява ви да пишете код на много различни езици и да го транспилирате в WebAssembly.
WebAssembly се възприема чрез Rust. Има много рамки като Yew, Sycamore и Seed, които можете да използвате, за да изградите задвижвани от WebAssembly интерфейси с Rust.