Merge pull request #287 from afilahkle/master

 Variable scope, closure

Author: afilahkle

1-js/06-advanced-functions/03-closure/10-make-army/solution.md

@@ -1,12 +1,12 @@
-Let's examine what exactly happens inside `makeArmy`, and the solution will become obvious.
+دعنا نفحص ما يحدث بالضبط داخل `makeArmy`، وسيصبح الحل واضحًا.
 
 1. تُنشئ مصفوفة `‎shooters‎` فارغة:
 
-   ```js
+   ````js
    let shooters = [];
    ```
 
-2. Fills it with functions via `shooters.push(function)` in the loop.
+2. يتم ملؤها بالدوال باستخدام `shooters.push(function)` في الحلقة.
 
    ```js no-beautify
    shooters = [
@@ -43,17 +43,17 @@ Let's examine what exactly happens inside `makeArmy`, and the solution will beco
    ];
    ```
 
-3. The array is returned from the function.
+3. يتم إرجاع المصفوفة من الدالة.
 
-   Then, later, the call to any member, e.g. `army[5]()` will get the element `army[5]` from the array (which is a function) and calls it.
+   ثم في وقت لاحق، سيتم استدعاء أي عضو، على سبيل المثال `army[5]()`، وسيتم الحصول على العنصر `army[5]` من المصفوفة (وهو دالة) ويتم استدعاؤها.
 
-   Now why do all such functions show the same value, `10`?
+   السؤال هو لماذا تظهر لجميع الدوال نفس القيمة، وهي الرقم `10`؟
 
-   That's because there's no local variable `i` inside `shooter` functions. When such a function is called, it takes `i` from its outer lexical environment.
+   يحدث ذلك لأنه لا يوجد متغير محلي بإسم `i` داخل دوال `shooter`. عند استدعاء مثل هذه الدالة، فإنه يتم أخذ `i` من البيئة اللغوية الخارجية.
 
-   Then, what will be the value of `i`?
+   إذاً، ماهي قيمة `i`؟
 
-   If we look at the source:
+   إذا نظرنا إلى الشفرة المصدرية:
 
    ```js
    function makeArmy() {
@@ -70,13 +70,13 @@ Let's examine what exactly happens inside `makeArmy`, and the solution will beco
    }
    ```
 
-   We can see that all `shooter` functions are created in the lexical environment of `makeArmy()` function. But when `army[5]()` is called, `makeArmy` has already finished its job, and the final value of `i` is `10` (`while` stops at `i=10`).
-
-   As the result, all `shooter` functions get the same value from the outer lexical environment and that is, the last value, `i=10`.
+   يمكننا ملاحظة أن جميع دوال `shooter` يتم إنشاؤها في البيئة اللغوية الخارجية لدالة `makeArmy()`، لكن عندما يتم استدعاء `army[5]()`، فقدانتهت دالة `makeArmy` من عملها وأصبحت قيمة `i` هي الأخيرة وهي `10` (حيث يتوقف الحلقة عند `i=10`)، 
+   
+   وبالتالي، جميع دوال `shooter` ستحصل على نفس القيمة من البيئة اللغوية الخارجية وهي القيمة الأخيرة `i=10`.
 
    ![](lexenv-makearmy-empty.svg)
 
-   As you can see above, on each iteration of a `while {...}` block, a new lexical environment is created. So, to fix this, we can copy the value of `i` into a variable within the `while {...}` block, like this:
+   كما ترون في الصورة أعلاه، في كل تكرار لكتلة `while {...}` يتم إنشاء بيئة لغوية جديدة. لحل هذه المشكلة، يمكننا نسخ قيمة `i` في متغير داخل كتلة `while {...}`، مثل هذا:
 
    ```js run
    function makeArmy() {
@@ -99,18 +99,18 @@ Let's examine what exactly happens inside `makeArmy`, and the solution will beco
 
    let army = makeArmy();
 
-   // Now the code works correctly
+   // الآن يعمل الكود بشكل صحيح
    army[0](); // 0
    army[5](); // 5
    ```
 
-   Here `let j = i` declares an "iteration-local" variable `j` and copies `i` into it. Primitives are copied "by value", so we actually get an independent copy of `i`, belonging to the current loop iteration.
+   هنا `let j = i` يعلن عن متغير "محلي للتكرار" `j` ويقوم بنسخ `i` فيه. القيم الأساسية تنسخ "بالقيمة"، لذلك نحصل فعليًا على نسخة مستقلة من `i` تنتمي إلى تكرار الحلقة الحالي.
 
-   The shooters work correctly, because the value of `i` now lives a little bit closer. Not in `makeArmy()` Lexical Environment, but in the Lexical Environment that corresponds the current loop iteration:
+   يعمل الدوال `shooter` بشكل صحيح، لأن قيمة `i` تعيش الآن قليلاً أقرب. ليس في بيئة اللغة الخارجية لـ `makeArmy()`، ولكنفي البيئة اللغوية الخارجية التي تتوافق مع التكرار الحالي:
 
    ![](lexenv-makearmy-while-fixed.svg)
 
-   Such problem could also be avoided if we used `for` in the beginning, like this:
+   كما يمكن تجنب مشكلة من هذا النوع إذا استخدمنا `for` في البداية، مثل هذا:
 
    ```js run demo
    function makeArmy() {
@@ -135,12 +135,12 @@ Let's examine what exactly happens inside `makeArmy`, and the solution will beco
    army[5](); // 5
    ```
 
-   That's essentially the same, because `for` on each iteration generates a new lexical environment, with its own variable `i`. So `shooter` generated in every iteration references its own `i`, from that very iteration.
+   هذا بشكل أساسي نفس الأمر، لأن `for` في كل تكرار ينشئ بيئة لغوية جديدة، مع متغير `i` الخاص به. لذلك تشير الدالة التي تم إنشاؤها في كل تكرار إلى `i` الخاص بها، من تلك التكرار.
 
    ![](lexenv-makearmy-for-fixed.svg)
 
-Now, as you've put so much effort into reading this, and the final recipe is so simple - just use `for`, you may wonder -- was it worth that?
+الآن، بعد أن قدمنا جهدًا كبيرًا في قراءة هذا الحل، وأن الوصفة النهائية هي بسيطة - استخدم `for` - قد تتساءل: هل كان ذلك يستحق كل هذا العناء؟
 
-Well, if you could easily answer the question, you wouldn't read the solution. So, hopefully this task must have helped you to understand things a bit better.
+حسنًا، إذا كان بإمكانك الإجابة على السؤال بسهولة، فلن تقرأ الحل. لذلك، نأمل أن يكون قد ساعدك هذا السؤال على فهم الأمور بشكل أفضل.
 
-Besides, there are indeed cases when one prefers `while` to `for`, and other scenarios, where such problems are real.
+بالإضافة إلى ذلك، ه

1-js/06-advanced-functions/03-closure/10-make-army/task.md

@@ -35,6 +35,6 @@ army[2](); // 10 ...and so on.
 */!*
 ```
 
-Why do all of the shooters show the same value?
+لماذا يظهر لكل من المدفعين الرقم نفسه؟
 
-Fix the code so that they work as intended.
+قم بإصلاح الكود حتى يعمل كما هو مفترض به.

1-js/06-advanced-functions/03-closure/article.md

@@ -1,16 +1,15 @@
-# نطاق المُتغير
 
-# Variable scope, closure
+# نطاق المتغيرات، الإغلاق
 
-JavaScript is a very function-oriented language. It gives us a lot of freedom. A function can be created at any moment, passed as an argument to another function, and then called from a totally different place of code later.
+جافا سكريبت هي لغة موجهة نحو الدوال. تمنحنا اللغة حرية كبيرة، حيث يمكن إنشاء دالة في أي وقت، وإرسالها كوسيط لدالة أخرى ومن ثم استدعائها من مكان مختلف في الكود لاحقًا.
 
-We already know that a function can access variables outside of it ("outer" variables).
+نحن بالفعل نعلم أن الدالة يمكنها الوصول إلى المتغيرات الخارجية منها ("المتغيرات الخارجية").
 
-But what happens if outer variables change since a function is created? Will the function get newer values or the old ones?
+ولكن ماذا يحدث إذا تغيرت المتغيرات الخارجية بعد إنشاء الدالة؟ هل ستحصل الدالة على القيم الأحدث أم القيم القديمة؟
 
-And what if a function is passed along as a parameter and called from another place of code, will it get access to outer variables at the new place?
+وماذا إذا تم تمرير دالة كمعلمة واستدعاؤها من مكان آخر في الكود؟ هل ستحصل الدالة على وصول إلى المتغيرات الخارجية في المكان الجديد؟
 
-Let's expand our knowledge to understand these scenarios and more complex ones.
+دعنا نوسع معرفتنا لفهم هذه السيناريوهات والسيناريوهات الأكثر تعقيدًا.
 
 سنتحدث عن المُتغيرات `let/const` هنا
 
@@ -203,11 +202,11 @@ alert(counter()); // 2
 
 # بسيط حتّى الآن، أم لا؟
 
-1. When the script starts, the Lexical Environment is pre-populated with all declared variables.
-   - Initially, they are in the "Uninitialized" state. That's a special internal state, it means that the engine knows about the variable, but it cannot be referenced until it has been declared with `let`. It's almost the same as if the variable didn't exist.
-2. Then `let phrase` definition appears. There's no assignment yet, so its value is `undefined`. We can use the variable from this point forward.
-3. `phrase` is assigned a value.
-4. `phrase` changes the value.
+1. عند بدء تشغيل البرنامج، تمتلئ البيئة اللغوية (Lexical Environment) مسبقًا بجميع المتغيرات المعلنة.
+- في البداية، تكون المتغيرات في الحالة "Uninitialized". هذه حالة داخلية خاصة، وتعني أن المحرك يعرف المتغير، ولكن لا يمكن الإشارة إليه حتى يتم تعريفه بـ `let`. إنها تقريبًا نفس الشيء كما لو أن المتغير لم يكن موجودًا.
+2. ثم يظهر تعريف `let phrase`. لا يوجد تعيين حتى الآن، لذلك قيمتها هي `undefined`. يمكننا استخدام المتغير من هذه النقطة فصاعدًا.
+3. يتم تعييين قيمة `phrase`.
+4. تتغير قيمة `phrase`.
 
 - المتغير هو فعليًا خاصية لإحدى الكائنات الداخلية الخاصة، وهذا الكائن مرتبط بالكتلة أو الدالة أو السكربت الذي يجري تنفيذه حاليًا.
 - حين نعمل مع المتغيرات نكون في الواقع نعمل مع خصائص ذلك الكائن.
@@ -310,10 +309,7 @@ let counter = makeCounter();
 
 ![](closure-makecounter-nested-call.svg)
 
-# الأن عندما يبدأ الكود في البحث عن المتغير `count` داخل الدالة `counter()`, يبحث أولاً في البيئة المعجمية الخاصة به وإذا كانت فارفة يبحث في البيئة المعجمية الخارجية, ثم الخارج ثم الخارج حتي يجده.
-
-Now when the code inside `counter()` looks for `count` variable, it first searches its own Lexical Environment (empty, as there are no local variables there), then the Lexical Environment of the outer `makeCounter()` call, where it finds and changes it.
-
+الآن عندما يبحث الكود داخل `counter()` عن متغير `count` ، يبحث أولاً في بيئته اللغوية الخاصة (التي تكون فارغة ، لأنه لا توجد متغيرات محلية هناك) ، ثم في بيئة `makeCounter()` الخارجية التي يتم استدعاؤها منها، حيث يجد المتغير ويقوم بتغييره.
 ** المتغير تم تعديله في البيئة المعجمية حيث يعيش.**
 
 ها هي الحالة بعد التنفيذ:
@@ -337,9 +333,9 @@ A [المنغلقات](https://en.wikipedia.org/wiki/Closure_(computer_programmi
 
 عادةً ما تُمسح وتُحذف البيئة المُعجمية بعدما تعمل الدالة
 
-However, if there's a nested function that is still reachable after the end of a function, then it has `[[Environment]]` property that references the lexical environment.
+ومع ذلك، إذا كان هناك دالة متداخلة يمكن الوصول إليها بعد انتهاء الدالة الأصلية، فإن لديها خاصية `[[Environment]]` التي تشير إلى البيئة اللغوية.
 
-In that case the Lexical Environment is still reachable even after the completion of the function, so it stays alive.
+في هذه الحالة، يمكن الوصول إلى البيئة اللغوية حتى بعد اكتمال الدالة، لذلك تبقى حية.
 
 مثال:
 
@@ -356,7 +352,7 @@ let g = f(); // g.[[Environment]] stores a reference to the Lexical Environment
 // of the corresponding f() call
 ```
 
-Please note that if `f()` is called many times, and resulting functions are saved, then all corresponding Lexical Environment objects will also be retained in memory. In the code below, all 3 of them:
+يرجى ملاحظة أنه إذا تم استدعاء `f()` العديد من المرات، وتم حفظ الدوال الناتجة، فسيتم الإحتفاظ بجميع كائنات البيئة اللغوية المقابلة في الذاكرة. في الكود أدناه، سيتم الإحتفاظ بجميع الكائنات اللغوية الثلاثة:
 
 ```js
 function f() {
@@ -395,7 +391,6 @@ g = null; // ...والآن لم تعد كذلك ونكون قد نظّفنا ا
 
 كما رأينا، فنظريًا طالما الدالة «حيّة تُرزق» تبقى معها كل متغيراتها الخارجية.
 
-**An important side effect in V8 (Chrome, Edge, Opera) is that such variable will become unavailable in debugging.**
 
 **ثمّة -في محرّك V8 (كروم وأوبرا)- تأثير مهمّ ألا وهو أنّ هذا المتغير لن يكون مُتاحًا أثناء التنقيح.**
 
@@ -439,6 +434,6 @@ let g = f();
 g();
 ```
 
-This feature of V8 is good to know. If you are debugging with Chrome/Edge/Opera, sooner or later you will meet it.
+هذه الميزة في V8 جيدة للمعرفة. إذا كنت تقوم بتصحيح الأخطاء باستخدام Chrome / Edge / Opera ، في وقت ما ستواجه هذه الميزة.
 
-That is not a bug in the debugger, but rather a special feature of V8. Perhaps it will be changed sometime. You can always check for it by running the examples on this page.
+لا يعتبر هذا خطأ في مصحح الأخطاء ، بل هو ميزة خاصة في V8. ربما سيتم تغييرها في وقت ما. يمكنك دائمًا التحقق من ذلك عن طريق تشغيل الأمثلة على هذه الصفحة.