Merge pull request #173 from mahdiHashemi14/master

Translate tasks of Prototypal Inheritance

Author: mahdyar

1-js/08-prototypes/01-prototype-inheritance/1-property-after-delete/solution.md

@@ -1,4 +1,4 @@
 
-1. `true`, taken from `rabbit`.
-2. `null`, taken from `animal`.
-3. `undefined`, there's no such property any more.
+1. مقدار `true`، از `rabbit` گرفته شده.
+2. مقدار `null`، از `animal` گرفته شده.
+3. مقدار `undefined`، چنین ویژگی‌ای دیگر وجود ندارد.

1-js/08-prototypes/01-prototype-inheritance/1-property-after-delete/task.md

@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Working with prototype
+# کار کردن با پروتوتایپ
 
-Here's the code that creates a pair of objects, then modifies them.
+اینجا کدی داریم که یک جفت از شیءها را ایجاد می‌کند و سپس آن‌ها را تغییر می‌دهد.
 
-Which values are shown in the process?
+کدام مقدار در فرایند نمایش داده می‌شود؟
 
 ```js
 let animal = {
@@ -28,4 +28,4 @@ delete animal.jumps;
 alert( rabbit.jumps ); // ? (3)
 ```
 
-There should be 3 answers.
+باید 3 جواب وجود داشته باشد.

1-js/08-prototypes/01-prototype-inheritance/2-search-algorithm/solution.md

@@ -1,5 +1,5 @@
 
-1. Let's add `__proto__`:
+1. بیایید `__proto__` را اضافه کنیم:
 
     ```js run
     let head = {
@@ -27,6 +27,6 @@
     alert( table.money ); // undefined
     ```
 
-2. In modern engines, performance-wise, there's no difference whether we take a property from an object or its prototype. They remember where the property was found and reuse it in the next request.
+2. در موتورهای مدرن، که از لحاظ عملکرد هوشمند هستند، تفاوتی بین اینکه ما ویژگی‌ای را از شیء یا پروتوتایپ آن دریافت کنیم وجود ندارد. آن‌ها جایی که ویژگی پیدا شد را به خاطر می‌سپارند و در درخواست بعدی از آن استفاده می‌کنند.
 
-    For instance, for `pockets.glasses` they remember where they found `glasses` (in `head`), and next time will search right there. They are also smart enough to update internal caches if something changes, so that optimization is safe.
+    برای مثال، برای `pockets.glasses` آن‌ها جایی که `glasses` را پیدا کردند (درون `head`) را به خاطر می‌سپارند و دفعه بعدی دقیقا همانجا را جست و جو می‌کند. همچنین آن‌ها به اندازه‌ای هوشمند هستند که اگر چیزی تغییر کند، کش‌های داخلی را بروزرسانی کنند تا بهینه‌سازی ایمن باشد.

1-js/08-prototypes/01-prototype-inheritance/2-search-algorithm/task.md

@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Searching algorithm
+# الگوریتم جست و جو
 
-The task has two parts.
+این تمرین دو بخش دارد.
 
-Given the following objects:
+شیءهای زیر داده شده‌اند:
 
 ```js
 let head = {
@@ -27,5 +27,5 @@ let pockets = {
 };
 ```
 
-1. Use `__proto__` to assign prototypes in a way that any property lookup will follow the path: `pockets` -> `bed` -> `table` -> `head`. For instance, `pockets.pen` should be `3` (found in `table`), and `bed.glasses` should be `1` (found in `head`).
-2. Answer the question: is it faster to get `glasses` as `pockets.glasses` or `head.glasses`? Benchmark if needed.
+1. از `__proto__` برای مقداردهی پروتوتایپ‌ها استفاده کنید به طوری که جست و جوی هر ویژگی این مسیر را دنبال کند: `pockets` -> `bed` -> `table` -> `head`. برای مثال، `pockets.pen` باید `3` باشد (در `table` پیدا شد) و `bed.glasses` باید `1` باشد (در `head` پیدا شد).
+2. این سوال را جواب دهید: دریافت `glasses` به صورت `pockets.glasses` سریع‌تر است یا `head.glasses`؟ اگر نیاز بود بنچمارک انجام دهید.

1-js/08-prototypes/01-prototype-inheritance/3-proto-and-this/solution.md

@@ -1,7 +1,7 @@
-**The answer: `rabbit`.**
+**جواب: `rabbit`.**
 
-That's because `this` is an object before the dot, so `rabbit.eat()` modifies `rabbit`.
+به این دلیل که `this` برابر با شیء قبل از نقطه است پس `rabbit.eat()` شیء `rabbit` را تغییر می‌دهد.
 
-Property lookup and execution are two different things.
+جست و جوی ویژگی و اجرا کردن دو موضوع جدا هستند.
 
-The method `rabbit.eat` is first found in the prototype, then executed with `this=rabbit`.
+متد `rabbit.eat` ابتدا در پروتوتایپ پیدا شد سپس با `this=rabbit` اجرا شد.

1-js/08-prototypes/01-prototype-inheritance/3-proto-and-this/task.md

@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Where does it write?
+# کجا می‌نویسد؟
 
-We have `rabbit` inheriting from `animal`.
+ما `rabbit` را داریم که از `animal` ارث‌بری می‌کند.
 
-If we call `rabbit.eat()`, which object receives the `full` property: `animal` or `rabbit`? 
+اگر ما `rabbit.eat()` را فراخوانی کنیم، کدام شیء ویژگی `full` را دریافت می‌کند: `animal` یا `rabbit`؟
 
 ```js
 let animal = {

1-js/08-prototypes/01-prototype-inheritance/4-hamster-proto/solution.md

@@ -1,26 +1,26 @@
-Let's look carefully at what's going on in the call `speedy.eat("apple")`.
+بیایید با دقت نگاه کنیم که در فراخوانی `speedy.eat("سیب")` چه اتفاقی می‌افتد.
 
-1. The method `speedy.eat` is found in the prototype (`=hamster`), then executed with `this=speedy` (the object before the dot).
+1. متد `speedy.eat` درون پروتوتایپ (`=hamster`) پیدا شده، سپس با `this=speedy` اجرا می‌شود (شیء قبل از نقطه).
 
-2. Then `this.stomach.push()` needs to find `stomach` property and call `push` on it. It looks for `stomach` in `this` (`=speedy`), but nothing found.
+2. سپس `this.stomach.push()` باید ویژگی `stomach` را پیدا کند و `push` را روی آن فراخوانی کند. به نظر می‌رسد این متد درون `this` (`=speedy`) به دنبال `stomach` می‌گردد، اما چیزی پیدا نشد.
 
-3. Then it follows the prototype chain and finds `stomach` in `hamster`.
+3. سپس زنجیره پروتوتایپ را دنبال می‌کند و `stomach` را درون `hamster` پیدا می‌کند.
 
-4. Then it calls `push` on it, adding the food into *the stomach of the prototype*.
+4. سپس `push` را روی آن فراخوانی می‌کند، که غذا را به *stomach درون پروتوتایپ* اضافه می‌کند.
 
-So all hamsters share a single stomach!
+پس تمام همسترها شکم (stomach) یکسانی را به اشتراک می‌گذارند!
 
-Both for `lazy.stomach.push(...)` and `speedy.stomach.push()`, the property `stomach` is found in the prototype (as it's not in the object itself), then the new data is pushed into it.
+هم برای `lazy.stomach.push(...)` و `speedy.stomach.push()`، ویژگی `stomach` درون پروتوتایپ پیدا شده است (چون درون خود شیء وجود ندارد)، سپس داده جدید به داخل آن فرستاده می‌شود.
 
-Please note that such thing doesn't happen in case of a simple assignment `this.stomach=`:
+لطفا توجه کنید که در صورت وجود یک مقداردهی ساده `this.stomach=` چنین چیزی اتفاق نمی‌افتد:
 
 ```js run
 let hamster = {
   stomach: [],
 
   eat(food) {
 *!*
-    // assign to this.stomach instead of this.stomach.push
+    // this.stomach.push به جای this.stomach برابر قرار دادن با
     this.stomach = [food];
 */!*
   }
@@ -34,17 +34,17 @@ let lazy = {
   __proto__: hamster
 };
 
-// Speedy one found the food
-speedy.eat("apple");
-alert( speedy.stomach ); // apple
+// غذا را پیدا کرد Speedy همستر
+speedy.eat("سیب");
+alert( speedy.stomach ); // سیب
 
-// Lazy one's stomach is empty
-alert( lazy.stomach ); // <nothing>
+// خالی است Lazy شکم همستر
+alert( lazy.stomach ); // <هیچی>
 ```
 
-Now all works fine, because `this.stomach=` does not perform a lookup of `stomach`. The value is written directly into `this` object.
+حالا همه چیز به درستی کار می‌کند، چون `this.stomach=` در جست و جوی `stomach` نیست. مقدار به صورت مستقیم درون شیء `this` نوشته می‌شود.
 
-Also we can totally avoid the problem by making sure that each hamster has their own stomach:
+همچنین می‌توانیم با اطمینان از اینکه هر همستر stomach خودش را دارا می‌باشد از این مشکل جلوگیری کنیم:
 
 ```js run
 let hamster = {
@@ -69,12 +69,12 @@ let lazy = {
 */!*
 };
 
-// Speedy one found the food
-speedy.eat("apple");
-alert( speedy.stomach ); // apple
+// غذا را پیدا کرد Speedy همستر
+speedy.eat("سیب");
+alert( speedy.stomach ); // سیب
 
-// Lazy one's stomach is empty
-alert( lazy.stomach ); // <nothing>
+// خالی است Lazy شکم همستر
+alert( lazy.stomach ); // <هیچی>
 ```
 
-As a common solution, all properties that describe the state of a particular object, like `stomach` above, should be written into that object. That prevents such problems.
+به عنوان یک راه‌حل عام، تمام ویژگی‌هایی که وضعیت یک شیء خاص را توصیف می‌کنند، مانند `stomach` بالا، باید درون همان شیء نوشته شوند. این کار از بروز مشکلات جلوگیری می‌کند.

1-js/08-prototypes/01-prototype-inheritance/4-hamster-proto/task.md

@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Why are both hamsters full?
+# چرا هر دو دو همستر سیر هستند؟
+ 
+ما دو همستر داریم: `speedy` و `lazy` که از شیء عمومی `hamster` ارث‌بری می‌کنند.
 
-We have two hamsters: `speedy` and `lazy` inheriting from the general `hamster` object. 
-
-When we feed one of them, the other one is also full. Why? How can we fix it?
+زمانی که ما به یکی از آن‌ها غذا می‌دهیم، دیگری هم سیر می‌شود. چرا؟ چگونه می‌توانیم این مشکل را رفع کنیم؟
 
 ```js run
 let hamster = {
@@ -25,11 +25,11 @@ let lazy = {
   __proto__: hamster
 };
 
-// This one found the food
-speedy.eat("apple");
-alert( speedy.stomach ); // apple
+// این همستر غذا را پیدا کرد
+speedy.eat("سیب");
+alert( speedy.stomach ); // سیب
 
-// This one also has it, why? fix please.
-alert( lazy.stomach ); // apple
+// این همستر هم غذا را دارد، چرا؟ لطفا این را درست کنید.
+alert( lazy.stomach ); // سیب
 ```