merging all conflicts

Author: iliakan

1-js/02-first-steps/03-strict-mode/article.md

@@ -19,7 +19,7 @@ For example:
 ...
 ```
 
-Quite soon we're going to learn functions (a way to group commands) soon, so let's note in advance that `"use strict"` can be put at the beginning of a function. Doing that enables strict mode in that function only. But usually people use it for the whole script.
+Quite soon we're going to learn functions (a way to group commands), so let's note in advance that `"use strict"` can be put at the beginning of a function. Doing that enables strict mode in that function only. But usually people use it for the whole script.
 
 ````warn header="Ensure that \"use strict\" is at the top"
 Please make sure that `"use strict"` is at the top of your scripts, otherwise strict mode may not be enabled.

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

@@ -82,7 +82,7 @@ const bigInt = 1234567890123456789012345678901234567890n;
 As `BigInt` numbers are rarely needed, we don't cover them here, but devoted them a separate chapter <info:bigint>. Read it when you need such big numbers.
 
 ```smart header="Compatability issues"
-Right now `BigInt` is supported in Firefox and Chrome, but not in Safari/IE/Edge.
+Right now `BigInt` is supported in Firefox/Chrome/Edge, but not in Safari/IE.
 ```
 
 ## String
@@ -257,7 +257,7 @@ There are 8 basic data types in JavaScript.
 
 - `number` for numbers of any kind: integer or floating-point, integers are limited by ±2<sup>53</sup>.
 - `bigint` is for integer numbers of arbitrary length.
-- `string` for strings. A string may have one or more characters, there's no separate single-character type.
+- `string` for strings. A string may have zero or more characters, there's no separate single-character type.
 - `boolean` for `true`/`false`.
 - `null` for unknown values -- a standalone type that has a single value `null`.
 - `undefined` for unassigned values -- a standalone type that has a single value `undefined`.

1-js/02-first-steps/09-comparison/article.md

@@ -4,10 +4,17 @@
 
 : وفي لغة الجافسكريبت تكتب كما يلي 
 
+<<<<<<< HEAD
 - أكبر من وأصغر من: <code>a &gt; b</code>, <code>a &lt; b</code>.
 - أكبر : <code>a &gt;= b</code>, <code>a &lt;= b</code>.
 - يساوي: `a == b` ، يرجى ملاحظة أن علامة المساواة المزدوجة` = `تعني اختبار المساواة ، في حين أن كلمة واحدة` a = b` تعني  تعيين أو مساواة .
 - لا تساوي. في الرياضيات ، يكون الترميز في JavaScript مكتوب مثل a !=b 
+=======
+- Greater/less than: <code>a &gt; b</code>, <code>a &lt; b</code>.
+- Greater/less than or equals: <code>a &gt;= b</code>, <code>a &lt;= b</code>.
+- Equals: `a == b`, please note the double equality sign `=` means the equality test, while a single one `a = b` means an assignment.
+- Not equals. In maths the notation is <code>&ne;</code>, but in JavaScript it's written as <code>a != b</code>.
+>>>>>>> 69e44506c3e9dac74c282be37b55ba7ff122ae74
 
 في هذه المقالة سنتعلم المزيد عن الأنواع المختلفة من المقارنات ، وكيف تجعلها JavaScript ، بما في ذلك الخصائص المهمة.
 

1-js/02-first-steps/11-logical-operators/article.md

@@ -125,16 +125,28 @@ alert( undefined || null || 0 ); // 0 (الكل falsy, ترجع آخر قيمة)
 
     أهمية هذه الميزة تصبح ملحوظة إذا كانت القيمة الممررة عبارة عن عملية لها آثار جانبية مثل تخصيص قيمة متغير أو استدعاء دالة
 
+<<<<<<< HEAD
     في هذا المثال سيتم طباعة الرسالة الأولى ولن يتم طباعة الثانية:
 
     ```js run no-beautify
     *!*false*/!* || alert("printed");
     *!*true*/!* || alert("not printed");
+=======
+    In the example below, only the second message is printed:
+
+    ```js run no-beautify
+    *!*true*/!* || alert("not printed");
+    *!*false*/!* || alert("printed");
+>>>>>>> 69e44506c3e9dac74c282be37b55ba7ff122ae74
     ```
 
     في السطر الثاني يتوقف المعامل OR `||` مباشرة عند الوصول إلى `true` لذلك فإن `alert` لا ينفذ.
 
+<<<<<<< HEAD
     أحيانًا يستخدم الناس هذه الخاصية لتنفيذ أوامر فقط إذا كان الجزء الأيسر truthy.
+=======
+    Sometimes, people use this feature to execute commands only if the condition on the left part is falsy.
+>>>>>>> 69e44506c3e9dac74c282be37b55ba7ff122ae74
 
 ## && (AND)
 

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

@@ -16,36 +16,58 @@ x = (a !== null && a !== undefined) ? a : b;
 
 هذا مثال أطول.
 
+<<<<<<< HEAD
 لنفترض أن لدينا `firstName`, `lastName` أو `nickName` وجميعهم اختياريين.
 
 لنختار القيمة المعرفة ونعرضها (أو نعرض "Anonymous" إذا لم يحدد أي شئ):
+=======
+Imagine, we have a user, and there are variables `firstName`, `lastName` or `nickName` for their first name, last name and the nick name. All of them may be undefined, if the user decided not to enter any value.
+
+We'd like to display the user name: one of these three variables, or show "Anonymous" if nothing is set.
+
+Let's use the `??` operator to select the first defined one:
+>>>>>>> 69e44506c3e9dac74c282be37b55ba7ff122ae74
 
 ```js run
 let firstName = null;
 let lastName = null;
 let nickName = "Supercoder";
 
-// show the first not-null/undefined variable
+// show the first not-null/undefined value
+*!*
 alert(firstName ?? lastName ?? nickName ?? "Anonymous"); // Supercoder
+*/!*
 ```
 
 ## المقارنة مع ||
 
+<<<<<<< HEAD
 هذا مشابه جدًا للمعامل `||`. في الحقيقة يمكننا استبدال `??` ب `||` في المثال السابق وسنحصل على نفس النتيجة.
+=======
+The OR `||` operator can be used in the same way as `??`. Actually, we can replace `??` with `||` in the code above and get the same result, as it was described in the [previous chapter](info:logical-operators#or-finds-the-first-truthy-value).
+>>>>>>> 69e44506c3e9dac74c282be37b55ba7ff122ae74
 
 الفرق الجوهري بينهما أن:
 - `||` يرجع أول قيمة *truthy*.
 - `??` يرجع أول قيمة *defined*.
 
 هذا مهم جدًا عندما نريد معاملة `null/undefined` بطريقة مختلفة عن `0`.
 
+<<<<<<< HEAD
 مثلًا:
+=======
+For example, consider this:
+>>>>>>> 69e44506c3e9dac74c282be37b55ba7ff122ae74
 
 ```js
 height = height ?? 100;
 ```
 
+<<<<<<< HEAD
 هذا يجعل `height` يساوي `100` إذا لم يعرف. ولكن إذا كان `height` يساوي `0` سيبقى كما هو.
+=======
+This sets `height` to `100` if it's not defined.
+>>>>>>> 69e44506c3e9dac74c282be37b55ba7ff122ae74
 
 لنقارنه مع `||`:
 
@@ -56,17 +78,31 @@ alert(height || 100); // 100
 alert(height ?? 100); // 0
 ```
 
+<<<<<<< HEAD
 هنا `height || 100` تعامل الصفر مثل `null`, `undefined` أو أي قيمة falsy أخرىوهذا قد لا يكون صحيح أحيانًا.
 
 ولكن `height ?? 100` ترجع `100` إذا كان فقط `height` يساوي تمامًا `null` أو `undefined`.
+=======
+Here, `height || 100` treats zero height as unset, same as `null`, `undefined` or any other falsy value. So zero becames `100`.
+
+The `height ?? 100` returns `100` only if `height` is exactly `null` or `undefined`. So zero remains "as is".
+
+Which behavior is better depends on a particular use case. When zero height is a valid value, that we shouldn't touch, then `??` is preferrable.
+>>>>>>> 69e44506c3e9dac74c282be37b55ba7ff122ae74
 
 ## الأولوية
 
 أولوية المعامل `??` هي قليلة: `7` وتساوي [MDN جدول](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table).
 
+<<<<<<< HEAD
 هذا أقل من معظم المعاملات وأكبر بقليل من `=` و `?`.
 
 لذلك إذا أردنا استخدام `??` في تعبيرات معقدة نقوم بإضافة أقواس:
+=======
+So `??` is evaluated after most other operations, but before `=` and `?`.
+
+If we need to choose a value with `??` in a complex expression, then consider adding parentheses:
+>>>>>>> 69e44506c3e9dac74c282be37b55ba7ff122ae74
 
 ```js run
 let height = null;
@@ -78,6 +114,7 @@ let area = (height ?? 100) * (width ?? 50);
 alert(area); // 5000
 ```
 
+<<<<<<< HEAD
 إذا لم نستخدم الأقواس فإن `*` له أولوية أعلى وسينفذ أولًا كأننا كتبنا:
 
 ```js
@@ -86,19 +123,45 @@ let area = height ?? (100 * width) ?? 50;
 ```
 
 هناك أيضًا قيود لغوية. لأسباب أمنية لا يمكن استخدام `??` مع `&&` أو `||`.
+=======
+Otherwise, if we omit parentheses, `*` has the higher precedence than `??` and would run first.
+
+That would work be the same as:
+
+```js
+// probably not correct
+let area = height ?? (100 * width) ?? 50;
+```
+
+There's also a related language-level limitation.
+
+**Due to safety reasons, it's forbidden to use `??` together with `&&` and `||` operators.**
+>>>>>>> 69e44506c3e9dac74c282be37b55ba7ff122ae74
 
 هذا سينتج خطأ لغوي:
 
 ```js run
 let x = 1 && 2 ?? 3; // Syntax error
 ```
 
+<<<<<<< HEAD
 هذا القيد قد لا يبدو منطقيًا ولكن لبعض الأسباب تم إضافته للغة.
 
 استخدم الأقواس لتجنب الخطأ:
 
 ```js run
 let x = (1 && 2) ?? 3; // تعمل دون مشاكل
+=======
+The limitation is surely debatable, but it was added to the language specification with the purpose to avoid programming mistakes, as people start to switch to `??` from `||`.
+
+Use explicit parentheses to work around it:
+
+```js run
+*!*
+let x = (1 && 2) ?? 3; // Works
+*/!*
+
+>>>>>>> 69e44506c3e9dac74c282be37b55ba7ff122ae74
 alert(x); // 2
 ```
 

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

@@ -124,7 +124,7 @@ user2.admin?.();
 
 Here, in both lines we first use the dot `.` to get `admin` property, because the user object must exist, so it's safe read from it.
 
-Then `?.()` checks the left part: if the user exists, then it runs (for `user1`). Otherwise (for `user2`) the evaluation stops without errors.
+Then `?.()` checks the left part: if the admin function exists, then it runs (for `user1`). Otherwise (for `user2`) the evaluation stops without errors.
 
 The `?.[]` syntax also works, if we'd like to use brackets `[]` to access properties instead of dot `.`. Similar to previous cases, it allows to safely read a property from an object that may not exist.
 

1-js/05-data-types/05-array-methods/12-reduce-object/_js.view/test.js

@@ -8,13 +8,14 @@ describe("groupById", function() {
     ];
 
     assert.deepEqual(groupById(users), {
-      john: {id: 'john', name: "John Smith", age: 20}
+      john: {id: 'john', name: "John Smith", age: 20},
       ann: {id: 'ann', name: "Ann Smith", age: 24},
       pete: {id: 'pete', name: "Pete Peterson", age: 31},
     });
   });
 
   it("works with an empty array", function() {
+    users = [];
     assert.deepEqual(groupById(users), {});
   });
 });

1-js/05-data-types/05-array-methods/12-reduce-object/task.md

@@ -23,7 +23,7 @@ let usersById = groupById(users);
 // after the call we should have:
 
 usersById = {
-  john: {id: 'john', name: "John Smith", age: 20}
+  john: {id: 'john', name: "John Smith", age: 20},
   ann: {id: 'ann', name: "Ann Smith", age: 24},
   pete: {id: 'pete', name: "Pete Peterson", age: 31},
 }

1-js/05-data-types/07-map-set/article.md

@@ -198,7 +198,7 @@ let prices = Object.fromEntries([
 alert(prices.orange); // 2
 ```
 
-We can use `Object.fromEntries` to get an plain object from `Map`.
+We can use `Object.fromEntries` to get a plain object from `Map`.
 
 E.g. we store the data in a `Map`, but we need to pass it to a 3rd-party code that expects a plain object.
 
@@ -220,7 +220,7 @@ let obj = Object.fromEntries(map.entries()); // make a plain object (*)
 alert(obj.orange); // 2
 ```
 
-A call to `map.entries()` returns an array of key/value pairs, exactly in the right format for `Object.fromEntries`.
+A call to `map.entries()` returns an iterable of key/value pairs, exactly in the right format for `Object.fromEntries`.
 
 We could also make line `(*)` shorter:
 ```js

1-js/05-data-types/11-date/6-get-seconds-today/solution.md

@@ -23,4 +23,6 @@ function getSecondsToday() {
   let d = new Date();
   return d.getHours() * 3600 + d.getMinutes() * 60 + d.getSeconds();
 }
+
+alert( getSecondsToday() );
 ```