Rust Basics Series #3: Типове данни в Rust

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

Съвсем естествено е сега да се покрият типовете данни.

Какво представляват типовете данни?

Променете реда на тези думи и ще получите своя отговор; “типове данни” -> “тип данни”.

Компютърът съхранява данни като 0пясък 1но за да го осмислим, когато четем, използваме тип данни, за да кажем какви са тези 0пясък 1означава.

Rust има два типа типове данни:

1. Скаларен тип данни: Типове, които съхраняват само една стойност.
2. Съставен тип данни: Типове, които съхраняват множество стойности, дори стойности от различни типове.

В тази статия ще разгледам скаларни типове данни. Ще премина през втората категория в следващата статия.

Следва кратък преглед на четирите основни категории типове данни Scalar в Rust:

• Цели числа: Съхранява цели числа. Има подтипове за всеки конкретен случай на употреба.
• Плувки: Съхранява числа с дробна стойност. Има два подтипа според размера.
• герои: Съхранява един знак от UTF-8 кодиране. (Да, можете да съхраните емоджи* в знак.)
• Булеви стойности: Магазини или a true или а false. (За разработчици, които не могат да се съгласят, ако 0 е true или ако 0 означава false.)

Цели числа

Цяло число в контекста на език за програмиране се отнася до цели числа. Целите числа в Rust са и двете Подписано или Неподписан. Целите числа без знак съхраняват само 0 и положителни числа, докато целите числа със знак могат да съхраняват отрицателни числа, 0 и положителни числа.

Следват наличните цели числа въз основа на знака и дължината:

Както можете да видите, Rust има цели числа със знак и без знак с дължина 8, 16, 32, 64 и дори 128!

Целите числа с *size варират в зависимост от архитектурата на компютъра. При 8-битовите микроконтролери е така *8на 32-битови стари компютри е така *32 и на съвременните 64-битови системи е така *64.

Използването на *size е да съхранява данни, които са свързани най-вече с паметта (която зависи от машината), като указатели, отмествания и т.н.

Rust ви позволява не само да съхранявате цели числа в тяхната десетична форма, но и в двоична, осмична и шестнадесетична форма.

За по-добра четливост можете да използвате долна черта _ като заместител на запетаите при писане/четене на големи числа.

fn main() {
    let bin_value = 0b100_0101; // use prefix '0b' for Binary representation
    let oct_value = 0o105; // use prefix '0o' for Octals
    let hex_value = 0x45; // use prefix '0x' for Hexadecimals
    let dec_value = 1_00_00_000; // same as writing 1 Crore (1,00,00,000)

    println!("bin_value: {bin_value}");
    println!("oct_value: {oct_value}");
    println!("hex_value: {hex_value}");
    println!("dec_value: {dec_value}");
}

Съхранил съм десетичното число 69 в двоична форма, осмична форма и шестнадесетична форма в променливите bin_value, oct_value и hex_value съответно. В променливата dec_value, съхранил съм числото 1 Crore (10 милиона) и имам запетаи с долна черта, според индийската система за номериране. За тези, които са по-запознати с международната система за номериране, можете да напишете това като 10_000_000.

При компилиране и изпълнение на този двоичен файл получавам следния изход:

bin_value: 69
oct_value: 69
hex_value: 69
dec_value: 10000000

Числа с плаваща запетая

Числата с плаваща запетая или по-известни като “float(s)” са тип данни, който съдържа числа, които имат дробна стойност (нещо след десетичната запетая).

За разлика от типа Integer в Rust, числата с плаваща запетая имат само два типа подмножества:

• f32: Тип с плаваща запетая с единична точност
• f64: Тип с плаваща запетая с двойна точност

Подобно на типа Integer в Rust, когато Rust изведе типа на променлива, която изглежда като float, на нея се присвоява f64 Тип. Това е така, защото на f64 има по-голяма точност от f32 тип и е почти толкова бърз, колкото f32 тип в повечето изчислителни операции. Моля, имайте предвид, че и двата типа данни с плаваща запетая (f32 и f64) са Подписано.

fn main() {
    let pi: f32 = 3.1400; // f32
    let golden_ratio = 1.610000; // f64
    let five = 5.00; // decimal point indicates that it must be inferred as a float
    let six: f64 = 6.; // even the though type is annotated, a decimal point is still
                       // **necessary**

    println!("pi: {pi}");
    println!("golden_ratio: {golden_ratio}");
    println!("five: {five}");
    println!("six: {six}");
}

Погледнете внимателно 5^th линия. Въпреки че съм анотирал типа за променливата sixаз трябва да използвате поне десетичната запетая. Ако имате нещо след десетичната запетая зависи от вас.

Резултатът от тази програма е доста предвидим… Или е така?

pi: 3.14
golden_ratio: 1.61
five: 5
six: 6

В горния изход може да сте забелязали, че докато показвате стойността, съхранена в променливите pi, golden_ratio и fiveнулите в края, които посочих по време на декларацията на променливата, липсват.

Докато тези нули не са отстранените се пропускат при извеждане на стойностите чрез println макрос. Така че не, Rust не е нарушил стойностите на вашата променлива.

герои

Можете да съхранявате един знак в променлива и типът е прост char. Подобно на традиционните езици за програмиране от 80-те, можете да съхранявате ASCII символ. Но Rust също разширява типа знак, за да съхранява валиден UTF-8 знак. Това означава, че можете да съхранявате емоджи в един знак 😉

fn main() {
    let a="a";
    let p: char="p"; // with explicit type annotation
    let crab = '🦀';

    println!("Oh look, {} {}! :{}", a, crab, p);
}

Както можете да видите, съхраних ASCII символите ‘a’ и ‘p’ вътре в променливите a и p. Също така съхранявам валиден символ UTF-8, емоджито на раци, в променливата crab. След това отпечатвам знаците, съхранени във всяка от тези променливи.

Следва изходът:

Oh look, a 🦀! :p

Булеви стойности

Булевият тип в Rust съхранява само една от двете възможни стойности: или true или false. Ако искате да анотирате типа, използвайте bool за да посочите вида.

fn main() {
    let val_t: bool = true;
    let val_f = false;

    println!("val_t: {val_t}");
    println!("val_f: {val_f}");
}

Горният код, когато се компилира и изпълни, води до следния изход:

val_t: true
val_f: false

Бонус: Изрично преобразуване на типове

В предишната статия за променливите в езика за програмиране Rust показах много проста програма за преобразуване на температурата. Там споменах, че Rust не позволява имплицитно преобразуване на типове.

Но това не означава, че Rust не позволява изрично типкаст или 😉

За да извършите изрично преобразуване на типове, as използва се ключова дума и е последвана от типа данни, към който трябва да се предаде стойността.

Следва демо програма:

fn main() {
    let a = 3 as f64; // f64
    let b = 3.14159265359 as i32; // i32

    println!("a: {a}");
    println!("b: {b}");
}

На ред 2, вместо да използвам „3.0“, следвам „3“ с as f64 за да обознача, че искам компилаторът да се справи с преобразуването на тип на ‘3’ (цяло число) в 64-битово плаващо число. Същото с 3-те^rd линия. Но тук кастингът на типове е такъв загуба. Това означава, че дробният елемент е напълно изчезнал. Вместо да съхранявате 3.14159265359тя се съхранява като просто 3.

Това може да се провери от изхода на програмата:

a: 3
b: 3

Заключение

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

Целите числа се използват за съхраняване на цели числа и имат няколко подтипа въз основа на това дали са със знак или без знак и дължината. Числата с плаваща запетая се използват за съхраняване на числа с някои дробни стойности и имат два подтипа въз основа на дължината. Знаковият тип данни се използва за съхраняване на един валиден UTF-8 кодиран знак. И накрая, булевите стойности се използват за съхраняване на a true или false стойност.

В следващата глава ще обсъдя съставни типове данни като масиви и кортежи. Останете на линия.