زبان برنامه نویسی Rust

سلام کارگو!

کارگو ابزار ساخت و مدیر بسته Rust است. اکثر برنامه‌نویسان Rust از این ابزار برای مدیریت پروژه‌های Rust استفاده می‌کنند چرا که کارگو بسیاری از کار‌ها مثل ساخت (build) کد‌ها، دانلود کردن کتابخانه‌هایی که کد شما به آن نیاز دارد و ساخت آنها را انجام می‌دهد. (ما به کتابخانه‌هایی که کد شما به آن نیاز دارد پیشنیاز می‌گوییم.)

ساده‌ترین برنامه‌های Rust، مثل برنامه‌ای که نوشتیم پیشنیازی ندارند. پس اگر برنامه «Hello world» را با کارگو بسازیم، تنها از بخشی از کارگو که کد شما را می‌سازد (build) استفاده می‌شود. هرچه برنامه‌های پیچیده‌تر Rust بنویسید به آنها پیشنیاز اضافه خواهید کرد، و اگر پروژه‌ای را با کارگو شروع کنید، اضافه کردن پیشنیاز بسیار ساده‌تر است.

چون اکثر پروژه‌های Rust از کارگو استفاده می‌کنند، در ادامه این کتاب در نظر می‌گیریم که شما نیز از کارگو استفاده می‌کنید. با نصب Rust کارگو نیز نصب می‌شود؛ البته اگر از روش‌های نصب رسمی در بخش «نصب» استفاده کنید. اگر Rust را با روش دیگری نصب کرده‌اید، با وارد کردن دستور زیر در ترمینال کنترل کنید که آیا کارگو نصب شده است:

$ cargo --version

اگر یک شماره نسخه می‌بینید، شما آن را دارید! اگر یک خطا مثل command not found می‌بینید، به مستندات روش نصب خود مراجعه کرده و نحوه نصب کارگو بصورت جداگانه را مطالعه کنید.

ساخت یک پروژه با کارگو

بیایید یک پروژه جدید با کارگو بسازیم و تفاوت آنرا با برنامه «Hello world» سابق ببینیم. به دایرکتوری projects (یا هرجایی که کد‌های خود را نگه می‌دارید) برگردید. سپس در همه سیستم‌عامل‌ها دستورات زیر را وارد کنید:

$ cargo new hello_cargo
$ cd hello_cargo

دستور اول یک دایرکتوری جدید با عنوان hello_cargo می‌سازد. نام پروژه خود را hello_cargo گذاشته‌ایم، کارگو فایل‌های مربوط به آن را در یک دایرکتوری با همین اسم نگه می‌دارد.

داخل دایرکتوری hello_cargo بروید و محتویات آنرا نمایش دهید. می‌بینید که کارگو برای ما دو فایل و یک دایرکتوری ساخته است: یک فایل Cargo.toml و یک دایرکتوری src با یک فایل main.rs درون آن.

همچنین کارگو یک مخزن گیت با یک فایل .gitignore ساخته است. اگر از قبل در پوشه مربوطه یک مخزن گیت وجود داشته باشد فایل های گیت با اجرای cargo new ساخته نخواهند شد. می‌توانید با استفاده از دستور cargo new --vcs=git این رفتار را غیرفعال کنید.

نکته: گیت یک سیستم کنترل نسخه پراستفاده است. شما می‌توانید cargo new را تغییر دهید تا از سیستم کنترل نسخه متفاوت استفاده کنید یا با دستور --vcs بدون کنترل نسخه ادامه دهید. با اجرای `cargo new --help همه تنظیمات موجود را ببینید.

فایل Cargo.toml را در ویرایشگر متن خود باز کنید. باید شبیه کد ۱٫۲ باشد.

فایل: Cargo.toml

[package]
name = "hello_cargo"
version = "0.1.0"
authors = ["Your Name <you@example.com>"]
edition = "2018"

[dependencies]

کد ۱٫۲: محتوای Cargo.toml که توسط cargo new وارد شده است.

این فایل به فرمت TOML (Tom’s Obvious, Minimal Language) نوشته شده است که فرمت تنظیمات کارگو است.

خط اول [package]، تیتر یک بخش است که نشان می‌دهد عبارات بعد از آن برای تنظیم یک بسته (package) آمده‌اند. هرچه اطلاعات بیشتر به این فایل اضافه کنیم. بخش‌های جدید هم اضافه خواهند شد.

چهار خط بعدی تنظیمات اطلاعاتی که کارگو برای کامپایل برنامه شما نیاز دارد را مشخص می‌کنند: نام، نسخه، نویسنده و ویرایشی از Rust که باید استفاده شود. کارگو اطلاعاتی مثل اسم و ایمیل شما را از محیط اجرا می‌گیرد، پس اگر اطلاعات درست نیست آن‌ها را تصحیح کرده و فایل را ذخیره کنید. در مورد کلید edition در ضمیمه ث صحبت خواهیم کرد.

خط آخر [dependencies]، شروع بخشی است که می‌توانید در آن هر یک از پیشنیاز‌های پروژه‌تان را وارد کنید. در Rust به بسته‌های کد معمولاً crate گفته می‌شود. برای این پروژه به crate دیگری احتیاج نداریم، اما در اولین پروژه فصل ۲ نیاز خواهیم داشت. پس آن زمان از این قسمت استفاده خواهیم کرد.

حال فایل src/main.rs را باز کنید و نگاهی بیاندازید:

فایل: src/main.rs

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

کارگو یک برنامه سلام دنیا برای شما نوشته مثل برنامه‌ای که در کد ۱٫۱ نوشتیم! تا اینجا تفاوت بین پروژه قبلی و پروژه خروجی کارگو این است که کارگو کد‌ را در دایرکتوری src قرار داد. و یک فایل تنظیمات Cargo.toml در دایرکتوری بیرونی داریم.

کارگو از فایل‌های کد منبع شما انتظار دارد که در دایرکتوری src قرار گیرند. دایرکتوری بیرونی تنها برای فایل‌های README، اطلاعات مجوز‌ها و گواهی‌ها، فایل‌های تنظیمات و هرچیزی که به کد ربطی نداشته باشد است. استفاده از کارگو به شما کمک می‌کند پروژه‌های خود را سامان بخشید. ‌جایی مشخصی برای همه چیز وجود دارد و همه چیز سر جای خود است.

اگر پروژه‌ای شروع کردید که از کارگو استفاده نمی‌کند، مثل پروژه «سلام دنیا» قبلی، می‌توانید آنرا به پروژه‌ای که از کارگو استفاده کند تبدیل کنید. کافیست کد پروژه را داخل دایرکتوری src ببرید و یک فایل Cargo.toml مناسب تنظیم کنید.

ساخت و اجرای یک پروژه با کارگو

حال تفاوت ساخت و اجرا برنامه «سلام دنیا» با کارگو را بررسی کنیم. از دایرکتوری hello_cargo، پروژه خود را با دستور زیر بسازید:

$ 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) می‌سازد. در حالی که بدون استفاده از کارگو این فایل در دایرکتوری کنونی ساخته می‌شود. می‌توانید با دستور زیر برنامه را اجرا کنید:

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

اگر همه چیز به خوبی پیش برود، Hello, world!‍ باید روی صفحه ترمینال چاپ شود. اجرای دستور cargo build برای اولین بار باعث ساخت فایل جدیدی در دایرکتوری پروژه به نام Cargo.lock نیز می‌شود. این فایل شماره نسخه پیشنیاز‌های پروژه شما را نگهداری می‌کند. چون پروژه ما پیشنیازی ندارد این فایل دارای محتویات کمی است. هرگز لازم ندارید این فایل را بصورت دستی ویرایش کنید؛ کارگو مدیریت محتوای آن را بر عهده دارد.

ما با دستور 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!

توجه کنید که این دفعه ما هیچ خروجی‌ای که نشان دهنده کامپایل hello_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 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 به این پروسه سرعت می‌بخشد. به این علت برنامه‌نویس‌های Rust مداوم cargo check را اجرا می‌کنند تا از کامپایل شدن برنامه‌شان مطمئن شوند. بعد ها cargo build را برای ساخت و استفاده از خروجی اجرا می‌کنند.

مطالبی که در مورد کارگو گفتیم را مرور کنیم:

• می‌توانیم با دستور cargo build یا cargo check کامپایل کنیم.
• می‌توانیم با یک دستور cargo run پروژه را اول کامپایل و سپس اجرا کنیم.
• بجای ذخیره خروجی کامپایلر در دایرکتوری کدهایمان کارگو آنرا در target/debug نگهداری می‌کند.

یک برتری دیگر کارگو این است که صرف نظر از سیستم عامل شما دستوراتی که باید وارد کنید یکسان هستند. پس از اکنون دیگر جزئیات برای سیستم‌عامل های مختلف، مثل لینوکس و مک در مقابل ویندوز، ذکر نخواهیم کرد.

ساخت برای انتشار

وقتی پروژه شما برای انتشار آماده باشد می‌توانید از cargo build --release برای کامپایل کردن با بهینه‌سازی استفاده کنید. این دستور بجای target/debug خروجی اجرایی را در target/release قرار می‌دهد. بهینه‌سازی‌ها باعث می‌شوند کد Rust سریع‌تر اجرا شود اما در مقابل زمانی که برنامه کامپایل می‌شود طولانی‌تر باشد. به این علت دو پروفایل متفاوت وجود دارند: یکی برای زمان توسعه، وقتی که نیاز دارید با سرعت و مدام پروژه را بسازید؛ و حالتی دیگر برای ساخت برنامه نهایی که به کاربر استفاده کننده می‌دهید. که مدام انجام نمی‌شود و خروجی آن بیشترین سرعت ممکن را دارد. اگر قصد بنجمارک‌گیری از برنامه خود دارید باید دستور cargo build --release را اجرا کرده و از خروجی باینری در target/release استفاده کنید.

کارگو به عنوان قرارداد

با پروژه‌های ساده شاید کارگو ارزش خیلی زیادی در مقابل استفاده از rustc نداشته باشد. ولی وقتی برنامه شما پیچیده شود و از پروژه‌های مرکب و با crate‌های متفاوت استفاده کند، کارگو ارزش واقعی خود را نشان خواهد داد. در این حالت استفاده از کارگو برای ساخت پروژه بسیار آسان‌تر است.

اگرچه پروژه hello_cargo ساده است، بسیاری از ابزارهایی که در ادامه حرفه برنامه‌نویسی Rust استفاده خواهید کرد در آن کاربرد دارد. در واقع، برای کار روی پروژه‌های کنونی می‌توانید از دستورات زیر برای گرفتن کد با گیت، تغییر دایرکتوری به پروژه و ساخت آن استفاده کنید:

$ git clone someurl.com/someproject
$ cd someproject
$ cargo build

برای اطلاعات بیشتر در مورد کارگو مستندات آن را ببینید.

خلاصه

تا اینجا که شروع خیلی خوبی در سفر Rust خود داشته‌اید! در این فصل یاد گرفتید:

• آخرین نسخه پایدار Rust را با rustup نصب کنید
• به نسخه بالاتر Rust بروزرسانی کنید
• مستندات نصب شده محلی را باز کنید
• یک برنامه «سلام دنیا» با rustc بنویسید و اجرا کنید
• یک پروژه جدید طبق قراردادهای کارگو بسازید و اجرا کنید

حال زمان مناسبی برای ساخت یک برنامه واقعی، برای عادت کردن به خواندن و نوشتن کد Rust، است. پس در فصل ۲، برنامه یک بازی حدس زدنی را می‌نویسیم. اما اگر ترجیح می‌دهید از یادگیری مفاهیم معمول برنامه‌نویسی در Rust شروع کنید اول فصل ۳ را مطالعه کرده و بعد به فصل ۲ بازگردید.