Ma’lumot turini tahmin qilish shuni anglatadiki, agar siz kompilyatorga yaratayotgan o’zgaruvchingizni qanday ma’lumot turini saqlashini kiritib o’tmasangiz, kompilyatorning o’zi avtomatik tarzda tahmin qiladi. Kompilyator har doim ma’lumot turini bilishi kerak, lekin har doim ham siz uni kiritishingiz shart bo’lmaydi. Masalan, “let my_number =8” my_number o’zgaruvchisi i32 turdagi ma’lumotni o’z ichida saqlaydigan bo’ladi. Sababi, butun sonlarga(integers) kompilyator ,unga kiritilgan standard bo’yicha, i32 ni tanlaydi. Lekin siz “let my_number:u8 = 8” qilib kiritsangiz, unda my_number u8 ma’lumot turini o’z ichida saqlaydigan bo’ladi.

Ba’zida kompilyator tahmin qilishi kerak, ba’zida esa dasturchi kiritishi kerak.2 xil vaziyat sodir bo’lishi mumkin.

• Dasturchi shunchalik kompleks dastur yozayabdiki, kompilyator uning kiruvchi ma’lumot turini tahmin qila olmaydi
• Dasturchi shunchaki boshqa bir ma’lumot turini istaydi(misol uchun, i32 ni emas i128 dan foydalanishni istaysiz.

Ma’lumot turini kiritish uchun o’zgaruvchi nomidan so’ng “:” yozib ma’lumot turi kiritiladi

fn main() {
    let small_number: u8 = 10;
}

Sonlar uchun, biz shunchaki kiritilgan son uchun uning ketidan uning ma’lumot turiin ham kiriitb ketsa bo’ladi. Bunda hech qanday probel yozish shart emas, shunchaki son va undan keyin darxol uning ma’lumot turi kiritiladi bo’ldi.

fn main() {
    let small_number = 10u8; // 10u8 = 10 ::endi 10 u8 turdagi ma'lumot hisoblanadi
}

Agar o’qishni yengilashtirishni ko’zlagan bo’lsangiz unda tag chiziq “_” bilan ham kiritsangiz bo’ladi.

fn main() {
    let small_number = 10_u8; // Oldingi shaklga nisbatan buni o'qish osonroq
    let big_number = 100_000_000_i32; // 100 millionni _ bilan yozilganda o'qish osonroq
}

Tag chiziq “_” kiritilgan songa hech qanday tasir qilmaydi. Bu shunchaki kodni o’qishni yengillashtirish uchun bo’lgan usullardan bo’lgani uchun, istalgancha “_” qo’yilsa ham hech narsa qilmaydi.

fn main() {
    let number = 0________u8;
    let number2 = 1___6______2____4______i32;
    println!("{}, {}", number, number2);
}

Bu kodning natijasi 0 va 1624 ga teng bo’ladi.

O’nlik sonlar asosan o’zining kasr qismi bilan birga keladi. Misol uchun 5.5 o’nlik son va 6 ning o’zi esa butun son. O’nlik son deb 5.0 va 5. shakldagi sonlarni ham shu turga kiritamiz.

fn main() {
    let my_float = 5.; // Rust bu sonning o'nlik son ekanligini ko'radi.
}

Lekin Rust da o’nlik sonlarning ma’lumot turi “float” deb emas balki f32 va f64 deb nomlanadi. Huddi butun sonlarga o’xshab “f” dan keyin kelgan sonlar ular saqlaydigan bitlar sonini anglatadi. Agar dastruchi ma’lumot turini kiritib ketmasa, Rust o’nlik sonlar uchun avtomatik tarzda f64 ni tanlaydi.

Shuni esdan chiqarmaslik kerakki, faqatgina bir xil turdagi bo’lgan o’nlik sonlar ustidagina amallar bajarsa bo’ladi, ya’ni f32 va f64 ni biza xattoki qo’sha olmaymiz.

fn main() {
    let my_float: f64 = 5.0; // Bu f64
    let my_other_float: f32 = 8.5; // Bu f32

    let third_float = my_float + my_other_float; // ⚠️
}

Bu dasturni ishlatishga harakat qilsak quyidagi natijani olamiz:

error[E0308]: mismatched types
 --> src\main.rs:5:34
  |
5 |     let third_float = my_float + my_other_float;
  |                                  ^^^^^^^^^^^^^^ expected `f64`, found `f32`

Chiqarilgan xatolikdan “expected(type)” ya’ni kompilyator boshqa bir turdagi ma’lumot turini kutgan lekin “found(type)” boshqa bir ma’lumot turini topgan. Misol uchun kompilyator f32 kutgan bo’lishi mumkin lekin dasturchi tomonidan f64 kiritilgan bo’lsa unda kompilyator xatolik beradi va bu vaqtda dasturchining vazifasi, ma’lumot turlaridagi 2 xillikkga sabab bo’layotgan o’zgaruvchini topib uni tuzatish.

Oddiy sonlar bilan bu xatolikni tuzatish juda oson. Biz shuncahki bir turdan ikkinchi turgan konvertatsiya qilamiz. Misol uchun f32 ni f64 ga:

fn main() {
    let my_float: f64 = 5.0;
    let my_other_float: f32 = 8.5;

    let third_float = my_float + my_other_float as f64; // my_other_float as f64 = kiritilgan f32 ni f64 kabi ishlatishni Rust dan so'raladi
}

Yokida undanam osonroq yo’li, o’zgaruvchi kiritilayotganda dasturchi hech qanday ma’lumot turi kiritmaydi va Rust ni o’zi standard ma’lumot turlari bo’yicha ishlashni boshlaydi. Shunda hech qanday xatolik bo’lmaydi.

fn main() {
    let my_float = 5.0; // Rust f64 tanlaydi
    let my_other_float = 8.5; // Bu yerda ham f64 tanlanadi

    let third_float = my_float + my_other_float;
}

Ba’zida esa rust oldingi kiritilgan o’zgaruvchining ma’lumot turidan kelib chiqib ham keyingi o’zgaruvchiga ma’lumot turini tanlashi mumkin.

fn main() {
    let my_float: f32 = 5.0;
    let my_other_float = 8.5; // Odatda bu yerda standard bo'yicha f64 bo'lishi kerak,

    let third_float = my_float + my_other_float; // Lekin Rust biladiki siz 2 ta f32 ni qo'shmoqchisiz shuning uchun ham my_other_float uchun f32 ni tanlaydi.
}