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

Hello, Cargo

Cargo არის Rust-ის build სისტემა და პაკეტების მენეჯერი (package manager). Rustacean-ების უმეტესობა იყენებს ამ ინსტრუმენტს თავისი Rust პროექტების მართვისთვის, რადგან Cargo თქვენ ნაცვლად ასრულებს უამრავ ამოცანას, როგორიცაა თქვენი კოდის build-ი, იმ ბიბლიოთეკების ჩამოტვირთვა, რომლებზეც თქვენი კოდია დამოკიდებული, და ამ ბიბლიოთეკების build-ი. (ბიბლიოთეკებს, რომლებიც თქვენს კოდს სჭირდება, დამოკიდებულებებს (dependencies) ვუწოდებთ.)

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

რადგან Rust პროექტების აბსოლუტური უმრავლესობა იყენებს Cargo-ს, ამ წიგნის დანარჩენი ნაწილი გულისხმობს, რომ თქვენც Cargo-ს იყენებთ. Cargo Rust-თან ერთად მოჰყვება, თუ გამოიყენეთ ოფიციალური ინსტალატორები, რომლებიც განხილულია “ინსტალაციის” სექციაში. თუ Rust-ი სხვა საშუალებით დააინსტალირეთ, შეამოწმეთ, არის თუ არა Cargo დაინსტალირებული თქვენს ტერმინალში შემდეგის შეყვანით:

cargo --version

თუ ხედავთ ვერსიის ნომერს, ის უკვე გაქვთ! თუ ხედავთ შეცდომას, როგორიცაა command not found, იხილეთ თქვენი ინსტალაციის მეთოდის დოკუმენტაცია, რათა დაადგინოთ, როგორ დააინსტალიროთ Cargo ცალკე.

პროექტის შექმნა Cargo-ს მეშვეობით

შევქმნათ ახალი პროექტი Cargo-ს გამოყენებით და ვნახოთ, ეს ეტაპი განსხვავდება ჩვენი თავდაპირველი “Hello, world!” პროექტისგან. დაბრუნდით თქვენს projects დირექტორიაში (ან სადაც გადაწყვიტეთ თქვენი კოდის შენახვა). შემდეგ, ნებისმიერ ოპერაციულ სისტემაზე, გაუშვით შემდეგი:

cargo new hello_cargo
cd hello_cargo

პირველი ბრძანება ქმნის ახალ დირექტორიას და პროექტს სახელად hello_cargo. ჩვენს პროექტს დავარქვით hello_cargo, და Cargo ქმნის თავის ფაილებს იმავე სახელწოდების დირექტორიაში.

შედით hello_cargo დირექტორიაში და ჩამოთვალეთ ფაილები. დაინახავთ, რომ Cargo-მ ჩვენთვის დააგენერირა ორი ფაილი და ერთი დირექტორია: Cargo.toml ფაილი და src დირექტორია მის შიგნით არსებული main.rs ფაილით.

მან ასევე მოახდინა ახალი Git რეპოზიტორიის ინიციალიზაცია .gitignore ფაილთან ერთად. Git ფაილები არ დაგენერირდება, თუ cargo new-ს გაუშვებთ არსებულ Git რეპოზიტორიაში; ამ ქცევის შეცვლა შეგიძლიათ cargo new --vcs=git ბრძანების გამოყენებით.

შენიშვნა: Git არის ვერსიების კონტროლის გავრცელებული სისტემა (version control system). შეგიძლიათ შეცვალოთ cargo new, რათა გამოიყენოს ვერსიების კონტროლის განსხვავებული სისტემა ან საერთოდ არ გამოიყენოს ის --vcs დროშის გამოყენებით. ხელმისაწვდომი ოფციების სანახავად გაუშვით cargo new --help.

გახსენით Cargo.toml თქვენს რჩეულ ტექსტურ რედაქტორში. ის უნდა წააგავდეს 1-2 ლისტინგში ნაჩვენებ კოდს.

[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2024"

[dependencies]

ეს ფაილი არის TOML (Tom’s Obvious, Minimal Language) ფორმატში, რაც Cargo-ს კონფიგურაციის ფორმატია.

პირველი სტრიქონი, [package], არის სექციის სათაური, რომელიც მიუთითებს, რომ მომდევნო ინსტრუქციები აკონფიგურირებს პაკეტს. ამ ფაილში მეტი ინფორმაციის დამატებასთან ერთად, ჩვენ დავამატებთ სხვა სექციებსაც.

შემდეგი სამი სტრიქონი ადგენს კონფიგურაციის ინფორმაციას, რომელიც Cargo-ს სჭირდება თქვენი პროგრამის დასაკომპილირებლად: სახელი, ვერსია და Rust-ის გამოცემა (edition), რომელიც უნდა გამოიყენოს. edition გასაღების (key) შესახებ ვისაუბრებთ დანართ E-ში.

ბოლო სტრიქონი, [dependencies], არის იმ სექციის დასაწყისი, სადაც შეგიძლიათ ჩამოთვალოთ თქვენი პროექტის ნებისმიერი დამოკიდებულება. Rust-ში კოდის პაკეტებს მოიხსენიებენ როგორც crate-ებს. ამ პროექტისთვის სხვა crate-ები არ დაგვჭირდება, მაგრამ დაგვჭირდება მე-2 თავის პირველ პროექტში, ასე რომ დამოკიდებულებების ამ სექციას მაშინ გამოვიყენებთ.

ახლა გახსენით src/main.rs და გადახედეთ:

ფაილის სახელი: src/main.rs

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

Cargo-მ თქვენთვის დააგენერირა “Hello, world!” პროგრამა, ზუსტად ისეთივე, როგორიც 1-1 ლისტინგში დავწერეთ! ჯერჯერობით, განსხვავება ჩვენს პროექტსა და Cargo-ს მიერ დაგენერირებულ პროექტს შორის არის ის, რომ Cargo-მ კოდი განათავსა src დირექტორიაში, ხოლო ძირითად დირექტორიაში გვაქვს Cargo.toml კონფიგურაციის ფაილი.

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

თუ დაიწყეთ პროექტი, რომელიც არ იყენებს Cargo-ს, როგორც ეს გავაკეთეთ “Hello, world!” პროექტის შემთხვევაში, შეგიძლიათ ის გადაიყვანოთ პროექტში, რომელიც იყენებს Cargo-ს. გადაიტანეთ პროექტის კოდი src დირექტორიაში და შექმენით შესაბამისი Cargo.toml ფაილი. Cargo.toml ფაილის მიღების ერთ-ერთი მარტივი გზაა cargo init-ის გაშვება, რომელიც მას ავტომატურად შექმნის თქვენთვის.

Cargo პროექტის Build-ი და გაშვება

ახლა ვნახოთ, რა განსხვავდება, როდესაც “Hello, world!” პროგრამის build-ს ვაკეთებთ და ვუშვებთ Cargo-ს მეშვეობით! თქვენი hello_cargo დირექტორიიდან მოახდინეთ პროექტის build-ი შემდეგი ბრძანების შეყვანით:

$ cargo build
   Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs

ეს ბრძანება ქმნის შესრულებად ფაილს target/debug/hello_cargo-ში (ან target\debug\hello_cargo.exe-ში Windows-ზე) და არა თქვენს მიმდინარე დირექტორიაში. რადგან ნაგულისხმევი build-ი არის debug build-ი, Cargo ბინარულ ფაილს ათავსებს დირექტორიაში სახელად debug. შესრულებადი ფაილის გაშვება შეგიძლიათ ამ ბრძანებით:

$ ./target/debug/hello_cargo # or .\target\debug\hello_cargo.exe on Windows
Hello, world!

თუ ყველაფერი კარგად წავიდა, Hello, world! უნდა დაიბეჭდოს ტერმინალში. cargo build-ის პირველად გაშვება ასევე აიძულებს Cargo-ს შექმნას ახალი ფაილი უმაღლეს დონეზე: Cargo.lock. ეს ფაილი ადევნებს თვალყურს თქვენს პროექტში არსებული დამოკიდებულებების ზუსტ ვერსიებს. ამ პროექტს არ აქვს დამოკიდებულებები, ასე რომ ფაილი ოდნავ ცარიელია. ამ ფაილის ხელით შეცვლა არასოდეს დაგჭირდებათ; Cargo თავად მართავს მის შინაარსს.

ჩვენ ახლახან ავაგეთ პროექტი cargo build-ით და გავუშვით ის ./target/debug/hello_cargo-თი, მაგრამ ასევე შეგვიძლია გამოვიყენოთ cargo run კოდის დასაკომპილირებლად და შემდეგ მიღებული შესრულებადი ფაილის გასაშვებად ერთ ბრძანებაში:

$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
      Running `target/debug/hello_cargo`
Hello, world!

cargo run-ის გამოყენება უფრო მოსახერხებელია, ვიდრე იმის დამახსოვრება, რომ გაუშვათ cargo build და შემდეგ გამოიყენოთ ბინარული ფაილის სრული გზა, ასე რომ დეველოპერების უმეტესობა იყენებს cargo run-ს.

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

$ cargo run
   Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.33 secs
      Running `target/debug/hello_cargo`
Hello, world!

Cargo ასევე გვაწვდის ბრძანებას სახელად cargo check. ეს ბრძანება სწრაფად ამოწმებს თქვენს კოდს, რათა დარწმუნდეს, რომ ის კომპილირდება, მაგრამ არ აწარმოებს შესრულებად ფაილს:

$ cargo check
   Checking hello_cargo v0.1.0 (file:///projects/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.32 secs

რატომ არ უნდა გინდოდეთ შესრულებადი ფაილი? ხშირად cargo check ბევრად სწრაფია, ვიდრე cargo build, რადგან ის ტოვებს შესრულებადი ფაილის შექმნის ნაბიჯს. თუ კოდის წერისას მუდმივად ამოწმებთ თქვენს ნამუშევარს, cargo check-ის გამოყენება დააჩქარებს პროცესს იმის გასაგებად, კომპილირდება თუ არა თქვენი პროექტი კვლავ! ამდენად, ბევრი Rustacean პერიოდულად აშვებს cargo check-ს პროგრამის წერისას, რათა დარწმუნდეს, რომ ის კომპილირდება. შემდეგ კი უშვებენ cargo build-ს, როცა მზად არიან შესრულებადი ფაილის გამოსაყენებლად.

შევაჯამოთ ის, რაც აქამდე ვისწავლეთ Cargo-ს შესახებ:

• შეგვიძლია შევქმნათ პროექტი cargo new-ს გამოყენებით.
• შეგვიძლია ავაგოთ (build) პროექტი cargo build-ის გამოყენებით.
• შეგვიძლია ავაგოთ და გავუშვათ პროექტი ერთ ნაბიჯში cargo run-ის გამოყენებით.
• შეგვიძლია ავაგოთ პროექტი ბინარული ფაილის შექმნის გარეშე შეცდომების შემოწმებისთვის cargo check-ის გამოყენებით.
• იმის ნაცვლად, რომ build-ის შედეგი შეინახოს იმავე დირექტორიაში, სადაც ჩვენი კოდია, Cargo მას ინახავს target/debug დირექტორიაში.

Cargo-ს გამოყენების დამატებითი უპირატესობა ის არის, რომ ბრძანებები იგივეა, მიუხედავად იმისა, თუ რომელ ოპერაციულ სისტემაზე მუშაობთ. ასე რომ, ამ ეტაპზე, ჩვენ აღარ მოგაწვდით სპეციფიკურ ინსტრუქციებს Linux-ისა და macOS-ისთვის Windows-ის წინააღმდეგ.

Build-ი Release-ისთვის

როდესაც თქვენი პროექტი საბოლოოდ მზად იქნება გამოშვებისთვის (release), შეგიძლიათ გამოიყენოთ cargo build --release, რათა დააკომპილიროთ ის ოპტიმიზაციებით. ეს ბრძანება შექმნის შესრულებად ფაილს target/release-ში target/debug-ის ნაცვლად. ოპტიმიზაციები აიძულებს თქვენს Rust კოდს უფრო სწრაფად იმუშაოს, თუმცა მათ ჩართვას სჭირდება მეტი დრო პროგრამის დასაკომპილირებლად. სწორედ ამიტომ არსებობს ორი განსხვავებული პროფილი: ერთი დეველოპმენტისთვის, როდესაც გსურთ სწრაფად და ხშირად ხელახლა აგება, ხოლო მეორე საბოლოო პროგრამის ასაგებად, რომელსაც მომხმარებელს მისცემთ, რომელიც ხელახლა არ აიგება განმეორებით და იმოქმედებს რაც შეიძლება სწრაფად. თუ ზომავთ თქვენი კოდის შესრულების დროს (benchmarking), აუცილებლად გაუშვით cargo build --release და გაზომეთ target/release-ში არსებული შესრულებადი ფაილით.

Cargo-ს სტანდარტების (Conventions) გამოყენება

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

მიუხედავად იმისა, რომ hello_cargo პროექტი მარტივია, ის ახლა იყენებს იმ რეალური ინსტრუმენტების დიდ ნაწილს, რომლებსაც გამოიყენებთ თქვენი Rust კარიერის დანარჩენ ნაწილში. ფაქტობრივად, ნებისმიერ არსებულ პროექტზე სამუშაოდ, შეგიძლიათ გამოიყენოთ შემდეგი ბრძანებები კოდის Git-ით ჩამოსატვირთად (checkout), იმ პროექტის დირექტორიაში გადასასვლელად და ასაგებად (build):

git clone example.org/someproject
cd someproject
cargo build

Cargo-ს შესახებ დამატებითი ინფორმაციისთვის იხილეთ მისი დოკუმენტაცია.

შეჯამება

თქვენ უკვე შესანიშნავი დასაწყისი გაქვთ Rust-ის მოგზაურობაში! ამ თავში ისწავლეთ როგორ:

• დააინსტალიროთ Rust-ის უახლესი სტაბილური ვერსია rustup-ის გამოყენებით.
• განაახლოთ Rust-ის უფრო ახალ ვერსიაზე.
• გახსნათ ლოკალურად დაინსტალირებული დოკუმენტაცია.
• დაწეროთ და გაუშვათ “Hello, world!” პროგრამა უშუალოდ rustc-ს გამოყენებით.
• შექმნათ და გაუშვათ ახალი პროექტი Cargo-ს სტანდარტების (conventions) გამოყენებით.

ეს შესანიშნავი დროა უფრო საგრძნობი პროგრამის ასაგებად, რათა შეეჩვიოთ Rust კოდის წაკითხვასა და დაწერას. ასე რომ, მე-2 თავში ჩვენ ავაგებთ რიცხვის გამოცნობის თამაშის პროგრამას. თუ გირჩევნიათ დაიწყოთ იმის სწავლით, თუ როგორ მუშაობს პროგრამირების ზოგადი კონცეფციები Rust-ში, იხილეთ მე-3 თავი და შემდეგ დაუბრუნდით მე-2 თავს.