merging all conflicts

Author: iliakan

1-js/02-first-steps/05-types/article.md

@@ -46,13 +46,23 @@ n = 12.345;
     alert( "not a number" / 2 ); // NaN، چنین تقسیمی اشتباه است
     ```
 
+<<<<<<< HEAD
    هر عملی بر روی `NaN` نتیجه `NaN` خواهد داشت:
+=======
+    `NaN` is sticky. Any further mathematical operation on `NaN` returns `NaN`:
+>>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
 
     ```js run
-    alert( "not a number" / 2 + 5 ); // NaN
+    alert( NaN + 1 ); // NaN
+    alert( 3 * NaN ); // NaN
+    alert( "not a number" / 2 - 1 ); // NaN
     ```
 
+<<<<<<< HEAD
     در نتیجه اگر `NaN` در عملیات ریاضیاتی‌ای وجود داشته باشد، بر روی تمام معادله تاثیر می‌گذارد (نتیجه معادله برابر `NaN` خواهد بود).
+=======
+    So, if there's a `NaN` somewhere in a mathematical expression, it propagates to the whole result (there's only one exception to that: `NaN ** 0` is `1`).
+>>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
 
 ```smart header="عملیات ریاضیاتی امن هستند"
 عملیات ریاضی در جاوااسکریپت امن است. ما هر نوع عملی می‌توانیم انجام دهیم مانند تقسیم بر صفر، رفتار کردن با رشته‌های غیر عددی همانند اعداد و غیره.

1-js/02-first-steps/12-nullish-coalescing-operator/article.md

@@ -106,7 +106,11 @@ alert(height ?? 100); // 0
 
 ## اولویت
 
+<<<<<<< HEAD
 اولویت عملگر `??` تقریبا برابر با عملگر `||` است، اما کمتر. اولویت آن در [جدول MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table) برابر با `5` است، در حالی که اولویت `||` برابر با `6` است.
+=======
+The precedence of the `??` operator is the same as `||`. They both equal `4` in the [MDN table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table).
+>>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
 
 این یعنی که درست مانند `||`، عملگر nullish coalescing `??` قبل از `=` و `?` ارزیابی می‌شود، اما بعد از بیشتر عملیات‌ها مانند `+`، `-` ارزیابی می‌شود.
 

1-js/02-first-steps/16-function-expressions/article.md

@@ -12,7 +12,11 @@ function sayHi() {
 
 یک سینتکس دیگر هم برای ساخت تابع وجود دارد که *Function Expression* نامیده می‌شود.
 
+<<<<<<< HEAD
 این سینتکس به ما این امکان را می‌دهد که بین هر عبارتی یک تابع جدید بسازیم.
+=======
+It allows us to create a new function in the middle of any expression.
+>>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
 
 برای مثال:
 

1-js/02-first-steps/17-arrow-functions-basics/article.md

@@ -33,7 +33,11 @@ let sum = function(a, b) {
 alert(sum(1, 2)); // 3
 ```
 
+<<<<<<< HEAD
 همانطور که می‌بینید `(a, b) => a + b` بدین معنی‌ست که این تابع دو آرگومان با نام‌های `a` و `b` می‌پذیرد. و هنگام اجرا شدن، مقدار `a + b` را حساب می‌کند و نتیجه را برمی‌گرداند.
+=======
+As you can see, `(a, b) => a + b` means a function that accepts two arguments named `a` and `b`. Upon the execution, it evaluates the expression `a + b` and returns the result.
+>>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
 
 - اگر فقط یک آرگومان داشته باشیم می‌توانیم پرانتزهای دور آرگومان را حذف کنیم و کد را از این هم کوتاه‌تر کنیم.
 
@@ -84,7 +88,11 @@ welcome();
 let sum = (a, b) => {  // کمانک یک تابع چندخظی را دربرمی‌گیرد
   let result = a + b;
 *!*
+<<<<<<< HEAD
   return result; // اگر از کمانک استفاده کنیم باید از return استفاده کنیم
+=======
+  return result; // if we use curly braces, then we need an explicit "return"
+>>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
 */!*
 };
 

1-js/04-object-basics/04-object-methods/8-chain-calls/_js.view/solution.js

@@ -11,5 +11,6 @@ let ladder = {
   },
   showStep: function() { 
     alert(this.step);
+    return this;
   }
 };

1-js/04-object-basics/04-object-methods/8-chain-calls/_js.view/test.js

@@ -32,6 +32,14 @@ describe('Ladder', function() {
   it('down().up().up().up() ', function() {
     assert.equal(ladder.down().up().up().up().step, 2);
   });
+
+  it('showStep() should return this', function() {
+    assert.equal(ladder.showStep(), ladder);
+  });
+ 
+  it('up().up().down().showStep().down().showStep()', function () {
+    assert.equal(ladder.up().up().down().showStep().down().showStep().step, 0)
+  });
 
   after(function() {
     ladder.step = 0;

1-js/04-object-basics/07-optional-chaining/article.md

@@ -25,7 +25,11 @@ alert(user.address.street); // !خطا
 
 ولی  در بسیاری از موارد عملی، ما ترجیح می‌دهیم به جای خطا، ‍`undefined` را دریافت کنیم (به معنای "بدون خیابان").
 
+<<<<<<< HEAD
 ...و مثالی دیگر، در توسعه وب، ما می‌توانیم یک شیء که با یک المان در صفحه مطابقت دارد را با استفاده از یک متد خاص، مانند `document.querySelector('.elem')` بگیریم و این متد هنگامی که چنین المانی وجود نداشته باشد `null` را برمی‌گرداند:
+=======
+...and another example. In Web development, we can get an object that corresponds to a web page element using a special method call, such as `document.querySelector('.elem')`, and it returns `null` when there's no such element.
+>>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
 
 ```js run
 // document.querySelector('.elem') خواهد شد اگر المنت وجود نداشته باشد null برابر با

1-js/05-data-types/10-destructuring-assignment/article.md

@@ -5,9 +5,13 @@
 - شیءها به ما این امکان را می‌دهند تا چیزی بسازیم که المان‌های داده را به واسطه کلید ذخیره کند.
 - آرایه‌ها به ما امکان جمع‌آوری المان‌های داده را در لیستی مرتب می‌دهند.
 
+<<<<<<< HEAD
 اگرچه، زمانی که ما آنها را به تابع می‌دهیم، ممکن است که نیازی به کل یک شیء/آرایه نباشد. ممکن است تنها قطعه‌های تکی نیاز باشد.
 
 *مقداردهیِ تجزیه‌کننده‌ی ساختار (Destructuring assignment)* یک سینتکس خاص است که به ما امکان می‌دهد تا آرایه‌ها یا شیءها را درون چند متغیر «پخش کنیم» چون بعضی اوقات این موضوع کار را راحت‌تر می‌کند.
+=======
+Although, when we pass those to a function, it may need not be an object/array as a whole. It may need individual pieces.
+>>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
 
 تخریب ساختار همچنین با تابع‌های پیچیده که تعداد زیادی پارامتر، مقدارهای پیش‌فرض و... دارند هم به خوبی کار می‌کند. به زودی آن را خواهیم دید.
 

1-js/11-async/01-callbacks/article.md

@@ -164,8 +164,14 @@ loadScript("/my/script.js", function(error, script) {
 
 ## هرم عذاب
 
+<<<<<<< HEAD
 در نگاه اول این روش برای نوشتن کدهای ناهمگام پایدار بنظر میرسد. که واقعا هم این چنین است ولی برای نهایتا یک یا دو فراخوان تودرتو!!
 اما برای چندین عمل ناهمگام که یکی پس از دیگری اتفاق میفتد چیزی شبیه به این خواهیم داشت:
+=======
+At first glance, it looks like a viable approach to asynchronous coding. And indeed it is. For one or maybe two nested calls it looks fine.
+
+But for multiple asynchronous actions that follow one after another, we'll have code like this:
+>>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
 
 ```js
 loadScript("1.js", function(error, script) {
@@ -197,7 +203,16 @@ loadScript("1.js", function(error, script) {
 2. `2.js`را بارگذاری میکنیم سپس  اگر خطایی نداشت
 3. `3.js` را بارگذاری میکنیم سپس  اگر خطایی نداشت  -- کار دیگری انجام میدهیم`(*)`
 
+<<<<<<< HEAD
 هرچقدر فراخوانی های ما تودرتو باشند کدهای مارا عمیقتر و غیرقابل فهم و مدیریت میکنند مخصوصا اگر به جای ... ها کدهای واقعی داشته باشیم که خود شامل حلقه ها و شرط ها و هر جمله دیگری هستند.
+=======
+In the code above:
+1. We load `1.js`, then if there's no error...
+2. We load `2.js`, then if there's no error...
+3. We load `3.js`, then if there's no error -- do something else `(*)`.
+
+As calls become more nested, the code becomes deeper and increasingly more difficult to manage, especially if we have real code instead of `...` that may include more loops, conditional statements and so on.
+>>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
 
 که معمولا به آن "جهنم فراخوانی" (callback-hell / pyramid of doom) میگویند.
 
@@ -262,7 +277,13 @@ function step3(error, script) {
 ```
 همینجوری که مشاهده میکنید نتیجه تغییری نکرد ولی از تودرتو بودن فراخوانی ها با تعریف کردن توابع به صورت جداگانه برای هر مرحله از تودرتو بودن عمیق جلوگیری کردیم.
 
+<<<<<<< HEAD
 این روش کار میکند ولی کدش تکه تکه و جدا از هم است که خواندن آن را سخت میکند. همانطور که احتمالا دیدید لازم است در حین خواندن از جایی به جای دیگر بپرید. این طور اصلا راحت نیست مخصوصا اگر به کد آشنا نباشید و ندانید باید برای ادامه کد کجا را بخوانید.
+=======
+See? It does the same thing, and there's no deep nesting now because we made every action a separate top-level function.
+
+It works, but the code looks like a torn apart spreadsheet. It's difficult to read, and you probably noticed that one needs to eye-jump between pieces while reading it. That's inconvenient, especially if the reader is not familiar with the code and doesn't know where to eye-jump.
+>>>>>>> bae0ef44d0208506f6e9b7f3421ee640ab41af2b
 
 همچنین توابعِ `step*` فقط یکبار استفاده میشوند و فقط برای جلوگیری از بوجود امدن جهنم فراخوانی و تودرتویی بیش از حد تعریف شده اند که باعث بی نظمی زیادی در کد میشوند.
 

1-js/11-async/03-promise-chaining/article.md

@@ -120,7 +120,7 @@ new Promise(function(resolve, reject) {
 });
 ```
 
-Here the first `.then` shows `1` and returns `new Promise(…)` in the line `(*)`. After one second it resolves, and the result (the argument of `resolve`, here it's `result * 2`) is passed on to handler of the second `.then`. That handler is in the line `(**)`, it shows `2` and does the same thing.
+Here the first `.then` shows `1` and returns `new Promise(…)` in the line `(*)`. After one second it resolves, and the result (the argument of `resolve`, here it's `result * 2`) is passed on to the handler of the second `.then`. That handler is in the line `(**)`, it shows `2` and does the same thing.
 
 So the output is the same as in the previous example: 1 -> 2 -> 4, but now with 1 second delay between `alert` calls.