პროგრამირების ენა Rust

Hello, World!

ახლა, როცა Rust-ი დააინსტალირეთ, დროა დაწეროთ თქვენი პირველი Rust პროგრამა. ახალი ენის სწავლისას ტრადიციად ითვლება პატარა პროგრამის დაწერა, რომელიც ეკრანზე ბეჭდავს ტექსტს Hello, world!, ასე რომ, ჩვენც იგივეს გავაკეთებთ!

შენიშვნა: ეს წიგნი გულისხმობს Command Line-ის ელემენტარულ ცოდნას. Rust-ს არ აქვს სპეციფიკური მოთხოვნები თქვენს რედაქტორზე, ინსტრუმენტებზე ან კოდის ადგილმდებარეობაზე, ასე რომ, თუ Command Line-ის ნაცვლად IDE-ს გამოყენება გირჩევნიათ, შეგიძლიათ გამოიყენოთ თქვენი საყვარელი IDE. ბევრ IDE-ს ახლა აქვს Rust-ის გარკვეული მხარდაჭერა; დეტალებისთვის შეამოწმეთ IDE-ს დოკუმენტაცია. Rust-ის გუნდი ორიენტირებულია IDE-ს შესანიშნავი მხარდაჭერის უზრუნველყოფაზე rust-analyzer-ის მეშვეობით. დამატებითი დეტალებისთვის იხილეთ დანართი D.

პროექტის დირექტორიის გამართვა

დაიწყებთ დირექტორიის შექმნით თქვენი Rust კოდის შესანახად. Rust-ისთვის მნიშვნელობა არ აქვს, სად ინახება კოდი, მაგრამ ამ წიგნში მოცემული სავარჯიშოებისა და პროექტებისთვის გირჩევთ შექმნათ projects დირექტორია თქვენს home დირექტორიაში და ყველა თქვენი პროექტი იქ შეინახოთ.

გახსენით ტერმინალი და შეიყვანეთ შემდეგი ბრძანებები projects დირექტორიის და მის შიგნით “Hello, world!” პროექტისთვის დირექტორიის შესაქმნელად.

Linux-ისთვის, macOS-ისთვის და Windows-ზე PowerShell-ისთვის შეიყვანეთ:

$ mkdir ~/projects
$ cd ~/projects
$ mkdir hello_world
$ cd hello_world

Windows CMD-ისთვის შეიყვანეთ:

> mkdir "%USERPROFILE%\projects"
> cd /d "%USERPROFILE%\projects"
> mkdir hello_world
> cd hello_world

Rust პროგრამის საფუძვლები

შემდეგ, შექმენით ახალი საწყისი ფაილი და დაარქვით main.rs. Rust-ის ფაილები ყოველთვის მთავრდება .rs გაფართოებით. თუ ფაილის სახელში ერთზე მეტ სიტყვას იყენებთ, მიღებული პრაქტიკაა მათ დასაცილებლად ქვედა ტირეს (underscore) გამოყენება. მაგალითად, გამოიყენეთ hello_world.rs და არა helloworld.rs.

ახლა გახსენით ახლად შექმნილი main.rs ფაილი და შეიყვანეთ კოდი 1-1 ლისტინგში.

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

შეინახეთ ფაილი და დაუბრუნდით ტერმინალის ფანჯარას ~/projects/hello_world დირექტორიაში. Linux-ზე ან macOS-ზე შეიყვანეთ შემდეგი ბრძანებები ფაილის დასაკომპილირებლად და გასაშვებად:

$ rustc main.rs
$ ./main
Hello, world!

Windows-ზე შეიყვანეთ ბრძანება .\main ./main-ის ნაცვლად:

> rustc main.rs
> .\main
Hello, world!

თქვენი ოპერაციული სისტემის მიუხედავად, ტერმინალში უნდა დაიბეჭდოს სტრიქონი Hello, world!. თუ ვერ ხედავთ ამ გამონატანს, დახმარების მისაღებად იხილეთ ინსტალაციის სექციის “პრობლემების აღმოფხვრის” ნაწილი.

თუ Hello, world! დაიბეჭდა, გილოცავთ! თქვენ ოფიციალურად დაწერეთ Rust პროგრამა. ეს თქვენ გხდით Rust-ის პროგრამისტად — კეთილი იყოს თქვენი მობრძანება!

Rust პროგრამის ანატომია

დეტალურად განვიხილოთ ეს “Hello, world!” პროგრამა. აი, თავსატეხის პირველი ნაწილი:

fn main() {

}

ეს სტრიქონები განსაზღვრავს ფუნქციას, სახელად main. main ფუნქცია განსაკუთრებულია: ის ყოველთვის არის პირველი კოდი, რომელიც იშვება Rust-ის თითოეულ შესრულებად (executable) პროგრამაში. აქ პირველი სტრიქონი აცხადებს main ფუნქციას, რომელსაც არ აქვს პარამეტრები და არაფერს აბრუნებს. პარამეტრები რომ ყოფილიყო, ისინი ფრჩხილების (()) შიგნით მოთავსდებოდა.

ფუნქციის ტანი მოქცეულია {} ფრჩხილებში. Rust-ი მოითხოვს ფიგურულ ფრჩხილებს ფუნქციის ყველა ტანის გარშემო. კარგი სტილია გამხსნელი ფიგურული ფრჩხილის იმავე სტრიქონზე განთავსება, სადაც ფუნქციის დეკლარაციაა, მათ შორის ერთი დაშორების (space) დამატებით.

შენიშვნა: თუ გსურთ დაიცვათ სტანდარტული სტილი Rust პროექტებში, შეგიძლიათ გამოიყენოთ ავტომატური ფორმატირების ინსტრუმენტი rustfmt, რათა დააფორმატოთ თქვენი კოდი გარკვეულ სტილში (მეტი rustfmt-ის შესახებ დანართ D-ში). Rust-ის გუნდმა ეს ინსტრუმენტი მოაყოლა Rust-ის სტანდარტულ დისტრიბუციას, ისევე როგორც rustc, ასე რომ ის უკვე დაინსტალირებული უნდა იყოს თქვენს კომპიუტერზე!

main ფუნქციის ტანი შეიცავს შემდეგ კოდს:

#![allow(unused)]
fn main() {
println!("Hello, world!");
}

ეს სტრიქონი ასრულებს მთელ სამუშაოს ამ პატარა პროგრამაში: ის ბეჭდავს ტექსტს ეკრანზე. აქ არის სამი მნიშვნელოვანი დეტალი, რომელსაც ყურადღება უნდა მიაქციოთ.

პირველი, println! იძახებს Rust-ის მაკროსს. ფუნქცია რომ გამოეძახა, ჩაწერილი იქნებოდა როგორც println (!-ის გარეშე). Rust-ის მაკროსები არის კოდის დაწერის გზა, რომელიც აგენერირებს კოდს Rust-ის სინტაქსის გასაფართოებლად, და მათ უფრო დეტალურად განვიხილავთ მე-20 თავში. ახლა მხოლოდ ის უნდა იცოდეთ, რომ ! სიმბოლოს გამოყენება ნიშნავს, რომ იძახებთ მაკროსს ჩვეულებრივი ფუნქციის ნაცვლად, და რომ მაკროსები ყოველთვის არ მიჰყვებიან იმავე წესებს, რასაც ფუნქციები.

მეორე, ხედავთ "Hello, world!" სტრიქონს (string). ჩვენ ამ სტრიქონს გადავცემთ არგუმენტად println!-ს, და ეს სტრიქონი იბეჭდება ეკრანზე.

მესამე, სტრიქონს ვასრულებთ წერტილ-მძიმით (;), რაც მიუთითებს, რომ ეს გამოსახულება დასრულდა და შემდეგი მზად არის დასაწყებად. Rust-ის კოდის სტრიქონების უმეტესობა წერტილ-მძიმით მთავრდება.

კომპილაცია და გაშვება

თქვენ ახლახან გაუშვით ახლად შექმნილი პროგრამა, ასე რომ განვიხილოთ პროცესის თითოეული ნაბიჯი.

Rust პროგრამის გაშვებამდე, ის უნდა დააკომპილიროთ Rust-ის კომპილატორის გამოყენებით rustc ბრძანების შეყვანით და მასზე თქვენი საწყისი ფაილის სახელის გადაცემით, ასე:

$ rustc main.rs

თუ გაქვთ C ან C++ გამოცდილება, შეამჩნევთ, რომ ეს წააგავს gcc-ს ან clang-ს. წარმატებული კომპილაციის შემდეგ, Rust-ი გამოიტანს ბინარულ შესრულებად (executable) ფაილს.

Linux-ზე, macOS-ზე და Windows-ზე PowerShell-ში შეგიძლიათ ნახოთ შესრულებადი ფაილი ტერმინალში ls ბრძანების შეყვანით:

$ ls
main  main.rs

Linux-სა და macOS-ზე დაინახავთ ორ ფაილს. Windows-ზე PowerShell-ით დაინახავთ იმავე სამ ფაილს, რასაც დაინახავდით CMD-ის გამოყენებით. Windows-ზე CMD-ით შეიყვანდით შემდეგს:

> dir /B %= the /B option says to only show the file names =%
main.exe
main.pdb
main.rs

ეს აჩვენებს საწყისი კოდის ფაილს .rs გაფართოებით, შესრულებად ფაილს (main.exe Windows-ზე, ხოლო main ყველა სხვა პლატფორმაზე) და Windows-ის გამოყენებისას დებაგინგის ინფორმაციის შემცველ ფაილს .pdb გაფართოებით. აქედან, თქვენ გაუშვებთ main ან main.exe ფაილს, ასე:

$ ./main # or .\main on Windows

თუ თქვენი main.rs არის თქვენი “Hello, world!” პროგრამა, ეს სტრიქონი ბეჭდავს Hello, world!-ს თქვენს ტერმინალში.

თუ უფრო იცნობთ დინამიკურ ენებს, როგორიცაა Ruby, Python ან JavaScript, შეიძლება არ იყოთ ჩვეული პროგრამის კომპილაციასა და გაშვებას, როგორც ცალკეულ ნაბიჯებს. Rust-ი არის წინასწარ კომპილირებადი (ahead-of-time compiled) ენა, რაც ნიშნავს, რომ შეგიძლიათ დააკომპილიროთ პროგრამა და მისცეთ შესრულებადი ფაილი სხვას, და მათ შეეძლებათ მისი გაშვება Rust-ის დაინსტალირების გარეშეც კი. თუ ვინმეს მისცემთ .rb, .py ან .js ფაილს, მათ დასჭირდებათ შესაბამისად Ruby, Python ან JavaScript იმპლემენტაციის დაინსტალირება. თუმცა ამ ენებში გჭირდებათ მხოლოდ ერთი ბრძანება თქვენი პროგრამის დასაკომპილირებლად და გასაშვებად. ენების დიზაინში ყველაფერი კომპრომისია.

უბრალოდ rustc-ით კომპილაცია კარგია მარტივი პროგრამებისთვის, მაგრამ თქვენი პროექტის ზრდასთან ერთად, მოგინდებათ ყველა ოფციის მართვა და თქვენი კოდის მარტივად გაზიარება. შემდეგში გაგაცნობთ Cargo ინსტრუმენტს, რომელიც დაგეხმარებათ რეალური Rust პროგრამების დაწერაში.