تخطي للذهاب إلى المحتوى

أساسيات رست (Rust) لمطوّري بايثون وجافاسكريبت: اقرأ الكود الذي يكتبه لك الذكاء الاصطناعي

الجزء الأول: الملكية والاستعارة وOption وResult والسمات والمكرِّرات، وأخطاء المترجم التي ستصادفها أولاً، وكيف تراجع كود رست كتبه الذكاء الاصطناعي
16 نوفمبر 2026 بواسطة
أساسيات رست (Rust) لمطوّري بايثون وجافاسكريبت: اقرأ الكود الذي يكتبه لك الذكاء الاصطناعي
Hassan Tabbal

تختار فرق أكثر فأكثر لغة رست (Rust) للخدمات الجديدة وأدوات سطر الأوامر وأجزاء الأنظمة التي يجب أن تكون سريعة وآمنة. ويتعرّف كثير من المطوّرين اليوم على رست عبر مساعد ذكاء اصطناعي، فيطلبون ميزة ويحصلون على بضع مئات من الأسطر التي تُترجَم بنجاح، ثم يطلقونها. وينجح ذلك حتى يتعطّل شيء ما، أو يسأل أحد المراجعين سؤالاً، أو يرفض المترجم (compiler) تعديلاً صغيراً برسالة خطأ تبدو كاللغز.

هذا الجزء الأول من سلسلة عن رست للمطوّرين القادمين من بايثون (Python) أو جافاسكريبت (JavaScript). ويغطي الأفكار التي تحتاجها لتقرأ كود رست بثقة، أي معنى الرموز، وسبب اعتراض المترجم، وما الذي تتحقّق منه في كود كتبه لك الذكاء الاصطناعي. وستتعمّق الأجزاء التالية في معالجة الأخطاء والكود غير المتزامن (async) وبناء مشاريع حقيقية.

ترجمنا كل مثال أدناه وشغّلناه على رست 1.93 (إصدار 2024). ويمكنك لصق أي منها في Rust Playground وتشغيله في متصفحك من دون تثبيت أي شيء.

عادات بايثون وجافاسكريبت مقارنة برست: غياب القيمة هو None أو null في بايثون وجافاسكريبت وOption في رست؛ الأخطاء تُرمى في بايثون وجافاسكريبت، وفي رست هي Result فيها Ok أو Err وتُمرَّر بعلامة الاستفهام؛ المتغيّرات قابلة للتغيير ما لم تكن const، وفي رست فقط حين تُعلَن مع mut؛ الذاكرة يحرّرها جامع المهملات، وفي رست حين يخرج مالكها من النطاق؛ السلوك المشترك يقوم على duck typing والأصناف، وفي رست على السمات (traits)

التثبيت واستعمال Cargo

ثبّت رست باستعمال rustup من صفحة التثبيت الرسمية. فتحصل على المترجم وعلى Cargo (أداة البناء ومدير الحزم في رست، مثل pip أو npm) وعلى أداتين ستستعملهما كثيراً هما Clippy وrustfmt.

cargo new my_app        # creates Cargo.toml and src/main.rs
cd my_app
cargo run               # compiles and runs
cargo build --release   # an optimised build for production
cargo test              # runs the tests
cargo fmt               # formats the code
cargo clippy            # catches common mistakes

يقوم Cargo.toml بدور requirements.txt أو package.json. وتُسمّى المكتبات حزماً (crates) وتأتي من crates.io. ويسجّل الملف Cargo.lock الإصدارات الدقيقة التي بنيت بها، لذلك احفظه في المستودع.

المتغيّرات وmut والتظليل (shadowing)

تُنشأ المتغيّرات بـlet ولا يمكن تغييرها ما لم تضف mut. ويستنتج رست معظم الأنواع وحده، ويمكنك كتابة النوع بعد نقطتين حين تريد التوضيح أو حين لا يستطيع رست أن يخمّنه.

fn main() {
    let name = "Lina"; // type inferred: &str
    let mut count = 0; // mut: this one can change
    count += 1;

    let price: f64 = 19.5; // type written out
    let input = "42"; // a &str
    let input: u32 = input.parse().unwrap(); // shadowing: a new `input`, now a number

    println!("{name} {count} {price} {}", input + 1);
}

السطر الثاني let input ليس خطأ، بل يُسمّى التظليل (shadowing)، أي متغيّر جديد بالاسم نفسه، وهو هنا رقم مأخوذ من النص. ويستعمله الكود الذي يكتبه الذكاء الاصطناعي كثيراً حين يحوّل القيم. وإن نسيت mut أوقفك المترجم:

error[E0384]: cannot assign twice to immutable variable `count`
 --> e1_immutable.rs:3:5
  |
2 |     let count = 0;
  |         ----- first assignment to `count`
3 |     count += 1;
  |     ^^^^^^^^^^ cannot assign twice to immutable variable
  |
help: consider making this binding mutable
  |
2 |     let mut count = 0;
  |         +++

اقرأ أخطاء رست من الأعلى. فالسطر الأول يعطي رمز الخطأ والمشكلة، والأسهم تشير إلى الأسطر المعنية، وقسم help يحتوي الحل في أحيان كثيرة. ولأي رمز، يطبع الأمر rustc --explain E0384 شرحاً كاملاً مع أمثلة.

الملكية (ownership): لكل قيمة مالك واحد

هذه هي الفكرة التي تميّز رست عن بايثون وجافاسكريبت. فلا يوجد جامع مهملات، ولكل قيمة مالك واحد، وحين يخرج المالك من النطاق تُحرَّر الذاكرة. وإسناد String إلى متغيّر آخر ينقلها إليه (move)، فلا يعود الاسم القديم صالحاً للاستعمال.

fn main() {
    let a = String::from("invoice-001");
    let b = a; // the String moves to b; a can't be used any more
    println!("{b}");

    let c = b.clone(); // a real copy of the text
    println!("{b} {c}");

    let x = 5;
    let y = x; // numbers are Copy: x is still usable
    println!("{x} {y}");
}

القيم الصغيرة مثل الأرقام والقيم المنطقية تُنسخ بدلاً من أن تُنقل، ولذلك يبقى x صالحاً. ففي بايثون يعطيك b = a اسمين للكائن نفسه، أما في رست فيتوقّف الاسم الأول عن الصلاحية، واستعماله خطأ:

error[E0382]: borrow of moved value: `a`
 --> e2_moved.rs:4:13
  |
2 |     let a = String::from("invoice-001");
  |         - move occurs because `a` has type `String`, which does not implement the `Copy` trait
3 |     let b = a;
  |             - value moved here
4 |     let n = a.len();
  |             ^ value borrowed here after move
  |
help: consider cloning the value if the performance cost is acceptable
  |
3 |     let b = a.clone();
  |              ++++++++

انظر إلى المساعدة في الأسفل. فالمترجم يقترح .clone()، ومساعد الذكاء الاصطناعي الذي يصلح الأخطاء واحداً تلو الآخر يقبل هذا الاقتراح في أحيان كثيرة. وهكذا يمتلئ كود رست الذي يكتبه الذكاء الاصطناعي بالنسخ، فيُترجَم بنجاح لكنه ينسخ بيانات كان يحتاج إلى قراءتها فقط. والاستعارة، في القسم التالي، هي الحل الأفضل عادة.

الاستعارة (borrowing): & و&mut

في معظم الأحيان لا تريد أن تعطي القيمة لغيرك، وإنما أن تعيرها. فـ&value يعيرها للقراءة و&mut value يعيرها للتعديل. والدالة التي تأخذ &str أو &Vec تستعير، ويحتفظ المستدعي بالملكية.

fn count_chars(text: &str) -> usize {
    // borrows, reads only
    text.chars().count()
}

fn add_item(list: &mut Vec<String>, item: &str) {
    // borrows, may change
    list.push(item.to_string());
}

fn main() {
    let title = String::from("Kitchen knives");
    println!("{}", count_chars(&title));
    println!("{title}"); // still ours: we only lent it

    let mut cart = Vec::new();
    add_item(&mut cart, "Pot");
    add_item(&mut cart, "Pan");
    println!("{cart:?}");
}

وتتبع الاستعارة قاعدة واحدة ستصادفها مراراً، ففي أي لحظة يمكن أن يكون لديك قرّاء كثيرون أو كاتب واحد، ولا يجتمع الاثنان. وهذه القاعدة هي ما يمنع جزأين من البرنامج من تعديل البيانات نفسها في الوقت نفسه، ويتحقّق منها المترجم عند الترجمة.

القواعد الأربع وراء معظم أخطاء مترجم رست: لكل قيمة مالك واحد وتُحرَّر حين يخرج المالك من النطاق؛ let b = a تنقل String إلى b ولا يمكن استعمال a بعدها؛ يمكن لأي عدد من الاستعارات المشتركة أن تقرأ في الوقت نفسه؛ أو يمكن لاستعارة قابلة للتعديل واحدة أن تغيّر القيمة ولا أحد غيرها يقرأ

هنا يحتفظ الكود بمرجع إلى العنصر الأول ثم يضيف عنصراً إلى القائمة. والإضافة قد تنقل القائمة إلى كتلة ذاكرة أكبر، فيصبح المرجع مشيراً إلى ذاكرة محرَّرة، لذلك يرفض رست:

error[E0502]: cannot borrow `cart` as mutable because it is also borrowed as immutable
 --> e3_borrow.rs:4:5
  |
3 |     let first = &cart[0];
  |                  ---- immutable borrow occurs here
4 |     cart.push(String::from("Pan"));
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable borrow occurs here
5 |     println!("{first}");
  |                ----- immutable borrow later used here

تذكر الرسالة الاستعارتين والسطر الذي ما زالت الأولى مستعملة فيه. والحل أن تنتهي من القارئ قبل أن تكتب، مثلاً بطباعة first قبل الإضافة، أو بنسخ القيمة الوحيدة التي تحتاجها.

مدد الحياة (lifetimes): ما معنى 'a حين تراها

عاجلاً أو آجلاً سترى توقيعاً مثل هذا في كود كتبه الذكاء الاصطناعي:

fn longer<'a>(a: &'a str, b: &'a str) -> &'a str {
    if a.len() >= b.len() { a } else { b }
}

fn main() {
    let first = String::from("frying pan");
    let second = String::from("wok");
    println!("{}", longer(&first, &second));
}

'a مدة حياة (lifetime). وهي لا تغيّر طريقة عمل البرنامج، وإنما تخبر المترجم بأن المرجع المُعاد يأتي من المدخلات ولا يمكن أن يعيش أطول منها. ومن دونها لا يستطيع رست أن يعرف من أي مُدخل يستعير الناتج:

error[E0106]: missing lifetime specifier
 --> e4_lifetime.rs:1:32
  |
1 | fn longer(a: &str, b: &str) -> &str {
  |              ----     ----     ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `a` or `b`
help: consider introducing a named lifetime parameter
  |
1 | fn longer<'a>(a: &'a str, b: &'a str) -> &'a str {
  |          ++++     ++          ++          ++

لقراءة الكود، هذا كل ما تحتاجه الآن، فـ'a تربط مدة حياة ما يدخل بما يخرج. وحين تحمل بنية (struct) مراجع، سترى العلامة نفسها على البنية. وإن بدأت مدد الحياة تنتشر في الكود، فمن الأبسط غالباً أن تخزّن قيماً مملوكة مثل String في البنية.

البنى (structs) وimpl وأنواع self الثلاثة

تحمل البنية (struct) البيانات، ويضيف إليها قسم impl الدوال. ولا توجد أصناف ولا وراثة. والمعامل الأول في الدالة يخبرك بما تفعله بالقيمة، ومن المفيد أن تتعلّم قراءته بنظرة واحدة.

#[derive(Debug)]
struct Order {
    customer: String,
    lines: Vec<f64>,
}

impl Order {
    fn new(customer: &str) -> Self {
        // no self: called as Order::new(...)
        Order {
            customer: customer.to_string(),
            lines: Vec::new(),
        }
    }

    fn total(&self) -> f64 {
        // &self: reads the order
        self.lines.iter().sum()
    }

    fn add_line(&mut self, amount: f64) {
        // &mut self: changes the order
        self.lines.push(amount);
    }

    fn close(self) -> String {
        // self: takes the order, it's gone after
        format!("{} paid {:.2}", self.customer, self.total())
    }
}

fn main() {
    let mut order = Order::new("Cedar Home");
    order.add_line(25.0);
    order.add_line(14.5);
    println!("{order:?}");
    println!("{}", order.total());
    println!("{}", order.close());
}
  • بلا self، كما في new: دالة مرتبطة تُستدعى بـOrder::new(...)، مثل الدالة الساكنة (static method).
  • &self: الدالة تقرأ فقط.
  • &mut self: الدالة تغيّر القيمة، لذلك يجب أن يُعلَن المتغيّر مع mut.
  • self: الدالة تأخذ الملكية، ولا يمكن استعمال القيمة بعد الاستدعاء.

السطر #[derive(Debug)] فوق البنية سِمة (attribute)، تطلب من المترجم أن يكتب كوداً بدلاً منك، وهو هنا الكود الذي يتيح طباعة البنية بـ{order:?}.

التعدادات (enums) وmatch

التعدادات في رست أكثر من قائمة أسماء، فكل متغيّر فيها يمكن أن يحمل بياناته، وmatch تجبرك على معالجة كل متغيّر. وإن أضاف أحدهم متغيّراً جديداً لاحقاً، يتوقّف عن الترجمة كل match ينساه.

enum Payment {
    Paid,
    Pending { days_left: u32 },
    Failed(String),
}

fn describe(p: &Payment) -> String {
    match p {
        Payment::Paid => "paid".to_string(),
        Payment::Pending { days_left } if *days_left == 0 => "due today".to_string(),
        Payment::Pending { days_left } => format!("due in {days_left} days"),
        Payment::Failed(reason) => format!("failed: {reason}"),
    }
}

fn main() {
    let all = [
        Payment::Paid,
        Payment::Pending { days_left: 3 },
        Payment::Pending { days_left: 0 },
        Payment::Failed("card declined".into()),
    ];
    for p in &all {
        println!("{}", describe(p));
    }
}

وif بعد النمط شرط حارس (guard)، والفروع تُفحَص من الأعلى إلى الأسفل. ففي بايثون كنت ستكتب سلسلة if وelif مع حالات نصية، أما هنا فالخطأ الإملائي في اسم حالة خطأ ترجمة.

Option وResult بدلاً من null والاستثناءات

لا يوجد في رست null ولا استثناءات. فالقيمة التي قد تغيب هي Option، إما Some(value) أو None. والعملية التي قد تفشل تُعيد Result، إما Ok(value) أو Err(error). والنوع يخبرك مسبقاً بأن شيئاً قد يخطئ، والمترجم يجبرك على التعامل معه.

use std::num::ParseIntError;

fn find_price(code: &str) -> Option<f64> {
    match code {
        "POT-01" => Some(35.0),
        "KNF-07" => Some(22.5),
        _ => None,
    }
}

fn parse_quantity(text: &str) -> Result<u32, ParseIntError> {
    let qty = text.trim().parse::<u32>()?; // on error, return it to the caller
    Ok(qty)
}

fn line_total(code: &str, qty_text: &str) -> Result<f64, String> {
    let price = find_price(code).ok_or(format!("unknown product {code}"))?;
    let qty = parse_quantity(qty_text).map_err(|e| e.to_string())?;
    Ok(price * qty as f64)
}

fn main() {
    if let Some(price) = find_price("POT-01") {
        println!("price {price}");
    }
    match line_total("KNF-07", "4") {
        Ok(total) => println!("total {total}"),
        Err(e) => println!("error: {e}"),
    }
    match line_total("KNF-07", "four") {
        Ok(total) => println!("total {total}"),
        Err(e) => println!("error: {e}"),
    }
    match line_total("XYZ", "1") {
        Ok(total) => println!("total {total}"),
        Err(e) => println!("error: {e}"),
    }
}

و? في نهاية السطر أهم رمز تتعلّمه، ومعناه: إن فشلت هذه العملية فأعِد الخطأ إلى من استدعاني الآن، وإلا فأعطني القيمة. وهو يقوم بدور الاستثناء الذي يصعد، لكنك ترى كل مكان يحدث فيه. وتحوّل ok_or قيمة Option إلى Result، وتحوّل map_err نوع خطأ إلى آخر. وعند تشغيل البرنامج يطبع:

price 35
total 90
error: invalid digit found in string
error: unknown product XYZ

لا يعمل ? إلا داخل دالة تُعيد هي نفسها Result أو Option. فإن استعملته في main عادية حصلت على:

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
 --> e5_question.rs:2:31
  |
1 | fn main() {
  | --------- this function should return `Result` or `Option` to accept `?`
2 |     let qty: u32 = "4".parse()?;
  |                               ^ cannot use the `?` operator in a function that returns `()`
  |
help: consider adding return type
  |
1 ~ fn main() -> Result<(), Box<dyn std::error::Error>> {
2 |     let qty: u32 = "4".parse()?;
3 |     println!("{qty}");
4 +     Ok(())
  |

وتُظهر المساعدة الحل المعتاد، أي main تُعيد Result:

use std::error::Error;

fn main() -> Result<(), Box<dyn Error>> {
    let qty: u32 = "4".parse()?;
    println!("{qty}");
    Ok(())
}

unwrap(): أول ما تبحث عنه في كود رست الذي يكتبه الذكاء الاصطناعي

تأخذ .unwrap() القيمة من Option أو Result وتوقف البرنامج بانهيار إن لم تكن موجودة. وتستعملها مساعدات الذكاء الاصطناعي كثيراً لأنها تُبقي الأمثلة قصيرة، لكنها في خدمة حقيقية تعني أن مُدخلاً سيئاً واحداً قد يُسقط العملية كلها:

fn main() {
    let from_user = "abc";
    let qty: u32 = from_user.parse().unwrap();
    println!("{qty}");
}
thread 'main' (18131820) panicked at src/main.rs:3:38:
called `Result::unwrap()` on an `Err` value: ParseIntError { kind: InvalidDigit }

عالج الخطأ بدلاً من ذلك، أو استعمل قيمة افتراضية معقولة:

fn main() {
    let from_user = "abc";
    match from_user.parse::<u32>() {
        Ok(qty) => println!("quantity {qty}"),
        Err(e) => println!("please enter a whole number ({e})"),
    }
    let qty: u32 = from_user.parse().unwrap_or(1);
    println!("{qty}");
}

unwrap() مقبولة في الاختبارات والسكربتات السريعة والأماكن التي يستحيل فيها الفشل فعلاً. و.expect("reason") تنهار بالطريقة نفسها لكنها تقول السبب على الأقل. وفي كل مكان آخر، ابحث في الكود عن unwrap واسأل ماذا يحدث حين تفشل.

السمات (traits) والأنواع العامة (generics)

السمة (trait) مجموعة دوال يتعهّد النوع بأن يوفّرها، وهي قريبة من interface في TypeScript أو protocol في بايثون. وتتيح الأنواع العامة (generics) للدالة أن تقبل أي نوع يطبّق سمة ما. وسترى الفكرة نفسها مكتوبة بثلاث طرق، ومعناها واحد:

trait Describe {
    fn describe(&self) -> String;
}

struct Product {
    name: String,
    price: f64,
}
struct Customer {
    name: String,
}

impl Describe for Product {
    fn describe(&self) -> String {
        format!("{} at {:.2}", self.name, self.price)
    }
}

impl Describe for Customer {
    fn describe(&self) -> String {
        format!("customer {}", self.name)
    }
}

// Three ways to write "any type that implements Describe"
fn show(item: &impl Describe) {
    println!("{}", item.describe());
}
fn show_generic<T: Describe>(item: &T) {
    println!("{}", item.describe());
}
fn show_where<T>(item: &T)
where
    T: Describe,
{
    println!("{}", item.describe());
}

fn main() {
    let p = Product {
        name: "Steel pot".into(),
        price: 35.0,
    };
    let c = Customer {
        name: "Rana".into(),
    };
    show(&p);
    show_generic(&c);
    show_where(&p);
}

حين تقرأ <T: Describe>، قل: أي نوع T يطبّق Describe. والسمات أيضاً وراء أشياء كثيرة تبدو مدمجة في اللغة. فالطباعة بـ{} تحتاج سمة Display، و{:?} تحتاج Debug، و.clone() تحتاج Clone.

الإغلاقات (closures) والمكرِّرات (iterators)

الكود الذي يمرّ على البيانات يُكتب عادة كسلسلة من دوال المكرِّرات، ويُقرأ مثل map وfilter في جافاسكريبت أو list comprehension في بايثون.

fn main() {
    let prices = [12.0, 45.5, 8.25, 120.0];
    let min = 10.0;

    let discounted: Vec<f64> = prices
        .iter()
        .filter(|p| **p > min) // closure: |arguments| body
        .map(|p| p * 0.9)
        .collect();

    let total: f64 = discounted.iter().sum();
    println!("{discounted:?} {total:.2}");
}

|p| p * 0.9 إغلاق (closure)، وهو نسخة رست من lambda أو الدالة السهمية. وهناك تفصيلان يربكان المبتدئين. فالمكرِّرات كسولة، فلا يعمل شيء حتى يطلب النتائج شيء مثل collect() أو sum()، وcollect() تحتاج إلى معرفة ما تبنيه، ولذلك يحمل المتغيّر النوع Vec<f64>. أما **p فسببها أن filter تعطي الإغلاق مرجعاً إلى مرجع، وكل * تتبع واحداً منهما.

الوحدات وpub والماكرو

يُجمَع الكود في وحدات (modules) بـmod، وكل شيء خاص ما لم يُعلَّم بـpub. وuse تُدخل اسماً إلى النطاق مثل import. وتستعمل المسارات ::، فـbilling::with_vat هي الدالة with_vat داخل الوحدة billing.

mod billing {
    pub fn with_vat(amount: f64) -> f64 {
        round2(amount * 1.11)
    }

    fn round2(x: f64) -> f64 {
        // private: only usable inside billing
        (x * 100.0).round() / 100.0
    }
}

use billing::with_vat;

fn main() {
    println!("{}", with_vat(100.0));
    let mut items = vec!["pot", "pan"]; // vec! is a macro that builds a Vec
    items.push("wok");
    let line = format!("{} items", items.len());
    println!("{line}");
}

الأسماء التي تنتهي بـ!، مثل println! وvec! وformat!، هي ماكرو (macros). وهي تولّد كوداً عند الترجمة، وهذا ما يتيح لـprintln! أن تتحقّق من نص التنسيق وتقبل أي عدد من المعاملات. ويمكنك أن تقرأها كاستدعاءات دوال يوسّعها المترجم قبل أن يبني البرنامج.

كيف تراجع كود رست كتبه الذكاء الاصطناعي

أن يُترجَم كود رست الذي كتبه الذكاء الاصطناعي هو الجزء السهل، لأن المترجم يلتقط وحده فئة كاملة من أخطاء الذاكرة. أما ما لا يستطيع الحكم عليه فهو هل يعالج الكود الفشل جيداً وهل يسهل صيانته. لذلك تحقّق من هذه النقاط قبل الدمج:

ما تبحث عنه أولاً حين تراجع كود رست كتبه الذكاء الاصطناعي: unwrap أو expect قد تعني انهياراً عند مُدخل سيئ، فعالج الخطأ؛ clone في كل مكان قد تخفي مشكلة استعارة، فجرّب الاستعارة؛ كتل unsafe تطفئ بعض فحوص المترجم، فاسأل عن السبب واطلب مراجعة؛ Arc Mutex في كل مكان قد تعني حالة مشتركة لم يخطّط لها أحد، فبسّط الملكية؛ let _ = استدعاء قد ترمي خطأ، فعالجه أو سجّله. شغّل cargo clippy وcargo audit مع كل تعديل.

  • unwrap() وexpect() خارج الاختبارات. فكل واحدة منها مكان قد ينهار فيه البرنامج.
  • .clone() في كل سطرين. وهي غالباً علامة على أن الذكاء الاصطناعي تصارع مع مدقّق الاستعارة (borrow checker) ونسخ البيانات ليتجاوزه.
  • كتل unsafe. تطفئ بعض فحوص المترجم، وكل واحدة منها تحتاج إلى سبب واضح ومراجعة دقيقة.
  • Arc<Mutex<...>> حول كل شيء. هي الأداة الصحيحة للبيانات المشتركة بين الخيوط (threads)، لكنها حين تلفّ كل شيء تبطّئ البرنامج وتجعل تسلسله صعب المتابعة.
  • النتائج المتجاهَلة، مثل let _ = save(&order);. فالمترجم ينبّه حين لا تُستعمل Result، بل يقترح let _ = ... لتجاهلها، وهذا يُسكت التنبيه والخطأ معاً.
  • cargo clippy من دون تنبيهات، وcargo fmt ليبدو الكود كما يتوقّعه مطوّرو رست الآخرون.
  • cargo audit، ويُثبَّت بـcargo install cargo-audit، ويفحص الحزم التي تعتمد عليها مقابل قاعدة بيانات تنبيهات RustSec.
  • اختبارات تفهمها. اطلب من الذكاء الاصطناعي أن يشرح أي سطر لا تستطيع قراءته، ثم تحقّق من جوابه في التوثيق.

يزيل رست كثيراً من أخطاء الذاكرة، لكن الأخطاء المنطقية والأسرار المسرّبة وضعف التحقّق من الصلاحيات والحزم الخطرة ما زالت تمرّ. ويشرح مقالنا عن المخاطر الأمنية للكود الذي يكتبه الذكاء الاصطناعي ما تتحقّق منه أبعد من اللغة نفسها، ويشرح دليل البرمجة بالذكاء الاصطناعي (vibe coding) كيف تجهّز تطبيقاً بناه الذكاء الاصطناعي للإطلاق.

أين تتعلّم أكثر

الأسئلة الشائعة

هل تعلّم رست صعب على مطوّري بايثون أو جافاسكريبت؟

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

هل يمكنني استعمال الذكاء الاصطناعي لكتابة رست إن كنت لا أعرف رست؟

يمكنك ذلك، لكنك لن تستطيع الحكم على ما يعطيك. تعلّم ما يكفي لقراءة الكود، وتحقّق من كل unwrap وclone وكتلة unsafe، وشغّل Clippy قبل أن يصل أي شيء إلى بيئة الإنتاج.

ما معنى علامة الاستفهام في رست؟

تُعيد الخطأ إلى المستدعي إن فشلت العملية، وتعطيك القيمة إن نجحت. ولا تعمل إلا في الدوال التي تُعيد Result أو Option.

ما معنى 'a في رست؟

هي علامة مدة حياة (lifetime annotation)، تخبر المترجم كم يبقى المرجع صالحاً مقارنة بغيره، مثلاً أن المرجع المُعاد يأتي من المدخلات. ولا تغيّر ما يفعله البرنامج عند التشغيل.

لماذا يقول مترجم رست إن قيمة قد نُقلت؟

إسناد قيمة مثل String أو تمريرها يعطيها لمالك جديد، فلا يمكن استعمال المتغيّر القديم بعد ذلك. مرّر مرجعاً بـ& إن كانت الدالة تحتاج إلى القراءة فقط، أو انسخ القيمة إن كنت تحتاج فعلاً إلى نسختين.

هل unwrap سيئة في رست؟

هي مقبولة في الاختبارات والتجارب السريعة. أما في كود الإنتاج فكل unwrap مكان قد ينهار فيه البرنامج، لذلك عالج الخطأ بـmatch أو if let أو ?، أو استعمل قيمة افتراضية بـunwrap_or.

تعلّم مع Winners Academy

هذا الجزء الأول من سلسلة عن رست من Winners Academy، التدريب العملي الذي تقدّمه NavyBits للطلاب والخرّيجين الجدد. ودوراتها مبنية على مشاريع حقيقية بإشراف مهندسي NavyBits. ولا توجد دورات قائمة الآن، ومن المتوقّع أن تبدأ دورات جديدة قريباً. زُر صفحة Winners Academy و أرسل لنا رسالة لتعرف متى تبدأ الدورة التالية.

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

أساسيات رست (Rust) لمطوّري بايثون وجافاسكريبت: اقرأ الكود الذي يكتبه لك الذكاء الاصطناعي
Hassan Tabbal 16 نوفمبر 2026
شارك هذا المنشور
راسلنا على واتسابوكيل ذكي يردّ على مدار الساعة
احجز مكالمة مجانية