Merge pull request #286 from afilahkle/master

Object references and copying

Author: afilahkle

1-js/04-object-basics/02-object-copy/article.md

@@ -1,65 +1,65 @@
 # Object references and copying
 
-One of the fundamental differences of objects versus primitives is that objects are stored and copied "by reference", whereas primitive values: strings, numbers, booleans, etc -- are always copied "as a whole value".
+أحد الاختلافات الأساسية بين الكائنات والقيم الأساسية هو أن الكائنات تخزن وتنسخ "ضمنيًا" وبالمقابل، يتم نسخ القيم الأساسية بالكامل.
 
-That's easy to understand if we look a bit under the hood of what happens when we copy a value.
+هذا سهل الفهم إذا نظرنا قليلاً تحت الغطاء لما يحدث عند نسخ القيمة.
 
-Let's start with a primitive, such as a string.
+لنبدأ بالقيمة الأساسية، مثل السلسلة.
 
-Here we put a copy of `message` into `phrase`:
+هنا نضع نسخة من `message` في `phrase`:
 
 ```js
 let message = "Hello!";
 let phrase = message;
 ```
 
-As a result we have two independent variables, each one storing the string `"Hello!"`.
+نحن الآن لدينا متغيران مستقلان، يخزن كل منهما السلسانة `"Hello!"`.
 
 ![](variable-copy-value.svg)
 
-Quite an obvious result, right?
+نتيجة واضحة جدًا، أليس كذلك؟
 
-Objects are not like that.
+الكائنات ليست كذلك.
 
-**A variable assigned to an object stores not the object itself, but its "address in memory" -- in other words "a reference" to it.**
+**يخزن المتغير الذي يشير إلى كائن ليس الكائن نفسه، ولكن "عنوانه في الذاكرة" - بعبارة أخرى "مرجعًا" له.**
 
-Let's look at an example of such a variable:
+لنلقي نظرة على مثال لمتغير من هذا النوع:
 
 ```js
 let user = {
     name: "John",
 };
 ```
 
-And here's how it's actually stored in memory:
+وهنا كيف يتم تخزينه في الذاكرة:
 
 ![](variable-contains-reference.svg)
 
-The object is stored somewhere in memory (at the right of the picture), while the `user` variable (at the left) has a "reference" to it.
+يتم تخزين الكائن في مكان ما في الذاكرة (على اليمين من الصورة)، في حين يحتوي المتغير `user` (على اليسار) على "مرجع" إلى هذا المكان.
 
-We may think of an object variable, such as `user`, as like a sheet of paper with the address of the object on it.
+يمكننا التفكير في متغير الكائن، مثل `user`، كورقة ورق بها عنوان الكائن.
 
-When we perform actions with the object, e.g. take a property `user.name`, the JavaScript engine looks at what's at that address and performs the operation on the actual object.
+عندما نقوم بإجراء أي عمليات على الكائن، مثل الوصول إلى خاصية `user.name`، يقوم محرك JavaScript بالنظر إلى ما يوجد في ذلك العنوان وينفذ العملية على الكائن الفعلي.
 
-Now here's why it's important.
+والآن هنا هو السبب في أهمية هذا الأمر.
 
-**When an object variable is copied, the reference is copied, but the object itself is not duplicated.**
+**عند نسخ متغير الكائن ، يتم نسخ المرجع ، ولكن الكائن نفسه لا يتم استنساخه.**
 
-For instance:
+على سبيل المثال:
 
 ```js no-beautify
 let user = { name: "John" };
 
-let admin = user; // ينسخ المؤشر
+let admin = user; // المرجع يتم نسخه
 ```
 
-Now we have two variables, each storing a reference to the same object:
+الآن لدينا متغيران، يخزن كل منهما مرجعًا إلى نفس الكائن نفسه:
 
 ![](variable-copy-reference.svg)
 
-As you can see, there's still one object, but now with two variables that reference it.
+كما يمكن رؤية، لا يوجد سوى كائن واحد، ولكن الآن بوجود متغيرين يشيران إليه.
 
-We can use either variable to access the object and modify its contents:
+يمكننا استخدام أي من المتغيرين للوصول إلى الكائن وتعديل محتوياته:
 
 ```js run
 let user = { name: 'John' };
@@ -73,7 +73,7 @@ admin.name = 'Pete'; // تم تغييرها بواسطة المؤشر "admin"
 alert(*!*user.name*/!*); // 'Pete', التغيرات مرئية بواسطة مؤشر "user"
 ```
 
-It's as if we had a cabinet with two keys and used one of them (`admin`) to get into it and make changes. Then, if we later use another key (`user`), we are still opening the same cabinet and can access the changed contents.
+هذا يعني أنه وكأننا لدينا خزانة بها مفاتيحان واستخدمنا واحدة منهما (`admin`) للوصول إلى المحتويات وإجراء التغييرات، ثم إذا استخدمنا المفتى الأخرى (`user`) في وقت لاحق، فنحن لا نفتح سوى نفس الخزانة ويمكننا الوصول إلى المحتويات المغيرة.
 
 ## المقارنة بالمؤشرات
 
@@ -89,7 +89,7 @@ alert(a == b); // true, كلاهما يشيران لنفس الكائن
 alert(a === b); // true
 ```
 
-And here two independent objects are not equal, even though they look alike (both are empty):
+وهنا لا يتساوى كائنان مستقلان، على الرغم من أنهما يبدوان متشابهين (كلاهما فارغ):
 
 ```js run
 let a = {};
@@ -98,15 +98,15 @@ let b = {}; // كائنان منفصلان
 alert(a == b); // false
 ```
 
-For comparisons like `obj1 > obj2` or for a comparison against a primitive `obj == 5`, objects are converted to primitives. We'll study how object conversions work very soon, but to tell the truth, such comparisons are needed very rarely -- usually they appear as a result of a programming mistake.
+للمقارنات مثل `obj1 > obj2` أو للمقارنة مع قيمة أولية `obj == 5`، يتم تحويل الكائنات إلى قيم أولية. سندرس كيفية عمل تحويلات الكائنات قريبًا جدًا، ولكن لنقل الحقيقة، تحتاج هذه المقارنات نادرًا جدًا - عادة ما تظهر نتيجة خطأ في البرمجة.
 
-## Cloning and merging, Object.assign [#cloning-and-merging-object-assign]
+## استنساخ ودمج، Object.assign [#cloning-and-merging-object-assign]
 
 نسخ المتغير ينشئ مؤشر آخر لنفس الكائن.
 
 لكن ماذا إذا أردنا نسخ الكائن نفسه كنسخة منفصلة ؟
 
-That's also doable, but a little bit more difficult, because there's no built-in method for that in JavaScript. But there is rarely a need -- copying by reference is good most of the time.
+هذا أيضًا قابل للتنفيذ، ولكنه أكثر صعوبة قليلاً، لأنه لا يوجد طريقة مدمجة لذلك في جافا سكريبت. ولكن نادرًا ما يكون هناك حاجة - فالنسخ بالإشارة جيد في معظم الأحيان.
 
 لكن إذا أردنا ذلك حقًا يمكننا فعل ذلك عن طريق عمل كائن آخر والمرور على خواص الكائن الحالي ونسخها واحدة تلو الأخرى.
 
@@ -189,9 +189,9 @@ let clone = Object.assign({}, user);
 
 ## النسخ المتداخل
 
-There are also other methods of cloning an object, e.g. using the [spread syntax](info:rest-parameters-spread) `clone = {...user}`, covered later in the tutorial.
+هناك أيضًا طرق أخرى لاستنساخ كائن، على سبيل المثال باستخدام [spread syntax](info:rest-parameters-spread) `clone = {...user}`، والتي سيتم تغطيتها في وقت لاحق في البرنامج التعليمي.
 
-## Nested cloning
+## النسخ الشامل
 
 مثل هذا:
 
@@ -229,14 +229,14 @@ user.sizes.width++; // تغيير الخاصية من مكان
 alert(clone.sizes.width); // 51, يجعل التغيير مئي في المكان الآخر
 ```
 
-To fix that, we should use a cloning loop that examines each value of `user[key]` and, if it's an object, then replicate its structure as well. That is called a "deep cloning".
+لحل هذه المشكلة، يجب علينا استخدام حلقة نسخ تفحص كل قيمة في `user[key]` وإذا كانت كائنًا، فإنه يتم تكرار هيكله أيضًا. يُسمى ذلك "نسخًا عميقًا".
 
-We can use recursion to implement it. Or, to not reinvent the wheel, take an existing implementation, for instance [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep) from the JavaScript library [lodash](https://lodash.com).
+يمكن استخدام التكرار لتنفيذ نسخة عميقة، أو يمكن استخدام تنفيذ موجود لعدم اختراع العجلة، على سبيل المثال [_.cloneDeep(obj)](https://lodash.com/docs#cloneDeep) من مكتبة JavaScript [lodash](https://lodash.com).
 
-````smart header="Const objects can be modified"
-An important side effect of storing objects as references is that an object declared as `const` *can* be modified.
+````smart header="يمكن تعديل الكائنات التي تم تعريفها بـ const"
+آثار جانبية مهمة لتخزين الكائنات كمراجع هو أنه يمكن تعديل كائن معرف بـ `const`.
 
-For instance:
+على سبيل المثال:
 
 ```js run
 const user = {
@@ -250,16 +250,16 @@ user.name = "Pete"; // (*)
 alert(user.name); // Pete
 ```
 
-It might seem that the line `(*)` would cause an error, but it does not. The value of `user` is constant, it must always reference the same object, but properties of that object are free to change.
+قد يبدو أن السطر `(*)` سيتسبب في حدوث خطأ، ولكن لا يحدث خطأ. قيمة `user` ثابتة، يجب أن يشير دائمًا إلى نفس الكائن، ولكن يمكن تغيير خصائص هذا الكائن.
 
-In other words, the `const user` gives an error only if we try to set `user=...` as a whole.
+بمعنى آخر، يتم إصدار خطأ عند استخدام `const user` فقط إذا حاولنا تعيين `user=...` ككل.
 
-That said, if we really need to make constant object properties, it's also possible, but using totally different methods. We'll mention that in the chapter <info:property-descriptors>.
+ومع ذلك، إذا كنا بحاجة فعلًا إلى جعل خصائص الكائن ثابتة، فمن الممكن ذلك باستخدام طرق مختلفة تمامًا. سنذكر ذلك في الفصل <info:property-descriptors>.
 ````
 
 ## ملخص
 
-Objects are assigned and copied by reference. In other words, a variable stores not the "object value", but a "reference" (address in memory) for the value. So copying such a variable or passing it as a function argument copies that reference, not the object itself.
+الكائنات تتم تعيينها ونسخها بالمرجع. وبمعنى آخر، يخزن المتغير ليس "قيمة الكائن" ولكن "مرجع" (عنوان في الذاكرة) للقيمة. لذلك، عند نسخ هذا المتغير أو تمريره كوسيط لدالة، يتم نسخ هذا المرجع، وليس الكائن نفسه.
 
 كل العمليات التي تتم بواسطة النسخة (مثل إضافة وحذف الخواص) تحدث على نفس الكائن.