Learn Rust Coding · درس

فهم نموذج الملكية في Rust

استوعبوا القواعد الأساسية للملكية ودلالات النقل وكيف تمنع أخطاء الذاكرة الشائعة مثل التحرير المزدوج.

فهم نموذج الملكية في Rust درس مجاني في Learn Rust Coding على CoddyKit. هذا هو الدرس 1 من أصل 3. يمكنك قراءة الدرس كاملاً أدناه مجاناً — ثم تمرن عليه مباشرة في المتصفح باستخدام محرر أكواد مدمج ومدرس ذكاء اصطناعي متاح 24/7. هذا الدرس جزء من مسار التعلم في Learn Rust Coding، وتقدمك يتزامن عبر الويب وتطبيق CoddyKit. تتضمن دورة Learn Rust Coding 3 دروس في المجموع.

ما ملكية Rust؟

إن نظام الملكية في Rust هو مجموعة من القواعد التي تدير كيفية استخدام برنامجك للذاكرة. وهو مفهوم أساسي يساعد Rust على تحقيق أمان الذاكرة من دون جامع للقمامة.

لا توجد مؤشرات معلّقة.
لا توجد أخطاء تحرير مزدوج للذاكرة.
لا توجد حالات تسابق على البيانات في التعليمات البرمجية المتزامنة.

يتحقق Rust من هذه القواعد أثناء الترجمة!

ذاكرة المكدس مقابل ذاكرة الكومة

تستخدم البرامج منطقتين رئيسيتين من الذاكرة: المكدس والكومة.

المكدس: بيانات أسرع وثابتة الحجم، مثل الأعداد الصحيحة والقيم المنطقية والأنواع معلومة الحجم. تُضاف البيانات وتُزال بالترتيب.
الكومة: بيانات أبطأ ومتغيرة الحجم، مثل String وVec. يطلب مُخصِّص الذاكرة البيانات ويعيدها.

تدير الملكية بصورة أساسية البيانات الموجودة في الكومة، مما يضمن استخدامها وتحريرها بأمان.

القاعدة 1: لكل قيمة مالك

القاعدة الأولى للملكية بسيطة: لكل قيمة في Rust متغير يُسمى مالكها.

فكّر في الأمر كأنها بطاقة ملصقة على صندوق. المتغير s أدناه هو مالك النص "hello".

fn main() {
  let s = String::from("hello"); // s owns "hello"
  println!("{}", s);
}

القاعدة 2: مالك واحد فقط في كل مرة

تنص القاعدة الثانية على ما يلي: لا يمكن أن يكون للقيمة أكثر من مالك واحد في أي وقت. وهذا أمر بالغ الأهمية لمنع مشكلات الذاكرة.

عند إسناد قيمة معقدة، مثل String الموجودة في الكومة، من متغير إلى آخر، تنتقل الملكية ولا تُنسخ.

انتقال الملكية عمليًا

شاهد ما يحدث عند إسناد قيمة s1 إلى s2. جرّب تشغيل التعليمات البرمجية.

fn main() {
  let s1 = String::from("Hello, CoddyKit!");
  let s2 = s1; // Ownership of the String data moves from s1 to s2

  // println!("{}", s1); // This line would cause a compile-time error!
  println!("{}", s2);
}

فهم دلالات "النقل"

بعد تنفيذ let s2 = s1;، لم يعد s1 صالحًا. يمنعك Rust من استخدام s1 مرة أخرى.

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

يمنع نظام الملكية في Rust حدوث ذلك أثناء الترجمة!

الملكية واستدعاءات الدوال

يماثل تمرير قيمة إلى دالة إسنادها إلى متغير آخر: تنتقل الملكية إلى الدالة.

عند انتهاء الدالة، يخرج مالك القيمة، أي وسيط الدالة، من النطاق، وتُسقط القيمة.

عرض توضيحي لملكية الدوال

لاحظ كيفية نقل قيمة String إلى takes_ownership، ثم كيفية إرجاع gives_ownership قيمة String جديدة.

fn takes_ownership(some_string: String) {
  println!("Inside takes_ownership: {}", some_string);
} // some_string goes out of scope and `drop` is called.

fn gives_ownership() -> String {
  let some_string = String::from("returned string");
  some_string // Ownership is moved out of the function
}

fn main() {
  let s1 = String::from("hello");
  takes_ownership(s1); // s1's value moves into takes_ownership
  // println!("{}", s1); // Error: s1 is no longer valid here!

  let s2 = gives_ownership(); // s2 gets ownership of the returned String
  println!("After gives_ownership: {}", s2);
}

القاعدة 3: النطاق والإسقاط

القاعدة الأخيرة: عندما يخرج المالك من النطاق، تُسقط القيمة.

النطاق هو الجزء من البرنامج الذي تكون فيه قيمة عنصر ما صالحة، ويُحدَّد عادةً بواسطة القوسين المعقوفين {}.
عندما يخرج متغير من النطاق، يستدعي Rust تلقائيًا دالة خاصة تُسمى drop.

يضمن ذلك تنظيف الذاكرة تلقائيًا وبأمان ومن دون جامع للقمامة.

منع أخطاء الذاكرة

تعمل قواعد الملكية معًا لضمان أمان الذاكرة:

مالك واحد: يمنع أجزاء متعددة من التعليمات البرمجية من محاولة تحرير الذاكرة نفسها.
الإسقاط عند انتهاء النطاق: يضمن تحرير الذاكرة مرة واحدة بالضبط وفي الوقت الصحيح.

وهذا يلغي أخطاء شائعة مثل أخطاء التحرير المزدوج للذاكرة وأخطاء الاستخدام بعد التحرير أثناء الترجمة، مما يمنحك راحة البال!

اختبار الملكية

تأمل تعليمات Rust البرمجية التالية. ماذا سيحدث عند محاولة ترجمتها وتشغيلها؟

fn main() {
  let message = String::from("Rust is fun!");
  let greeting = message;
  println!("{}", message);
}

مراجعة: أساسيات الملكية

أحسنت! لقد تعلمت القواعد الأساسية لنظام الملكية في Rust:

لكل قيمة مالك.
لا يمكن أن يكون هناك سوى مالك واحد في كل مرة.
عندما يخرج المالك من النطاق، تُسقط القيمة.

يمنع هذا النظام أخطاء الذاكرة الشائعة من دون جامع للقمامة. سنستكشف بعد ذلك الاستعارة لمشاركة البيانات من دون نقل الملكية.

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

هل درس «فهم نموذج الملكية في Rust» مجاني؟

نعم — نص درس «فهم نموذج الملكية في Rust» كامل متاح مجاناً هنا على الويب. لتمرينه بشكل تفاعلي (محرر أكواد مدمج ومدرس ذكاء اصطناعي متاح 24/7) وفتح باقي دورة Learn Rust Coding، انتقل إلى CoddyKit PRO. تتضمن دورة Learn Rust Coding 3 دروس في المجموع.

ماذا ستتعلم في «فهم نموذج الملكية في Rust»؟

استوعبوا القواعد الأساسية للملكية ودلالات النقل وكيف تمنع أخطاء الذاكرة الشائعة مثل التحرير المزدوج. تتمرن على Learn Rust Coding مع أكواد عملية تشغلها مباشرة في المتصفح، ومدرس ذكاء اصطناعي متاح 24/7 يجيب على أسئلتك أثناء عملك.

هل أحتاج إلى خبرة سابقة لأبدأ Learn Rust Coding؟

لا تُشترط خبرة سابقة. Learn Rust Coding على CoddyKit منظم للمبتدئين حتى المتقدمين، لذا يمكنك البدء من هنا أو من البداية والتقدم بسرعتك الخاصة. هذا هو الدرس 1 من أصل 3.

كم من الوقت يستغرق درس «فهم نموذج الملكية في Rust»؟

معظم دروس CoddyKit تستغرق حوالي 5–10 دقائق. كل منها موجز وتفاعلي، لذا تحرز تقدماً مستمراً وتستأنف من حيث توقفت عبر الويب والتطبيق.

هل يمكنني كتابة وتشغيل أكواد في درس Learn Rust Coding هذا؟

نعم. كل درس في Learn Rust Coding يتضمن محرر أكواد مدمج، لذا تكتب وتشغل أكواداً حقيقية مباشرة في متصفحك وتحصل على تعليقات فورية من الذكاء الاصطناعي — بدون إعداد محلي.

جميع الدروس في هذه الدورة

← العودة إلى Learn Rust Coding