برنامه نویسی Rust برای توسعه دهندگان جاوا

هیچ برنامه نویسی به اندازه برنامه نویسان Rust از زبان خود راضی نیست. و اگر جاوا را بلد باشید، یادگیری Rust نسبتا آسان است.

در میان زبان‌های برنامه‌نویسی جدیدتر که محبوبیت بیشتری دارد، Rust است. Rust اولین بار در سال ۲۰۱۰ معرفی شد و بی سر و صدا برای عملکرد، نحو و ویژگی های ایمنی رشته ها مورد توجه قرار گرفت. اگر توسعه‌دهنده جاوا هستید، به لطف شباهت این دو زبان، Rust را نسبتاً آسان می‌یابید.

طبق نظرسنجی سرریز پشته. این گواهی بر تجربه عالی استفاده از Rust است.

در صورتی که از پس‌زمینه جاوا می‌آیید، به برخی از اصلی‌ترین چیزهایی که باید درباره Rust بدانید، ادامه دهید.

نحو زنگ زده

Rust مانند جاوا کامپایل شده است. این به مشخصات LLVM، شبیه به JVM کامپایل شده است. ، اجازه خروجی را به انواع پلتفرم های هدف می دهد.

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

فهرست ۱. کد ساده Rust

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

توجه کنید که یک تابع main()، مشابه نقطه ورودی در جاوا وجود دارد.

توابع در Rust

توابع به تنهایی در Rust قرار دارند و می‌توانند در هر جایی اعلام شوند، از جمله تو در تو در توابع دیگر. این برخلاف جاوا است، جایی که توابع همیشه به عنوان متدهای روی اشیاء اعلام می شوند (به جز در مورد لامبدا). به عبارت دیگر، در جاوا همه چیز یک شی است. در Rust اینطور نیست.

فهرست ۲. استفاده از توابع در Rust

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

    fn function2(){
        println!("Hello InfoWorld");
    }
    function2();

    function3();
}

fn function3() {
    println!("Hello again.");
}

مقادیر بازگشتی ضمنی

برخلاف جاوا، Rust به شما اجازه می دهد تا از کلمه کلیدی بازگشتی در انتهای یک تابع صرف نظر کنید. عبارت نهایی در تابع به طور خودکار به عنوان مقدار بازگشتی ارزیابی می شود. هنگام انجام این کار، نقطه ویرگول را از عبارت نهایی حذف می کنید.

لامبدا

Rust مانند جاوا از لامبدا برای کدنویسی سبک عملکردی پشتیبانی می کند. نحو متفاوت است، اما اگر با API جریان های جاوا آشنایی دارید، درک آن سخت نیست. لیست ۳ استفاده از تابع map() را برای ایجاد مجموعه ای از رشته ها با حروف بزرگ نشان می دهد. همانطور که می بینید، کاملاً شبیه جاوا است.

فهرست ۳. مرتب‌سازی عملکردی با لامبدا

// Rust
fn main() {
    let animals = ["dog", "badger", "quokka"];

    let result = animals.iter().map(|value| value.to_uppercase());

    for animal in result {
        println!("Uppercased: {}", animal);
    }
}

تابع map() یک آرگومان دو بخشی می گیرد. قسمت اول یک متغیر در داخل کاراکترهای لوله است، |value|، که متغیری را که به عنوان دسته برای هر آیتم استفاده می شود، تعریف می کند. بخش دوم عملیات اجراست. در این مورد، to_uppercase() را روی هر عنصر آرایه فراخوانی می کنیم.

توجه داشته باشید که مانند جاوا، Rust lambdas بسته‌هایی هستند که وضعیت بلوک اطراف را نشان می‌دهند. به عبارت دیگر، آنها به متن متغیری که در آن اجرا می کنند دسترسی دارند.

اشیاء ساختارهایی در Rust هستند

به فهرست ۴ که کلمه کلیدی struct را معرفی می کند، نگاهی بیندازید. یک ساختار، که مخفف ساختار است، به شما امکان می دهد تا یک محفظه برای داده تعریف کنید، درست مانند قسمت حالت یک کلاس در جاوا.

فهرست ۴. استفاده از ساختار Rust

struct Animal {
  name: String
}
fn main() {
  let dog = Animal{
    name: String::from("Shiba")
  };
  println!("{}", dog.name);
}

شما اعضای ساختار را در داخل پرانتز فرفری ساختار تعریف می‌کنید. این متغیرها مشابه اعضای عمومی هستند.

توجه داشته باشید که در خطی که متغیر dog را اعلام می‌کنید، هیچ تماسی با کلمه کلیدی جدید لازم نیست. Rust می تواند از زمینه استنباط کند که یک مرجع جدید درست است.

بعد، توجه داشته باشید که متغیر name در زمان ایجاد به عنوان رشته ای با مقدار تنظیم شده است. این کار از طریق فراخوانی روش داخلی String.from با استفاده از عملگر مرجع دو نقطه ای انجام می شود.

در نهایت، توجه داشته باشید که دقیقاً مانند جاوا، Rust از عملگر نقطه برای دسترسی به فیلد name در نمونه dog استفاده می‌کند: dog.name .

روش ها

شما می‌توانید توابع را به ساختارها اضافه کنید، و این توابع مانند متدها در جاوا عمل می‌کنند. به عنوان مثال، برای افزودن یک متد speak() به ساختار Animal نشان داده شده در فهرست ۴، می توانید از کلمه کلیدی impl همانطور که در Listing مشاهده می شود استفاده کنید. ۵.

فهرست ۵. افزودن روش

impl Animal {
  fn speak(&self) {
      println!("{}", self.name);
  }
}

Impl به معنای پیاده سازی است. در اینجا در لیست ۵، ما ساختار Animal را پیاده سازی می کنیم. ما یک متد واحد را تعریف می کنیم، speak، که یک آرگومان واحد می گیرد. این آرگومان نشانگر ویژه &self است (امپرسند در Rust به معنای ارجاع است). این اشاره گر ویژه معنایی بسیار شبیه به کلمه کلیدی this در جاوا دارد. به نمونه شی فعال فعلی اشاره دارد.

با فراخوانی dog.speak() نام شیء نمونه فعلی که در این مثال "Shiba" است، خروجی خواهد شد.

تغییرپذیری در Rust

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

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

فهرست ۶ نشان می دهد که چگونه می توان شی dog را قابل تغییر کرد و سپس نام جدیدی به آن اختصاص داد.

فهرست ۶. یک رشته قابل تغییر

let mut dog = Animal{
  name: String::from("Shiba")
};
dog.name = String::from("Suki");
println!("{}", dog.name);

کلید اینجا کلمه کلیدی mut است که به اعلان اضافه شده است.

استنتاج را در Rust تایپ کنید

در Rust، همیشه لازم نیست به کامپایلر بگویید چه نوع متغیری را اعلام می‌کنید. این برای توسعه دهندگانی که از جاوا می آیند عجیب به نظر می رسد، جایی که هیچ امکانی برای استنباط نوع متغیر وجود ندارد. به عنوان مثال، در لیست ۷، کامپایلر به درستی نوع را به عنوان عدد صحیح استنباط می کند.

فهرست ۷. نمونه استنتاج را تایپ کنید

let number1 = 10;
let number2 = 10;
println!("{}", number1 * number2);

سایه و نام متغیر

یکی دیگر از ویژگی های Rust که ممکن است توسعه دهندگان جاوا را شگفت زده کند، چیزی است که سایه متغیر نامیده می شود. در اصل، به جای اینکه یک متغیر را به عنوان قابل تغییر اعلام کنید، می توانید یک ماسک در بالای آن با همان نام ایجاد کنید.

این یک نوع تغییرپذیری یکباره است که فضای جدیدی را برای همان نام متغیر ایجاد می کند. به طور کلی، امکان استفاده مجدد از نام متغیر مشابه با جاوا متفاوت است. فهرست ۸ یک مثال ساده از سایه گذاری متغیر را نشان می دهد.

فهرست ۸. سایه‌زنی متغیر

fn main() {
    let x = 5;
    let x = x + 1;
    println!("The value of x is: {}", x); // outputs 6
}

تایپ تاپل در Rust

Rust از نوع تاپلی پشتیبانی می‌کند، که نوعی متغیر ترکیبی است که آنالوگ واقعی در جاوا ندارد. فهرست ۹ نمونه ای از یک تاپل در حال عمل را به شما نشان می دهد.

فهرست ۹. استفاده از نوع تاپل

fn main() {
    let myTuple = ("Sum", 10, 5);
    let (x, y) = myTuple ;
    println!("The {} is: {}", x, y + z);
}

در اینجا می توانید ببینید که متغیر myTuple با پرانتزهای حاوی سه مقدار، یک رشته و دو عدد صحیح اعلام شده است. این یک تاپل است.

می توانید تاپل را به متغیرهای اسکالر “تخریب کنید” همانطور که در خط بعدی مشاهده می شود، جایی که کلمه کلیدی let برای پر کردن هر متغیر استفاده می شود، x، y و z، با مقادیر تاپل.

همچنین می‌توانید با فهرست به اعضای چندگانه دسترسی داشته باشید. برای مثال، tup.0 به اولین فیلد روی تاپل (رشته "Sum") ارجاع می دهد.

خواص و ژنریک در Rust

در Rust مفهوم صفات وجود دارد که شبیه رابط های ریز دانه در جاوا هستند: آنها مشخص می کنند که یک نوع چه ویژگی هایی را با انواع دیگر به اشتراک می گذارد. به عبارت دیگر، ویژگی های عملکرد مشترک انتزاعی را در انواع مختلف مشخص می کند.

Generics در Rust مشابه آنچه در جاوا کار می‌کند، با استفاده از دستور زبان براکت زاویه‌ای مشابه، برای آدرس‌دهی انواع به روشی کلی بر اساس ویژگی‌های مشترکشان کار می‌کند.

به فهرست ۱۰ نگاهی بیندازید، که نمونه‌ای از استفاده از ویژگی‌های کتابچه راهنمای Rust را خلاصه می‌کند.

فهرست ۱۰. استفاده از یک ویژگی

pub trait Summary {
    fn summarize(&self) -> String;
}
pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

pub struct Tweet {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub retweet: bool,
}

impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

fn main() {
    let tweet = Tweet {
        username: String::from("dog_post"),
        content: String::from("A Shih Tzu is smaller than a Lurcher",
        ),
        reply: false,
        retweet: false,
    };

    println!("1 new tweet: {}", tweet.summarize());
}

در اینجا از کلمه کلیدی trait برای تعریف ویژگی Summary استفاده می‌شود که سپس برای هر نوع، NewsArticle و Tweet اجرا می‌شود. ، با استفاده از کلمه کلیدی impl. بنابراین این بسیار شبیه به یک رابط در جاوا است، با این تفاوت که در جاوا یک رابط به جای روش‌های تعریف تکه‌ای، سطح کل کلاس را تعریف می‌کند.

نوشیدنی نه چندان عجیب

اگرچه این یک تور مختصر از برخی از برجسته ترین نکات برای یک برنامه نویس جاوا است که به Rust تازه کار شده است، اما می توانید ببینید که نزدیک شدن به این زبان خیلی سخت نیست. همیشه خوب است که نسبت به فناوری جدید ذهنی باز داشته باشید، و Rust با رتبه‌بندی رضایت توسعه‌دهندگان سازگار خود را توصیه می‌کند.