Agar siz Rust da yangi dastur yozishni boshlasangiz, eng avvalo quyidagi kodga ko’zingiz tushadi:

fn main() {
    println!("Hello, world!");
}

• “fn” bu funksiya
• “main” dasturni ishga tushiruvchi funksiya
• “()” bizning funksiyamizga hech qanday o’zgaruvchilar kiritilmaganini bildiradi

“{}” esa kod bloki deb ataladi va barcha yoziladigan kodlar aynan shu blokni ishida joylashadi.

“println!” esa macro deyiladi va u console ga chop etish uchun yordam beradi. “Macro” bu huddi siz uchun kod yozadigan funksiyaga o’xshaydi va oxirida “!” belgisi qo’yiladi. Macro to’g’risida yana gaplashamiz. Hozirchalik esa “!” macroni anglatishini bilib olsak bo’ldi.

“;” belgisi haqida bilib olish uchun esa biz qo’shimcha funksiya yaratamiz. Boshida, “main” funksiyamizning ichida 8 sonini chop etishga harakat qilib ko’ramiz.

fn main() {
    println!("Hello, world number {}!", 8);
}

“println!” ning ichida turgan {} larning vazifasi huddi band qilib qo’yilgan joylarga o’xshaydi va “,” verguldan keyingi o’zgaruvchilarni yozilgan tartibi bilan har bir band qilngan joyga qo’yib chiqadi.

Tepadagi dasturimiz: “Hello, world number 8!” chop etadi.

Biz istalgancha “{}” qo’yib joy band qilib o’zgaruvchi kiritishimiz mumkin.

fn main() {
    println!("Hello, worlds number {} and {}!", 8, 9);
}

Endi esa “Hello, worlds number 8 and 9!” ni chop etadi.

Endi yana bitta funksiya yaratamiz.

fn number() -> i32 {
    8
}

fn main() {
    println!("Hello, world number {}!", number());
}

Bu kod ham huddi tepadagi kabi “Hello, world number 8!” chop etadi. Lekin, Rust “number()” ni ko’rganida u funksiyaga duch keladi va bu funksiya:

• Xech qanday qiymat qabul qilmaydi, sababi () bilan yaratilgan
• i32 turidagi son qaytaradi. “->” funksiya qaytaradigan ma’lumot turini anglatadi.

Funksiyaning ichida 8 ni o’zi yozib qo’yilgan va hech qanday “;” lar siz. Sababi, agar siz biror qiymatdan so’ng “;” qo’ymasangiz bu huddi “return 8;” dagi kabi qaytarish kerak bo’lgan qiymat deb tushuniladi. Agar 8 dan keyin “;” qo’yilganida Rust hech narsa qaytarmaydi va qaytangi xatolik beradi. Negaki qaytishi kerak bo’lgan qiymat “i32” bo’lishi kerak, lekin funksiya “()” qaytaradi.

fn main() {
    println!("Hello, world number {}", number());
}

fn number() -> i32 {
    8;  // ⚠️
}

5 | fn number() -> i32 {
  |    ------      ^^^ expected `i32`, found `()`
  |    |
  |    implicitly returns `()` as its body has no tail or `return` expression
6 |     8;
  |      - help: consider removing this semicolon

Ushbu xatolik shuni anglatadiki, “number()” i32 qaytarishi kerak edi lekin biz “;” ni qo’yish qo’yganimiz uchun hech narsa qaytarilmayapti va kompilyator bizga “;” ni olib tashlashni maslahar beryapti.

Umuman olganda “return 8;” qilib ham yozsa bo’ladi, leki “;” olib tashlab qiymatning o’zini yozish ham odatiy hol.

Agar siz funksiyaga biror o’zgaruvchi bermoqchi bo’lsangiz, unda “()” ning ichiga ularni ma’lumot turi bilan birga kiritishingiz kerak.

fn multiply(number_one: i32, number_two: i32) { // Ikkita i32 qiymat funksiyaga beriladi. Biz ularni number_one va number_two deb ataymiz.
    let result = number_one * number_two;
    println!("{} times {} is {}", number_one, number_two, result);
}

fn main() {
    multiply(8, 9); // sonni shunchaki yozib kiritsak bo'ladi
    let some_number = 10; // yokida funksiyadan oldin 2 ta o'zgaruvchi e'lon qilsak ham bo'ladi
    let some_other_number = 2;
    multiply(some_number, some_other_number); // va funksiyaga kiritamiz
}

Biz funksiyadan i32 qiymat qaytarishini so’rasak ham bo’ladi.

fn multiply(number_one: i32, number_two: i32) -> i32 {
    let result = number_one * number_two;
    println!("{} times {} is {}", number_one, number_two, result);
    result // qaytarilayotgan i32 qiymat
}

fn main() {
    let multiply_result = multiply(8, 9); // multiply() funksiyasidan qiymatni chop etishga va multiply_result o'zgaruvchisiga yuborish uchun foydalandik
}

O’zgaruvchilarni e’lon qilish va kod bloklari

“let” dan foydalangan holda biz o’zgaruvchi yaratsak bo’ladi.

fn main() {
    let my_number = 8;
    println!("Hello, number {}", my_number);
}

O’zgaruvchilar {} blokni ichida boshlanadi va yakuniga yetadi. Quyidagi misolda “my_number” o’zgaruvchisi “println!” ishlatilishidan oldin yakuniga yetadi, sababi u o’zining bloki ichida yaratilib, nixoyasiga yetdi.

fn main() {
    {
        let my_number = 8; // my_number boshlandi
                           // my_number yakuniga yetdi
    }

    println!("Hello, number {}", my_number); // ⚠️ bu yerda my_number endi yo'q
                                             // println!() uni topa olmaydi.
}

Kod bloklaridan biz qiymat qaytarish uchun foydalansak bo’ladi.

fn main() {
    let my_number = {
    let second_number = 8;
        second_number + 9 // ";" ishlatilmaydi, shunda blok 8+9 ning qiymatini qaytaradi
                          // Huddi funksiyaga o'xshab ishlaydi.
    };

    println!("My number is: {}", my_number);
}

Agar blokning ichida “;” qo’shadigan bo’lsak, u hech narsa qaytarmaydi “()”:

fn main() {
    let my_number = {
    let second_number = 8; // second_number e'lon qilish,
        second_number + 9; // 9 ni qo'shish second_number ga
                           // lekin qiymat qaytarilmadi
                           // second_number shu yerdayoq tugaydi
    };

    println!("My number is: {:?}", my_number); // my_number is ()
}

Joyni band qilish uchun nega “{}” emas balki “{:?}” dan foydalanganimiz to’g’risida esa keyingi darsda gaplashamiz.