دليل المبتدئين إلى Rust: من الألعاب إلى البرمجة، فهم سريع لنظام Rust البيئي

تتطور Rust بسرعة، فهي ليست مجرد لغة برمجة، بل هي أيضًا نظام بيئي نابض بالحياة. من ألعاب البقاء على قيد الحياة إلى برمجة الأنظمة عالية الأداء، يمكن رؤية Rust في كل مكان. ستنطلق هذه المقالة من المناقشات على X/Twitter لتقديم دليل سريع للمبتدئين في Rust، يغطي حالات استخدام Rust وموارد التعلم وبعض الأدوات العملية.

أولاً، ما هي Rust؟ ولماذا تستحق التعلم؟

Rust هي لغة برمجة أنظمة تركز على الأمان والسرعة والتزامن. وهي تهدف إلى حل مشكلات أمان الذاكرة الشائعة في C و C++، مع توفير أداء مكافئ أو حتى أعلى من هذه اللغات.

مزايا Rust:

• أمان الذاكرة: يمكن لنظام الملكية ومدقق الإعارة في Rust منع المشكلات مثل المؤشرات الفارغة وحالات السباق في وقت الترجمة.
• أداء عالٍ: يتم تجميع Rust في كود آلة فعال، ولديها قدرة تجريد قوية بدون تكلفة.
• أمان التزامن: يمكن لنظام أنواع Rust ضمان أمان التعليمات البرمجية المتزامنة وتجنب حالات السباق.
• عبر الأنظمة الأساسية: تدعم Rust مجموعة متنوعة من أنظمة التشغيل والبنى، بما في ذلك Windows و Linux و macOS و WebAssembly وما إلى ذلك.
• مجتمع نشط: لدى Rust مجتمع نابض بالحياة يوفر مكتبات وأدوات ودعمًا غنيًا.

حالات استخدام Rust:

• أنظمة التشغيل والأنظمة المدمجة: نظرًا لأدائها العالي وأمانها، فإن Rust مناسبة جدًا لتطوير نوى أنظمة التشغيل وبرامج التشغيل وبرامج الأجهزة المدمجة.
• WebAssembly (Wasm): يمكن تجميع Rust إلى Wasm، وبالتالي تشغيل التعليمات البرمجية عالية الأداء في المتصفح.
• أدوات سطر الأوامر: توفر Rust أطر عمل قوية لتطوير أدوات سطر الأوامر، مثل clap و structopt.
• برمجة الشبكات: توفر مكتبة tokio في Rust وقت تشغيل غير متزامن، مما يجعل كتابة تطبيقات الشبكة عالية الأداء أسهل.
• تطوير الألعاب: على الرغم من أنها ليست شائعة مثل C++، إلا أن Rust تظهر في مجال تطوير الألعاب، على سبيل المثال، لعبة البقاء على قيد الحياة مفتوحة المصدر Rust نفسها تم تطويرها باستخدام محرك Unity و C#، ولكن يمكن استخدام Rust لتحسين أداء بعض المنطق من جانب الخادم.

ثانيًا، من لعبة Rust إلى لغة برمجة Rust

ذكرت المناقشات على X/Twitter لعبة البقاء على قيد الحياة Rust، والتي لها علاقة وثيقة بلغة برمجة Rust. على الرغم من أنها تستخدم نفس الاسم، إلا أنها أشياء مختلفة. لعبة Rust هي لعبة بقاء على قيد الحياة متعددة اللاعبين عبر الإنترنت، بينما Rust هي لغة برمجة تستخدم لبناء مجموعة متنوعة من البرامج.

لعبة Rust:

• هي لعبة بقاء على قيد الحياة متعددة اللاعبين عبر الإنترنت، حيث يحتاج اللاعبون إلى البقاء على قيد الحياة في البرية وبناء قواعد والتفاعل مع لاعبين آخرين.
• تم تطويرها باستخدام محرك Unity و C#.
• يمكن شراؤها على Steam وغالبًا ما تكون هناك عروض ترويجية.

لغة برمجة Rust:

• تستخدم لتطوير مجموعة متنوعة من البرامج، بما في ذلك أنظمة التشغيل ومحركات المتصفح وخوادم الشبكة والألعاب وما إلى ذلك.
• مفتوحة المصدر وعبر الأنظمة الأساسية.
• لديها نظام أنواع قوي وميزات أمان الذاكرة.

إذا كنت لاعبًا في لعبة Rust وترغب في تعلم لغة برمجة Rust، فيمكنك التفكير في الخطوات التالية:

1. تثبيت سلسلة أدوات Rust: قم بتنزيل وتثبيت rustup، وهي أداة إدارة إصدارات Rust.
2. تعلم أساسيات Rust: اقرأ البرنامج التعليمي الرسمي "The Rust Programming Language" (المعروف باسم "The Book")، لفهم بناء جملة Rust الأساسي ونظام الملكية ومدقق الإعارة وما إلى ذلك.
3. المشاريع العملية: عزز ما تعلمته من خلال كتابة أدوات سطر أوامر بسيطة أو خوادم ويب أو ألعاب.
4. المشاركة في المجتمع: انضم إلى مجتمع Rust وتواصل مع مطوري Rust الآخرين وتعلم من تجاربهم.

ثالثًا: تهيئة بيئة تطوير Rust

تهيئة بيئة تطوير Rust بسيطة جدًا، تحتاج فقط إلى تثبيت rustup. سيقوم rustup بتثبيت مُصرّف Rust والمكتبة القياسية والأدوات الضرورية الأخرى تلقائيًا.

الخطوات:

1. تنزيل rustup: قم بزيارة ، وقم بتنزيل برنامج تثبيت rustup المناسب لنظام التشغيل الخاص بك.
2. تشغيل برنامج التثبيت: اتبع التعليمات الموجودة في برنامج التثبيت.
3. تكوين متغيرات البيئة: سيقوم rustup بتكوين متغيرات البيئة تلقائيًا، ويمكنك أيضًا تكوينها يدويًا.
4. التحقق من التثبيت: افتح الطرفية، وقم بتشغيل rustc --version و cargo --version، إذا تم عرض أرقام الإصدارات بشكل صحيح، فهذا يعني أن التثبيت قد نجح.

مثال على التعليمات البرمجية:

rustc --version  # عرض إصدار مُصرّف Rust
cargo --version  # عرض إصدار مدير الحزم Cargo

رابعًا: مقدمة سريعة إلى بناء الجملة الأساسي في Rust

فيما يلي بعض أساسيات بناء الجملة في Rust التي يمكن أن تساعدك على البدء بسرعة:

• إعلان المتغيرات:

  let x = 5;          // متغير غير قابل للتغيير
  let mut y = 10;     // متغير قابل للتغيير
  const PI: f64 = 3.1415926; // ثابت
  

• أنواع البيانات:

  • عدد صحيح: i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, isize, usize

  • عدد عشري: f32, f64

  • بولياني: bool (true, false)

  • حرف: char (حرف Unicode)

  • سلسلة نصية: String, &str

  • صف: (i32, f64, char)

  • مصفوفة: [i32; 5]

  • شريحة: &[i32]

  • هيكل:

    struct Point {
        x: i32,
        y: i32,
    }
    

  • تعداد:

    enum Color {
        Red,
        Green,
        Blue,
    }
    

• دالة:

  fn add(x: i32, y: i32) -> i32 {
      x + y
  }
  

• تدفق التحكم:

  • عبارة if:

    if x > 5 {
        println!("x is greater than 5");
    } else if x == 5 {
        println!("x is equal to 5");
    } else {
        println!("x is less than 5");
    }
    

  • حلقة loop:

    loop {
        println!("This will loop forever");
        break; // الخروج من الحلقة
    }
    ```## أولاً، لماذا Rust؟
    

Rust هي لغة برمجة حديثة تركز على الأمان والسرعة والتزامن. إنها مناسبة بشكل خاص لتطوير برامج النظام، وأدوات سطر الأوامر، وتطبيقات الويب عالية الأداء، والمزيد. بالمقارنة مع لغات مثل C و C++، توفر Rust أمانًا أفضل للذاكرة دون التضحية بالأداء.

ثانيًا، إعداد بيئة التطوير

1. تثبيت Rust:

• قم بزيارة الموقع الرسمي لـ Rust وقم بتنزيل وتثبيت أحدث إصدار من Rust.
• أثناء التثبيت، سيتم تثبيت rustup، وهو أداة لإدارة إصدارات Rust وسلاسل الأدوات.

2. تكوين متغيرات البيئة:

• بعد التثبيت، سيضيف rustup تلقائيًا Rust إلى متغيرات البيئة الخاصة بك. يمكنك التحقق من ذلك عن طريق فتح موجه الأوامر أو الوحدة الطرفية وتشغيل الأمر rustc --version. إذا تم عرض معلومات الإصدار بشكل صحيح، فهذا يعني أن التكوين ناجح.

3. محرر التعليمات البرمجية:

• يوصى باستخدام VS Code مع ملحق Rust Analyzer للحصول على تجربة تطوير أفضل.

ثالثًا، المفاهيم الأساسية

1. Hello, World!

• أنشئ ملفًا باسم main.rs وأدخل التعليمات البرمجية التالية:

  fn main() {
      println!("Hello, World!"); // اطبع Hello, World! إلى وحدة التحكم
  }
  

• افتح الوحدة الطرفية، وانتقل إلى الدليل الذي يوجد به main.rs، وقم بتشغيل الأمر rustc main.rs لتجميع التعليمات البرمجية.

• بعد التجميع، سيتم إنشاء ملف قابل للتنفيذ. قم بتشغيل هذا الملف القابل للتنفيذ (على سبيل المثال، ./main على نظام Linux/macOS أو main.exe على نظام Windows) وسترى الإخراج Hello, World!.

2. المتغيرات وأنواع البيانات:

• المتغيرات:

  let x = 5; // متغير غير قابل للتغيير
  let mut y = 10; // متغير قابل للتغيير
  y = 20; // يمكن تغيير قيمة y
  const Z: i32 = 30; // ثابت، يجب تحديد النوع
  

• أنواع البيانات:

  • الأعداد الصحيحة: i8, i16, i32, i64, i128, u8, u16, u32, u64, u128
  • الأعداد العشرية: f32, f64
  • القيم المنطقية: bool (true أو false)
  • الأحرف: char (يمثل حرف Unicode واحد)
  • السلاسل النصية: String, &str

  let a: i32 = 10; // عدد صحيح 32 بت
  let b: f64 = 3.14; // عدد عشري 64 بت
  let c: bool = true; // قيمة منطقية
  let d: char = 'A'; // حرف
  let e: String = String::from("Hello"); // سلسلة نصية قابلة للتغيير
  let f: &str = "World"; // شريحة سلسلة نصية غير قابلة للتغيير
  

3. الدوال:

• تعريف دالة:

  fn add(x: i32, y: i32) -> i32 { // تعريف دالة باسم add تأخذ وسيطتين من النوع i32 وتعيد قيمة من النوع i32
      x + y // لا حاجة إلى كلمة return، يتم إرجاع آخر تعبير
  }
  
  fn main() {
      let result = add(5, 3); // استدعاء الدالة add
      println!("Result: {}", result); // اطبع النتيجة
  }
  

4. التحكم في التدفق:

• if و else:

  let number = 7;
  
  if number < 5 {
      println!("condition was true");
  } else {
      println!("condition was false");
  }
  

• loop حلقة:

  loop {
      println!("again!");
      break; // للخروج من الحلقة
  }
  

• while حلقة:

  let mut i = 0;
  while i < 5 {
      println!("i = {}", i);
      i += 1;
  }
  

• for حلقة:

  let a = [10, 20, 30, 40, 50];
  
  for element in a.iter() {
      println!("the value is: {}", element);
  }
  

5. الملكية والاقتراض:

• الملكية: في Rust، لكل قيمة متغير يسمى "مالكها". عندما يخرج المالك عن النطاق، يتم تحرير الذاكرة تلقائيًا.

• الاقتراض: يمكن أن يكون لديك عدة مراجع غير قابلة للتغيير أو مرجع قابل للتغيير واحد فقط لنفس البيانات في نفس الوقت.

  fn main() {
      let s1 = String::from("hello");
      let s2 = &s1; // اقتراض غير قابل للتغيير
  
      println!("s1 is {}, s2 is {}", s1, s2);
  
      let mut s3 = String::from("hello");
      let s4 = &mut s3; // اقتراض قابل للتغيير
      s4.push_str(", world!");
  
      println!("s3 is {}, s4 is {}", s3, s4);
  }
  

6. الهياكل والتعدادات:

• الهياكل (Structs):

  struct User {
      username: String,
      email: String,
      sign_in_count: u64,
      active: bool,
  }
  
  fn main() {
      let user1 = User {
          email: String::from("someone@example.com"),
          username: String::from("someusername123"),
          active: true,
          sign_in_count: 1,
      };
  
      println!("Username: {}", user1.username);
  }
  

• التعدادات (Enums):

  enum Movement {
      Up,
      Down,
      Left,
      Right,
  }
  
  fn move_avatar(m: Movement) {
      match m {
          Movement::Up => println!("Moving up"),
          Movement::Down => println!("Moving down"),
          Movement::Left => println!("Moving left"),
          Movement::Right => println!("Moving right"),
      }
  }
  
  fn main() {
      let avatar_move = Movement::Left;
      move_avatar(avatar_move);
  }
  

7. معالجة الأخطاء:

• Result و panic!:

  use std::fs::File;
  use std::io::ErrorKind;
  
  fn main() {
      let f = File::open("hello.txt");
  
      let f = match f {
          Ok(file) => file,
          Err(error) => match error.kind() {
              ErrorKind::NotFound => match File::create("hello.txt") {
                  Ok(fc) => fc,
                  Err(e) => panic!("Problem creating the file: {:?}", e),
              },
              other_error => {
                  panic!("Problem opening the file: {:?}", other_error)
              }
          },
      };
  }
  

خامساً، الأدوات والموارد التعليمية

• Cargo: مدير الحزم وأداة البناء في Rust، تُستخدم لإدارة التبعيات وبناء المشاريع وتشغيل الاختبارات.
• Rust Analyzer: خادم لغة Rust قوي يوفر إكمال التعليمات البرمجية والتحقق من بناء الجملة وإعادة البناء وما إلى ذلك. يوصى بتثبيت الملحق المقابل في VS Code.
• Clippy: أداة تحليل ثابتة لتعليمات Rust البرمجية، يمكنها التحقق من المشكلات المحتملة في التعليمات البرمجية وتقديم اقتراحات للتحسين.
• crates.io: مستودع حزم Rust، مشابه لـ npm (JavaScript) أو PyPI (Python).
• الوثائق الرسمية: تحتوي على الوثائق الكاملة للغة Rust.
• Rust by Example: يوفر عددًا كبيرًا من أمثلة تعليمات Rust البرمجية.
• The Rust Programming Language (The Book): البرنامج التعليمي الرسمي لـ Rust، يوصى بشدة بقراءته.
• Rustlings: أداة تعليمية تفاعلية لـ Rust، تعلم Rust من خلال حل سلسلة من التمارين.
• الدورات التدريبية عبر الإنترنت: توجد العديد من الدورات التدريبية عبر الإنترنت لـ Rust على منصات مثل Udemy و Coursera.

سادساً، اتجاهات التعلم المتعمق

• البرمجة غير المتزامنة (async/await): استخدم tokio أو async-std لكتابة برامج متزامنة عالية الأداء.
• WebAssembly (Wasm): قم بتجميع تعليمات Rust البرمجية في Wasm وتشغيلها في المتصفح.
• تطوير الأنظمة المدمجة: استخدم Rust لتطوير برامج الأنظمة المدمجة.
• تطوير Blockchain: استخدم Rust لتطوير تطبيقات blockchain، مثل تطوير العقود الذكية لـ Solana.

سابعاً، الخلاصة

Rust هي لغة برمجة مليئة بالتحديات ولكنها ذات قيمة كبيرة. إنها توفر أمانًا وأداءً قويين، ولديها مجتمع نشط. آمل أن تساعدك هذه المقالة في البدء بسرعة في Rust وبدء رحلة برمجة Rust الخاصة بك. انطلاقًا من لعبة Rust، استكشف أسرار لغة البرمجة Rust، وستكتشف عالمًا جديدًا تمامًا.