برنامه Hello World با Rust

مقدمه

بعد از نصب موفقیت‌آمیز Rust روی سیستم خود، حالا قصد داریم اولین برنامه‌ی خود را با استفاده از این زبان ایجاد کنیم. در یادگیری یک زبان برنامه‌نویسی، نوشتن یک برنامه‌ی ساده که عبارت متنی Hello, world! را روی صفحه نمایش دهد، به یک سنت تبدیل شده است. ما نیز با پیروی از همین سنت در این بخش چنین برنامه‌ای را ایجاد می‌کنیم.

نوشتن و اجرای یک برنامه Rust

ابتدا یک دایرکتوری با نام projects برای نگهداری پروژه‌های خود ایجاد کنید. برای ساخت اولین پروژه، یک دایرکتوری با نام hello_world درون دایرکتوری projects ایجاد کنید و درون آن فایلی با نام main.rs بسازید. همانطور که احتمالاً حدس زده‌اید .rs پسوند فایل‌های کد Rust است. ضمناً در نامگذاری پروژه‌های Rust از استایل snake_case تبعیت می‌کنیم. در این استایل، کلمات با حروف کوچک نوشته شده و بین آنها از کاراکتر _ استفاده می‌کنیم. به همین دلیل است که نام hello_world را به پروژه‌ی خود اختصاص داده‌ایم.

حالا کدهای زیر را در فایل main.rs وارد کنید.

main.rs

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

سپس، این فایل را ذخیره کنید و یک پنجره‌ی ترمینال باز کنید و با استفاده از دستور cd به دایرکتوری hello_world بروید. در لینوکس و مک دستورات زیر را برای کامپایل و اجرای برنامه وارد کنید:

اما در ویندوز به جای ./main باید دستور .\main.exe را وارد کنید.

به این ترتیب، فارغ از اینکه از چه سیستم‌عاملی استفاده می‌کنید، در هر صورت عبارت Hello, world! در پنجره‌ی ترمینال شما نمایش داده می‌شود.
بسیار خوب، شما اولین برنامه‌ی Rust خود را ایجاد کردید و این یعنی اینکه شما الان یک برنامه‌نویس Rust هستید. پس به دنیای برنامه‌نویسان Rust خوش آمدید. حالا فقط باید هر چقدر می‌توانید در این مسیر پیشرفت کنید!

آناتومی یک برنامه Rust

اجازه دهید آنچه در برنامه‌ی Hello World گذشت را با جزئیات بیشتر بررسی کنیم و ببینیم این برنامه چطور کار می‌کند. در اولین بخش از کدهای فایل mian.rs عبارت زیر دیده می‌شود:

RUST

fn main() {

}

این عبارت یک تابع را در Rust تعریف می‌کند که نام آن main است. البته main نام یک تابع خاص در Rust است: این تابع به منزله‌ی نقطه‌ی ورود (entry point) هر برنامه‌ی اجرایی در Rust است و همواره اولین کدی است که اجرا می‌شود. خالی بودن پرانتزهای مربوط به این تابع حاکی از این امر است که این تابع هیچ پارامتر ورودی ندارد. همچنین، این تابع هیچ چیزی برنمی‌گرداند و دارای خروجی نیست.

در ادامه یک جفت آکلاد دیده می‌شود که کدهای مربوط به بدنه‌ی تابع درون این آکلادها قرار می‌گیرد. توجه کنید که یک فاصله (space) بین پرانتزهای تابع و آکلاد باز ایجاد شده و آکلاد بسته در خط دیگری قرار دارد. این شیوه و استایل کدنویسی مرسوم در Rust برای تعریف توابع است که بهتر است شما نیز آن را رعایت کنید.

تیم Rust یک ابزار فرمت‌دهی استاندارد به نام rustfmt را توسعه داده و به عنوان یک ابزار نصب استاندارد در پکیج نصب Rust جاسازی کرده تا به همراه کامپایلر rustc به طور خودکار نصب شود. اگر دستور rustfmt --version را آزمایش کنید، خواهید دید که ورژن این ابزار برای شما نمایش داده می‌شود. هدف از ارائه‌ی این ابزار این است که همه‌ی پروژه‌های Rust از یک استایل کدنویسی یکسان و استاندارد بهره ببرند. در مورد این ابزار در انتهای این دوره‌ی آموزشی مطالب لازم بیان خواهد شد.

اما درون تابع main نیز کد زیر قرار دارد:

RUST

println!("Hello, world!")

این همان خطی است که باعث نمایش پیام Hello, world! در خروجی می‌شود. عبارت متنی Hello, world! را به عنوان آرگومان println! فراهم کرده‌ایم و این مقدار در خروجی نمایش داده می‌شود. البته println! فراخوانی یک ماکرو در Rust است. اگر می‌خواستیم یک تابع را فراخوانی کنیم، باید از عبارت println (بدون علامت تعجب)‌ استفاده می‌کردیم. در فصل نوزدهم در مورد جزئیات ماکروها صحبت می‌کنیم و برای الان تنها چیزی که باید بدانید این است که استفاده از کاراکتر ! به این معناست که ما به جای یک تابع معمولی در حال فراخوانی یک ماکرو هستیم.

مطلب دیگری که از این مثال قابل برداشت است این است که دستورات Rust با سمی‌کالن به انتها می‌رسند.

کامپایل و اجرا در دو گام مجزا

در ادامه قصد داریم برنامه‌ی نوشته شده را اجرا کنیم. قبل از اجرای برنامه‌ی خود، باید با وارد کردن دستور زیر از کامپایلر rustc بخواهیم که فایل main.rs را کامپایل کند.

این امر برنامه‌نویسان C و C++ را به یاد gcc یا clang می‌اندازد. پس از کامپایل موفقیت‌آمیز برنامه، Rust یک فایل اجرایی باینری تولید می‌کند. در لینوکس و مک این فایل اجرایی main و در ویندوز main.exe نام دارد. اگر دستور ls را آزمایش کنید، در لینوکس و مک دو فایل main و main.rs را خواهیم دید:

اما در ویندوز علاوه بر این دو فایل، فایل سومی با نام main.pdb نیز تولید می شود که شامل اطلاعات مربوط به دیباگ برنامه است. در پاورشل می‌توانیم همانند بالا از دستور ls استفاده کنیم.

حالا دستور main (در لینوکس) یا main.exe (در ویندوز) را به فرم زیر اجرا کنید:

نتیجه‌ی این دستور نمایش پیام Hello, world! در پنجره‌ی ترمینال است.

اگر با زبان‌های دینامیک مانند روبی، پایتون و جاوااسکریپت آشنا باشید، شاید به کامپایل و اجرای برنامه در دو فاز مجزا عادت نداشته باشید. اما همانطور که قبلاً‌ هم گفتیم، Rust یک زبان کامپایلری است و این به این معناست که ما می‌توانیم برنامه را کامپایل کرده و یک فایل اجرایی تولید کنیم. حال، این فایل اجرایی تولید شده توسط کامپایلر را هر کسی می‌تواند روی سیستم خود بدون نیاز به Rust اجرا کند. اما در زبان‌های تفسیر شده و دینامیکی مانند پایتون و جاوااسکریپت تفسیر و اجرای برنامه در یک مرحله و در زمان اجرا انجام می‌شود و لذا اجرای یک فایل .py یا .js بدون وجود یک مفسرِ این زبان‌ها ممکن نیست.

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