Rust turli hil ma’lumotlar turlari bilan ishlash imkonini beradi. Misol uchun raqamlar, belgilar va hokazo. Ba’zilari juda oson bo’lsa, ba’zilari esa sal murakkabroq va siz xattoki o’zingizning ma’lumot turini ham yaratsangiz bo’ladi.

Sodda ma’lumot turlari

Rustda oddiy ma’lumot turlari hisoblanadigan turlar ham mavjud va ular “primitive data types” deb ham ataladi. Boshlanishiga biz butun son(integer) va belgilar(characters) dan boshlaymiz. Butun son(integer) lar bu asosan kasr qismi mavjud bo’lmagan sonlardir va ular odatda 2 turga bo’linadi.

• Belgili butun sonlar (signed integers)
• Belgisiz butun sonlar (unsigned integers)

Belgili butun sonlar bu o’zi bilan + va – ishoralarini ifodalaydigan sonlardir. Shuning uchun ham belgili butun sonlar musbat va manfiy bo’lishi mumkin, masalan -8 yokida +8. Lekin belgisiz butun sonlar esa faqatgina musbat bo’ladi oladi, sababi ularda belgini ifoda etish xususiyati yo’q.

Belgili butun sonlarga quyidagilar kiradi:

• i8, i16, i32, i64, i128 va isize

Belgisiz butun sonlar esa:

• u8, u16, u32, u64, u128 va usize

“i” yokida “u” dan keyin keladigan sonlar asosan bu ma’lumot turining ifoda eta oladigan maksimum bit ini anglatadi, shuning uchun ham, kattaroq son bu kattaroq bit ni ifodalaydi degani hisoblanadi. 8 bit = 1 bayt. Shunda i8 1 baytni o’z ichiga olsa i64 esa 8 baytni o’z ichiga oladi.

Raqamlar turlariga qarab ularning maksimal ifoda etadigan qiymatini bilib olish mumkin. Misol uchun, u8 maksimal 255 gacha bo’lgan sonlarni ifoda etadi, lekin u16 esa 65535 va u128 esa 340282366920938463463374607431768211455.340282366920938463463374607431768211455

Xo’sh “isize” va “usize” nimani anglatadi ? Bu sizning kompyuteringizdagi bitlar turini anglatadi.(Kompyuterdagi bitlar turi bu kompyuter arxitekturasini deb ham ataladi). “isize” va “usize 32 bitlik kompyuterda i32 va u32 bo’lsa, 64 bitlik kompyuterda esa bular i64 va u64 bo’ladi.

Har bir bitning foydalanish sabablari turlicha bo’lishi mumkin. Misol uchun eng asosiy sabablardan biri bu kompyuterning ishlash samaradorligi. Kichikroq bitlarni hisoblash tezroq amalga oshiriladi. Misol uchun -10 ni i8 da ifodalasak 11110110 bo’lsa, i128 da ifodalanganida bu son 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110110

Belgilar Rust da “char” bilan ifodalanadi. Har bir “char”ning o’ziga belgilangan raqami bor. A harfining xos raqami 65 bo’lsa, 友 belgisiing raqami esa 21451. Bu raqamlar ro’yxati “Unicode” deb ataladi. Unicode asosan ko’p ishlatiladigan belgilar uchun kichikroq raqamlardan foydalanadi ,A dan Z gacha yokida 0 dan 9 gacha bo’lgan belgilar.

fn main() {
    let first_letter = 'A';
    let space = ' '; // Qo'shtirnoq ichidagi bo'sh probel ham belgi hisoblanadi
    let other_language_char = 'Ꮔ'; // Unicode ning foydalanaridan biri bu boshqa tildagi belgilarni ham o'girib bera oladi
    let cat_face = '😺'; // Emojilar ham belgilar hisoblanadi.
}

Eng ko’p ishlatilinadigan belgilarning raqami 256 dan pastda bo’lgani uchun ham “u8” ma’lumot turiga mos keladi. Esda tutish kerakki, “u8” bu 0 dan 256 gacha bo’lgan barcha raqamlarni o’z ichiga oladi. Shuning uchun ham Rust ning “as” funksiyasidan foydalangan holda “u8” ni char ga aylantirishni xavfsiz amalga oshirsak bo’ladi.

Ma’lumot turlarini “as” funksiyasi bilan konvertatsiya qilish bu judaam qulay bo’lib Rustning qat’iy qoidalariga amal qilishda yordam beradi.Sababi Rust da har bir amaliyotni amalga oshirishdan oldin unga ma’lumot turini aniq aytish kerak bo’ladi, yokida ikkala son butun bo’lgan taqdirda ham ular bilan birga har qanday amaliyot bajarish imkonsiz bo’ladi tokid ikkala son ham bir xil ma’lumot turiga ega bo’lmaguncha. Misol uchun quyidagi kod xatolik chiqaradi

fn main() { 
    let my_number = 100; // Agar Rustda o'zgaruvchi e'lon qilinganda,
                         // undagi ma'lumot turi kiritilmasa
                         // chooses i32 for integers if you don't
                         // tell it to use a different type

    println!("{}", my_number as char); // 
}

Sababi esa quyidagicha:

error[E0604]: only `u8` can be cast as `char`, not `i32`
 --> src\main.rs:3:20
  |
3 |     println!("{}", my_number as char);
  |                    ^^^^^^^^^^^^^^^^^

Xatolikni to’g’irlash uchun shunchaki “as” funksiyasidan foydalanamiz. Biz “i32” ni “char” ga aylantira olmaymiz, lekin “i32” ni “i8” ga o’gira olamiz. Shundan so’ng “i8” ni qayta “char” ga aylantira olamiz. Vanixoyat bir qatorning o’zida biz oldin i32 ni i8 va so’ng “char” ga aylantiramiz va kodimiz xatosiz ishlay boshlaydi.

fn main() {
    let my_number = 100;
    println!("{}", my_number as u8 as char);
}

Natija esa “d” harfi bo’ladi sababi “d” ning belgidagi xos raqami 100 ga to’g’ri keladi.

Tepada keltirib o’tilgan “as” bilan qayta-qayta konvertatsiyalashni oldini olish uchun, biz shunchaki o’zgaruvchini e’lon qilayotganda uning turini kiritib o’tishlik kifoya qiladi.

fn main() {
    let my_number: u8 = 100; //  o'zgaruvchimizning turini kiritib o'tamiz
    println!("{}", my_number as char);
}

Rustdagi turli ma’lumot turlarining yana bir vazifalaridan bir bu “usize” dir. Bu turdan Rustda asosan indekslash uchun foydalaniladi. “usize” ning indekslash uchun eng mos turligining sababi:

• Indeks manfiy son bo’la olmaydi shuning uchun ham belgisiz sonlar juda qulaydir
• U katta bo’lishi ham kerak, sababi ba’zida biz juda ko’p narsalarni indekslashimiz kerak bo’ladi
• U “u64” ham bo’la olmaydi, negaki 32-bit arxitekturali kompyuterlar “u64” dan foydalana olishmaydi.

Shuning uchun ham Rust kompyuter iloji boricha maksimal raqamini ishlata olishi uchun “usize” dan foydalanadi.

Endi “char” bilan yaqinroq tanishamiz. Tepada keltirib o’tilgan koddan ko’rinadigi “char” har doim 1 dona belgi ko’rinishida keladi va ” ” ning o’rninga ‘ ‘ dan foydalaniladi.

Har bit “char” asosan 4 byte xotira ishlatadi, sababi 4 bayt bilan istalgan turdagi belgini ifodalash mumkin.

• Oddiy belgilar zaxiradagi 4 baytdan faqatgina 1 bayt nigina ishlatishadi. a b 1 2 + – = $
• Boshqa tildagi maxsus harflar esa 2 baytdan foydalanadi: ä ö ü ß è é à ñ
• Koreys,Xitoy va Yapon harflari esa 3 yoki 4 bayt talab qiladi: 国 안 녕

Qachonki “string” ya’ni belgilar yig’indisi orqali so’z yokida matnlar tuzadigan bo’lsal, Rust iloji boricha har bir belgi uchun eng kam xotira ishlatishga harakat qiladi.

Natijani ko’rish uchun .len() dan foydalansak bo’ladi:

fn main() {
    println!("Size of a char: {}", std::mem::size_of::<char>()); // 4 byte
    println!("Size of string containing 'a': {}", "a".len()); // .len() umumiy matn uzunligini baytda ko'rsatadi
    println!("Size of string containing 'ß': {}", "ß".len());
    println!("Size of string containing '国': {}", "国".len());
    println!("Size of string containing '𓅱': {}", "𓅱".len());
}

Natijasi esa quyidagicha:

Size of a char: 4
Size of string containing 'a': 1
Size of string containing 'ß': 2
Size of string containing '国': 3
Size of string containing '𓅱': 4

Ko’rishimiz mumkinki, “a” harfi 1 bayt, Nemis “ß” si 2 bayt, Yapon harfi 3 bayt va Misr belgisi esa 4 bayt xotira egallayapti

fn main() {
    let slice = "Hello!";
    println!("Slice is {} bytes.", slice.len());
    let slice2 = "안녕!"; // Koreyscha salom
    println!("Slice2 is {} bytes.", slice2.len());
}

Natija:

Slice is 6 bytes.
Slice2 is 7 bytes.

“slice” o’zgaruvchidagi qiymatning olayotgan xotirasi 6 byte va 6 belgidan iborat.
Lekin, “slice2” dagi matn esa uzunligi 3 ta belgi bo’lishiga qaramasdan, xotiradan oladigan joyi esa 7 bayt.

Agar, .len() matnni bayt ko’rinishidagi o’lchamini beradigan bo’lsa, belgilar sanog’ini qanday topishimiz mumkin deb o’ylashingiz mumkin. Umuman olganda buni .char().count() funksiyasi orqali amalga oshirsak bo’ladi. Kiritilgan mattni belgilarga aajratadi va keyin uning sanog’ini qaytaradi.

fn main() {
    let slice = "Hello!";
    println!("Slice is {} bytes and also {} characters.", slice.len(), slice.chars().count());
    let slice2 = "안녕!";
    println!("Slice2 is {} bytes but only {} characters.", slice2.len(), slice2.chars().count());
}

Ekrandagi natija:

Slice is 6 bytes and also 6 characters.
Slice2 is 7 bytes but only 3 characters.