chore(i18n,learn): processed translations (#48152)

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes.md

@@ -0,0 +1,87 @@
+---
+id: 56bbb991ad1ed5201cd392ca
+title: الوصول إلى بيانات القائمة باستخدام الترتيب (Access Array Data with Indexes)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBZQbTz'
+forumTopicId: 16158
+dashedName: access-array-data-with-indexes
+---
+
+# --description--
+
+يمكننا الوصول إلى البيانات داخل القائمات باستخدام <dfn>الترتيب</dfn>.
+
+Array indexes تكتب بنفس الأقواس التي تستخدم في مقاطع النصية (strings)، باستثناء أنه بدلاً من تحديد رمز، فإنهم يحددون عنصرا في القائمة (array). مثل المقاطع النصية (strings)، فإن القائمات (arrays) تستخدم القائمة <dfn>تبدأ بالصفر</dfn>، لذا فإن العنصر الأول في القائمة (array) لديه الترتيب (index) برقم `0`.
+
+<br>
+
+**على سبيل المثال**
+
+```js
+const array = [50, 60, 70];
+console.log(array[0]);
+const data = array[1];
+```
+
+`console.log(array[0])` تطبع `50` و `data` بقيمة `60`.
+
+# --instructions--
+
+أنشئ متغير يسمى `myData` وعيّنه ليساوي القيمة الأولى في `myArray` باستخدام bracket notation.
+
+# --hints--
+
+المتغير `myData` يجب أن يساوي القيمة الأولى في `myArray`.
+
+```js
+assert(
+  (function () {
+    if (
+      typeof myArray !== 'undefined' &&
+      typeof myData !== 'undefined' &&
+      myArray[0] === myData
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })()
+);
+```
+
+البيانات في المتغير `myArray` يجب الوصول إليها باستخدام bracket notation.
+
+```js
+assert(
+  (function () {
+    if (code.match(/\s*=\s*myArray\[0\]/g)) {
+      return true;
+    } else {
+      return false;
+    }
+  })()
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined" && typeof myData !== "undefined"){(function(y,z){return 'myArray = ' + JSON.stringify(y) + ', myData = ' + JSON.stringify(z);})(myArray, myData);}
+```
+
+## --seed-contents--
+
+```js
+const myArray = [50, 60, 70];
+
+
+```
+
+# --solutions--
+
+```js
+const myArray = [50, 60, 70];
+const myData = myArray[0];
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/access-multi-dimensional-arrays-with-indexes.md

@@ -0,0 +1,77 @@
+---
+id: 56592a60ddddeae28f7aa8e1
+title: الوصول إلى القائمات المتعددة الأبعاد باستخدام الترتيب (Access Multi-Dimensional Arrays With Indexes)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ckND4Cq'
+forumTopicId: 16159
+dashedName: access-multi-dimensional-arrays-with-indexes
+---
+
+# --description--
+
+إحدى الطرق للتفكير في قائمة <dfn>عديده الأبعاد(multi-dimensional)</dfn> هي تكون *قائمة من قائمات (array of arrays)*. عندما تستخدم أقواس للوصول إلى القائمة (array)، تشير المجموعة الأولى من الأقواس إلى المواد الموجودة في أعلى فئة (المستوى الأول)، ويشير كل زوج إضافي من الأقواس إلى المستوى التالي من الإدخالات في الداخل.
+
+**مثال**
+
+```js
+const arr = [
+  [1, 2, 3],
+  [4, 5, 6],
+  [7, 8, 9],
+  [[10, 11, 12], 13, 14]
+];
+
+const subarray = arr[3];
+const nestedSubarray = arr[3][0];
+const element = arr[3][0][1];
+```
+
+في هذا المثال، لدي `subarray` قيمة `[[10, 11, 12], 13, 14]`, ولدي `nestedSubarray` قيمة `[10, 11, 12]`, ولدي `element` قيمة `11`.
+
+**ملاحظة:** لا ينبغي أن تكون هناك أي مسافات بين اسم القائمة (array) والأقواس المربعة، مثل `array [0][0]` و حتي ذلك `array [0] [0]` ممنوع أيضاً. مع أنّ JavaScript قادر على معالجة هذا الأمر بشكل صحيح، إلا أن هذا قد يحير المبرمجين الآخرين الذين يقرؤون التعليمات البرمجية الخاص بك.
+
+# --instructions--
+
+باستخدام bracket notation، اختر عنصرا من `myArray` بحيث أن `myData` يساوي `8`.
+
+# --hints--
+
+يجب أن يساوي `myData` قيمة `8`.
+
+```js
+assert(myData === 8);
+```
+
+يجب أن تستخدم bracket notation لقراءة القيمة الصحيحة من `myArray`.
+
+```js
+assert(/myData=myArray\[2\]\[1\]/.test(__helpers.removeWhiteSpace(code)));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return "myData: " + myData + " myArray: " + JSON.stringify(myArray);})();}
+```
+
+## --seed-contents--
+
+```js
+const myArray = [
+  [1, 2, 3],
+  [4, 5, 6],
+  [7, 8, 9],
+  [[10, 11, 12], 13, 14],
+];
+
+const myData = myArray[0][0];
+```
+
+# --solutions--
+
+```js
+const myArray = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [[10, 11, 12], 13, 14]];
+const myData = myArray[2][1];
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays.md

@@ -0,0 +1,121 @@
+---
+id: 56533eb9ac21ba0edf2244cd
+title: الوصول إلى القائمات المتداخلة (Accessing Nested Arrays)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cLeGDtZ'
+forumTopicId: 16160
+dashedName: accessing-nested-arrays
+---
+
+# --description--
+
+وكما رأينا في أمثلة سابقة، يمكن أن تحتوي الكائنات (objects) على كائنات متدخلة (nested objects) و قائمات متداخلة (nested arrays). على غرار الوصول إلى الكائنات متدخلة nested objects، يمكن ربط bracket notation في القائمة للوصول إلى القائمات متداخلة (nested arrays).
+
+وفيما يلي مثال على كيفية الوصول إلى القائمة متداخلة nested) array):
+
+```js
+const ourPets = [
+  {
+    animalType: "cat",
+    names: [
+      "Meowzer",
+      "Fluffy",
+      "Kit-Cat"
+    ]
+  },
+  {
+    animalType: "dog",
+    names: [
+      "Spot",
+      "Bowser",
+      "Frankie"
+    ]
+  }
+];
+
+ourPets[0].names[1];
+ourPets[1].names[0];
+```
+
+`ourPets[0].names[1]` ستكوون المقطع نصي (string) الآتي `Fluffy` و `ourPets[1].names[0]` ستكون المقطع نصي (string) الآتي `Spot`.
+
+# --instructions--
+
+باستخدام dot و bracket notation، وعيّن المتغير `secondTree` إلى العنصر الثاني في قائمة `trees` من object باسم `myPlants`.
+
+# --hints--
+
+يجب أن تساوي `secondTree` مقطع (string) الآتي `pine`.
+
+```js
+assert(secondTree === 'pine');
+```
+
+التعليمات البرميجة الخاص بك يجب أن يستخدم dot و bracket notation للوصول إلى `myPlants`.
+
+```js
+assert(/=\s*myPlants\[1\].list\[1\]/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(x) {
+  if(typeof x != 'undefined') {
+    return "secondTree = " + x;
+  }
+  return "secondTree is undefined";
+})(secondTree);
+```
+
+## --seed-contents--
+
+```js
+const myPlants = [
+  {
+    type: "flowers",
+    list: [
+      "rose",
+      "tulip",
+      "dandelion"
+    ]
+  },
+  {
+    type: "trees",
+    list: [
+      "fir",
+      "pine",
+      "birch"
+    ]
+  }
+];
+
+const secondTree = "";
+```
+
+# --solutions--
+
+```js
+const myPlants = [
+  {
+    type: "flowers",
+    list: [
+      "rose",
+      "tulip",
+      "dandelion"
+    ]
+  },
+  {
+    type: "trees",
+    list: [
+      "fir",
+      "pine",
+      "birch"
+    ]
+  }
+];
+
+const secondTree = myPlants[1].list[1];
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects.md

@@ -0,0 +1,100 @@
+---
+id: 56533eb9ac21ba0edf2244cc
+title: الوصول إلى الكائنات المتداخلة (Accessing Nested Objects)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRnRnfa'
+forumTopicId: 16161
+dashedName: accessing-nested-objects
+---
+
+# --description--
+
+يمكن الوصول للخصائص الفرعية (sub-properties) للكائنات (objects) من طريق ربطه برمز النقطة أو القوس.
+
+فيما يلي كائن متداخل (nested object):
+
+```js
+const ourStorage = {
+  "desk": {
+    "drawer": "stapler"
+  },
+  "cabinet": {
+    "top drawer": { 
+      "folder1": "a file",
+      "folder2": "secrets"
+    },
+    "bottom drawer": "soda"
+  }
+};
+
+ourStorage.cabinet["top drawer"].folder2;
+ourStorage.desk.drawer;
+```
+
+سيكون `ourStorage.cabinet["top drawer"].folder2` مقطع (string) الآتي `secrets`, وسيكون `ourStorage.desk.drawer` مقطع (string) الآتي `stapler`.
+
+# --instructions--
+
+الوصول إلى الكائن `myStorage` وعيّن محتوى الخاصية `glove box` إلى المتغير `gloveBoxContents`. حاول استخدام النُّقَط (dot notation) للوصول للخصائص (properties) بقدر الإمكان، وإلا فيمكنك استخدام الأقواس[] (bracket notation).
+
+# --hints--
+
+يجب أن يساوي `gloveBoxContents` مقطع (string) الآتي `maps`.
+
+```js
+assert(gloveBoxContents === 'maps');
+```
+
+التعليمات البرمجية الخاص بك يجب أن يستخدم dot notation و bracket notation للوصول إلى `myStorage`.
+
+```js
+assert(/=\s*myStorage\.car\.inside\[\s*("|')glove box\1\s*\]/g.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(x) { 
+  if(typeof x != 'undefined') { 
+    return "gloveBoxContents = " + x;
+  }
+  return "gloveBoxContents is undefined";
+})(gloveBoxContents);
+```
+
+## --seed-contents--
+
+```js
+const myStorage = {
+  "car": {
+    "inside": {
+      "glove box": "maps",
+      "passenger seat": "crumbs"
+     },
+    "outside": {
+      "trunk": "jack"
+    }
+  }
+};
+
+const gloveBoxContents = undefined;
+```
+
+# --solutions--
+
+```js
+const myStorage = {
+  "car":{
+    "inside":{
+      "glove box":"maps",
+      "passenger seat":"crumbs"
+    },
+    "outside":{
+      "trunk":"jack"
+    }
+  }
+};
+const gloveBoxContents = myStorage.car.inside["glove box"];
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-bracket-notation.md

@@ -0,0 +1,103 @@
+---
+id: 56533eb9ac21ba0edf2244c8
+title: الوصول خصائص (Properties) الكائن (Object) بواسطة Bracket Notation
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBvmEHP'
+forumTopicId: 16163
+dashedName: accessing-object-properties-with-bracket-notation
+---
+
+# --description--
+
+الطريقة الثانية للوصول إلى خصائص الكائن هي القوسان المعكوفان (`[]`). في حال إن خاصية الكائن الذي تحاول الوصول إليه يحتوي على مسافة في اسمه, سوف تحتاج إلى استخدام القوسان المعكوفان (bracket notation).
+
+على أية حال, فانه يمكنك أستخدام bracket notation على خصائص الكائن من دون مسافات.
+
+هذا مثال على استخدام bracket notation لقراءة خاصية الكائن:
+
+```js
+const myObj = {
+  "Space Name": "Kirk",
+  "More Space": "Spock",
+  "NoSpace": "USS Enterprise"
+};
+
+myObj["Space Name"];
+myObj['More Space'];
+myObj["NoSpace"];
+```
+
+سوف يحتوي `myObj["Space Name"]` على نص `Kirk`, و سوف يحتوي `myObj['More Space']` على نص `Spock`, و سوف يحتوي `myObj["NoSpace"]` على نص `USS Enterprise`.
+
+لاحظ يجب أن تكون أسماء الخاصية مع المسافات في علامتا التنصيص (أحاديا أو ثنائيا).
+
+# --instructions--
+
+أقراء قيم خصائص `an entree` و `the drink` في `testObj` باستخدام القوسان المعكوفان وتعينهم إلى `entreeValue` و `drinkValue` على التوالي.
+
+# --hints--
+
+يجب أن يكون `entreeValue` مقطع نصي
+
+```js
+assert(typeof entreeValue === 'string');
+```
+
+يجب ان يكون قيمة `entreeValue` نص `hamburger`
+
+```js
+assert(entreeValue === 'hamburger');
+```
+
+يجب أن تكون `drinkValue` نص
+
+```js
+assert(typeof drinkValue === 'string');
+```
+
+يجب أن تكون قيمة `drinkValue` نص `water`
+
+```js
+assert(drinkValue === 'water');
+```
+
+يجب عليك أستخدام القوسان المعكوفان مرتين
+
+```js
+assert(code.match(/testObj\s*?\[('|")[^'"]+\1\]/g).length > 1);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b) { return "entreeValue = '" + a + "', drinkValue = '" + b + "'"; })(entreeValue,drinkValue);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const testObj = {
+  "an entree": "hamburger",
+  "my side": "veggies",
+  "the drink": "water"
+};
+
+// Only change code below this line
+const entreeValue = testObj;   // Change this line
+const drinkValue = testObj;    // Change this line
+```
+
+# --solutions--
+
+```js
+const testObj = {
+  "an entree": "hamburger",
+  "my side": "veggies",
+  "the drink": "water"
+};
+const entreeValue = testObj["an entree"];
+const drinkValue = testObj['the drink'];
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-dot-notation.md

@@ -0,0 +1,100 @@
+---
+id: 56533eb9ac21ba0edf2244c7
+title: الوصول إلى خصائص الكائن مع النقطة التأشير (Accessing Object Properties with Dot Notation)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cGryJs8'
+forumTopicId: 16164
+dashedName: accessing-object-properties-with-dot-notation
+---
+
+# --description--
+
+هناك طريقتان للوصول إلى خصائص الكائن: نقطة التأشير (`.`) وتدوين الأقواس (`[]`)، على غرار القائمة.
+
+ترميز النقطة هو ما تستخدمه عندما تعرف اسم الخاصية التي تحاول الوصول إليها مسبقاً.
+
+هذا مثال من استخدام النقطة التأشير (`.`) لقراءة خاصية الكائن:
+
+```js
+const myObj = {
+  prop1: "val1",
+  prop2: "val2"
+};
+
+const prop1val = myObj.prop1;
+const prop2val = myObj.prop2;
+```
+
+سيكون إلى `prop1val` قيمة نص `val1`، و سيكون إلى `prop2val` قيمة نص `val2`.
+
+# --instructions--
+
+اقرأ في قيم الخاصية `testObj` باستخدام النقطة التأشير. عيّن المتغير `hatValue` مساوية لخاصية الكائن `hat`, وعيّن المتغير `shirtValue` مساوية لخاصية الكائن `shirt`.
+
+# --hints--
+
+قيمة `hatVvalue` يجب أن تكون نص
+
+```js
+assert(typeof hatValue === 'string');
+```
+
+يجب أن تكون قيمة `hatValue` نص `ballcap`
+
+```js
+assert(hatValue === 'ballcap');
+```
+
+يجب أن تكون قيمة `shirtValue` نص
+
+```js
+assert(typeof shirtValue === 'string');
+```
+
+يجب أن تكون قيمة `shirtValue` نص `jersey`
+
+```js
+assert(shirtValue === 'jersey');
+```
+
+يجب عليك استخدام النقطة التأشير مرتين
+
+```js
+assert(code.match(/testObj\.\w+/g).length > 1);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b) { return "hatValue = '" + a + "', shirtValue = '" + b + "'"; })(hatValue,shirtValue);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const testObj = {
+  "hat": "ballcap",
+  "shirt": "jersey",
+  "shoes": "cleats"
+};
+
+// Only change code below this line
+const hatValue = testObj;      // Change this line
+const shirtValue = testObj;    // Change this line
+```
+
+# --solutions--
+
+```js
+const testObj = {
+  "hat": "ballcap",
+  "shirt": "jersey",
+  "shoes": "cleats"
+};
+
+const hatValue = testObj.hat;
+const shirtValue = testObj.shirt;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables.md

@@ -0,0 +1,107 @@
+---
+id: 56533eb9ac21ba0edf2244c9
+title: الوصول إلى خصائص الكائن باستخدام المتغيرات (Accessing Object Properties with Variables)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cnQyKur'
+forumTopicId: 16165
+dashedName: accessing-object-properties-with-variables
+---
+
+# --description--
+
+وثمة استخدام آخر لترميز آلأقواس للوصول إلى الخصائص المخزنة كقيمة للمتغير. يمكن أن يكون هذا مفيداً جداً خلال تكرار خصائص الكائن أو عند الوصول إلى جدول البحث.
+
+فيما يلي, مثال على استخدام متغير للوصول إلى خاصية ما:
+
+```js
+const dogs = {
+  Fido: "Mutt",
+  Hunter: "Doberman",
+  Snoopie: "Beagle"
+};
+
+const myDog = "Hunter";
+const myBreed = dogs[myDog];
+console.log(myBreed);
+```
+
+سوف يتم عرض `Doberman` في وحدة التحكم (console).
+
+لاحظ أننا *لا* نستخدم علامات التنصيص حول اسم المتغير عند استخدامه للوصول إلى الخاصية لأننا نستخدم *قيمة* المتغير، ليس *الاسم*.
+
+# --instructions--
+
+عيّن متغير `playerNumber` إلى `16`. ثم استخدم المتغير للبحث عن اسم اللاعب وتعيينه إلى `player`.
+
+# --hints--
+
+`playerNumber` يجب أن يكون رقما
+
+```js
+assert(typeof playerNumber === 'number');
+```
+
+المتغير `player` يجب أن يكون مقطع نصي (string)
+
+```js
+assert(typeof player === 'string');
+```
+
+يجب أن تكون قيمة `player` مقطع نصي `Montana`
+
+```js
+assert(player === 'Montana');
+```
+
+يجب عليك استخدام ترميز ألأقواس للوصول إلى `testObj`
+
+```js
+assert(/testObj\s*?\[.*?\]/.test(code));
+```
+
+لا يجب عليك تعيين قيمة `Montana` للمتغير `player` مباشرة.
+
+```js
+assert(!code.match(/player\s*=\s*"|\'\s*Montana\s*"|\'\s*;/gi));
+```
+
+يجب أن تستخدم المتغير `playerNumber` في رمز القوس
+
+```js
+assert(/testObj\s*?\[\s*playerNumber\s*\]/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof player !== "undefined"){(function(v){return v;})(player);}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const testObj = {
+  12: "Namath",
+  16: "Montana",
+  19: "Unitas"
+};
+
+// Only change code below this line
+const playerNumber = 42;  // Change this line
+const player = testObj;   // Change this line
+```
+
+# --solutions--
+
+```js
+const testObj = {
+  12: "Namath",
+  16: "Montana",
+  19: "Unitas"
+};
+const playerNumber = 16;
+const player = testObj[playerNumber];
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/add-new-properties-to-a-javascript-object.md

@@ -0,0 +1,90 @@
+---
+id: 56bbb991ad1ed5201cd392d2
+title: إضافة خصائص جديدة إلى كائن في JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cQe38UD'
+forumTopicId: 301169
+dashedName: add-new-properties-to-a-javascript-object
+---
+
+# --description--
+
+بإمكانك إضافة خصائص جديدة إلى كائنات في JavaScript موجودة فعلًا بنفس الطريقة التي تعديلها.
+
+هذه هي طريقة إضافة خاصية `bark` إلى `ourDog`:
+
+```js
+ourDog.bark = "bow-wow";
+```
+
+أو
+
+```js
+ourDog["bark"] = "bow-wow";
+```
+
+الآن عندما نشغل `ourDog.bark`، سنحصل على صوت نُباحه `bow-wow`.
+
+مثال:
+
+```js
+const ourDog = {
+  "name": "Camper",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["everything!"]
+};
+
+ourDog.bark = "bow-wow";
+```
+
+# --instructions--
+
+أضف خاصية `bark` إلى `myDog` وعيّنها إلى صوت الكلاب، مثل "woof". يمكنك استخدام أي من علامة نقط أو علامة الأقواس.
+
+# --hints--
+
+يجب عليك إضافة الخاصية `bark` إلى الكائن `myDog`.
+
+```js
+assert(myDog.bark !== undefined);
+```
+
+لا ينبغي أن تضيف `bark` إلى التعليمات البرمجية تهيئة الكائن `myDog`.
+
+```js
+assert(!/bark[^\n]:/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myDog);
+```
+
+## --seed-contents--
+
+```js
+const myDog = {
+  "name": "Happy Coder",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["freeCodeCamp Campers"]
+};
+
+
+```
+
+# --solutions--
+
+```js
+const myDog = {
+  "name": "Happy Coder",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["freeCodeCamp Campers"]
+};
+myDog.bark = "Woof Woof";
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/add-two-numbers-with-javascript.md

@@ -0,0 +1,62 @@
+---
+id: cf1111c1c11feddfaeb3bdef
+title: إضافة رقمين باستخدام JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cM2KBAG'
+forumTopicId: 16650
+dashedName: add-two-numbers-with-javascript
+---
+
+# --description--
+
+`Number` (رَقَم) هو نوع من أنواع البيانات في لغة JavaScript و هو يمثل بيانات رقمية.
+
+حاول إضافة رقمين باستخدام JavaScript.
+
+تستخدم JavaScript رمز `+` كمعامل الإضافة عند وضعه بين رقمين.
+
+**مثال:**
+
+```js
+const myVar = 5 + 10;
+```
+
+لدي `myVar` الآن القيمة `15`.
+
+# --instructions--
+
+غير `0` بحيث يكون المجموع `20`.
+
+# --hints--
+
+يجب أن `sum` يساوي `20`.
+
+```js
+assert(sum === 20);
+```
+
+يجب عليك استخدام المعامل `+`.
+
+```js
+assert(/\+/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'sum = '+z;})(sum);
+```
+
+## --seed-contents--
+
+```js
+const sum = 10 + 0;
+```
+
+# --solutions--
+
+```js
+const sum = 10 + 10;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/adding-a-default-option-in-switch-statements.md

@@ -0,0 +1,128 @@
+---
+id: 56533eb9ac21ba0edf2244de
+title: إضافة خِيار افتراضي (Default) في عبارات التبديل (Switch)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c3JvVfg'
+forumTopicId: 16653
+dashedName: adding-a-default-option-in-switch-statements
+---
+
+# --description--
+
+في عبارة `switch` قد لا تكون قادراً على تحديد جميع القيم المحتملة كعبارات `case`. بدلاً من ذلك، يمكنك إضافة عبارة `default` التي سيتم تنفيذها إذا لم يتم العثور على عبارات `case` مطابقة. فكر بالأمر مثل العبارة `else` في `if/else`.
+
+يجب أن تكون عبارة `default` آخر حالة.
+
+```js
+switch (num) {
+  case value1:
+    statement1;
+    break;
+  case value2:
+    statement2;
+    break;
+...
+  default:
+    defaultStatement;
+    break;
+}
+```
+
+# --instructions--
+
+اكتب عبارة التبديل لتعيين `answer` للشروط التالية:  
+`a` - `apple`  
+`b` - `bird`  
+`c` - `cat`  
+`default` - `stuff`
+
+# --hints--
+
+`switchOfStuff("a")` يجب أن يعيد مقطع نصي (string) باسم `apple`
+
+```js
+assert(switchOfStuff('a') === 'apple');
+```
+
+`switchOfStuff("b")` يجب أن ينتج مقطع نصي (string) باسم `bird`
+
+```js
+assert(switchOfStuff('b') === 'bird');
+```
+
+`switchOfStuff("c")` يجب أن ينتج مقطع نصي (string) باسم `cat`
+
+```js
+assert(switchOfStuff('c') === 'cat');
+```
+
+`switchOfStuff("d")` يجب أن ينتج مقطع نصي (string) باسم `stuff`
+
+```js
+assert(switchOfStuff('d') === 'stuff');
+```
+
+`switchOfStuff(4)` يجب أن ينتج مقطع نصي (string) باسم `stuff`
+
+```js
+assert(switchOfStuff(4) === 'stuff');
+```
+
+يجب ألا تستخدم أي عبارات `if` أو `else`
+
+```js
+assert(!/else/g.test(code) || !/if/g.test(code));
+```
+
+يجب أن تستخدم عبارة `default`
+
+```js
+assert(switchOfStuff('string-to-trigger-default-case') === 'stuff');
+```
+
+يجب أن يكون لديك في الأقل ٣ عبارات `break`
+
+```js
+assert(code.match(/break/g).length > 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function switchOfStuff(val) {
+  let answer = "";
+  // Only change code below this line
+
+
+
+  // Only change code above this line
+  return answer;
+}
+
+switchOfStuff(1);
+```
+
+# --solutions--
+
+```js
+function switchOfStuff(val) {
+  let answer = "";
+
+  switch(val) {
+    case "a":
+      answer = "apple";
+      break;
+    case "b":
+      answer = "bird";
+      break;
+    case "c":
+      answer = "cat";
+      break;
+    default:
+      answer = "stuff";
+  }
+  return answer;
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/appending-variables-to-strings.md

@@ -0,0 +1,77 @@
+---
+id: 56533eb9ac21ba0edf2244ed
+title: إلحاق المتغيرات بالمقاطع النصية (Appending Variables to Strings)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cbQmZfa'
+forumTopicId: 16656
+dashedName: appending-variables-to-strings
+---
+
+# --description--
+
+تماما كما يمكننا بناء مقطع نصي (string) مكونة من عدة سطور باستخدام <dfn>الاحرف مقطع نصي (string literals)</dfn>، يمكننا أيضا إلحاق المتغيرات في مقطع نصي (string) معينة باستخدام (`+=`).
+
+على سبيل المثال:
+
+```js
+const anAdjective = "awesome!";
+let ourStr = "freeCodeCamp is ";
+ourStr += anAdjective;
+```
+
+المتغير `ourStr` ستكون قيمته النهائية `freeCodeCamp is awesome!`.
+
+# --instructions--
+
+عرف متغير جديد `someAdjective` بحيث يكون string قيمته مكون من 3 أحرف في الأقل, ثم إلحاقه بمتغير آخر `myStr` باستخدام `+=`.
+
+# --hints--
+
+يجب إن تكون قيمة المتغير `someAdjective` مقطع نصي (string) مكون من 3 حروف في الأقل.
+
+```js
+assert(typeof someAdjective !== 'undefined' && someAdjective.length > 2);
+```
+
+يجب عليك إلحاق المتغير `someAdjective` إلى `myStr` باستخدام `+=`.
+
+```js
+assert(code.match(/myStr\s*\+=\s*someAdjective\s*/).length > 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+  var output = [];
+  if(typeof someAdjective === 'string') {
+    output.push('someAdjective = "' + someAdjective + '"');
+  } else {
+    output.push('someAdjective is not a string');
+  }
+  if(typeof myStr === 'string') {
+    output.push('myStr = "' + myStr + '"');
+  } else {
+    output.push('myStr is not a string');
+  }
+  return output.join('\n');
+})();
+```
+
+## --seed-contents--
+
+```js
+// Change code below this line
+const someAdjective = "";
+let myStr = "Learning to code is ";
+```
+
+# --solutions--
+
+```js
+const someAdjective = "neat";
+let myStr = "Learning to code is ";
+myStr += someAdjective;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/assigning-the-value-of-one-variable-to-another.md

@@ -0,0 +1,86 @@
+---
+id: 5ee127a03c3b35dd45426493
+title: تعيين قيمة متغير إلى متغير آخر (Assigning the Value of One Variable to Another)
+challengeType: 1
+videoUrl: ''
+forumTopicId: 418265
+dashedName: assigning-the-value-of-one-variable-to-another
+---
+
+# --description--
+
+بعد تعيين قيمة إلى متغير باستخدام عملية <dfn>تكليف (=)</dfn>، يمكنك تعيين قيمة هذا المتغير إلى متغير آخر باستخدام عملية<dfn>تكليف (=)</dfn> ذاتها.
+
+```js
+var myVar;
+myVar = 5;
+var myNum;
+myNum = myVar;
+```
+
+ما ورد أعلاه يظهر تعريف المتغير `myVar` دون قيمة، ثم يعين له القيمة `5`. بعد ذلك، يتم تعريف متغير آخر يدعى `myNum` دون قيمة. ثم يتم تعيين قيمة المتغير `myVar` (التي تساوي `5`) إلى المتغير `myNum`. الآن المتغير `myNum` لديه القيمة `5`.
+
+# --instructions--
+
+عيًن قيمة المتغير`a` إلى المتغير `b`.
+
+# --hints--
+
+لا يجب عليك تعديل التعليمات البرمجية فوق التعليق المحدد.
+
+```js
+assert(/var a;/.test(code) && /a = 7;/.test(code) && /var b;/.test(code));
+```
+
+المتغير `b` يجب أن يساوي `7`.
+
+```js
+assert(typeof b === 'number' && b === 7);
+```
+
+قيمة المتغير `a` يجب أن يتم تعيينها إلى المتغير `b` باستخدام `=`.
+
+```js
+assert(/b\s*=\s*a\s*/g.test(code));
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+if (typeof a != 'undefined') {
+  a = undefined;
+}
+if (typeof b != 'undefined') {
+  b = undefined;
+}
+```
+
+## --after-user-code--
+
+```js
+(function(a, b) {
+  return 'a = ' + a + ', b = ' + b;
+})(a, b);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var a;
+a = 7;
+var b;
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var a;
+a = 7;
+var b;
+b = a;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/assignment-with-a-returned-value.md

@@ -0,0 +1,72 @@
+---
+id: 56533eb9ac21ba0edf2244c3
+title: استخدام القيمة الناتجة للتعيين
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ce2pEtB'
+forumTopicId: 16658
+dashedName: assignment-with-a-returned-value
+---
+
+# --description--
+
+إذا كنت ستتذكر من مناقشتنا حول <a href="/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator" target="_blank" rel="noopener noreferrer nofollow">تخزين القيم مع مشغل التعيين (=)</a>، يتم عزم كل شيء لحق الإشارة المتساوية قبل تعيين القيمة. وهذا يعني أنه يمكننا أخذ قيمة الناتجة من وظيفة وتعيينها إلى متغير.
+
+افترض أن لدينا وظيفة معرف سلفًا يدعي `sum`، التي تضيف رقمين معا، ثم:
+
+```js
+ourSum = sum(5, 12);
+```
+
+يستعي الوظيفة `sum` التي ترجع قيمة `17` وتعيينها إلى متغير `ourSum`.
+
+# --instructions--
+
+استدعي الوظيفة `processArg` باستخدام حَجَّة بقيمة `7`, وعيّن قيمة إرجاع لوظيفة للمتغير `processed`.
+
+# --hints--
+
+يجب أن تكون `processed` قيمته `2`
+
+```js
+assert(processed === 2);
+```
+
+يجب عليك تعيين `processArg` إلى `processed`
+
+```js
+assert(/processed\s*=\s*processArg\(\s*7\s*\)/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){return "processed = " + processed})();
+```
+
+## --seed-contents--
+
+```js
+// Setup
+let processed = 0;
+
+function processArg(num) {
+  return (num + 3) / 5;
+}
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+var processed = 0;
+
+function processArg(num) {
+  return (num + 3) / 5;
+}
+
+processed = processArg(7);
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/build-javascript-objects.md

@@ -0,0 +1,159 @@
+---
+id: 56bbb991ad1ed5201cd392d0
+title: بناء الكائنات في JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWGkbtd'
+forumTopicId: 16769
+dashedName: build-javascript-objects
+---
+
+# --description--
+
+ربما قد سمعت عن مصطلح `object` من قبل.
+
+الكائنات تشبه `arrays`، باستثناء انه بدلا من استخدام الترتيب للوصول إلى بياناتها وتعديلها، يمكنك الوصول إلى البيانات في الكائنات بواسطة `properties`.
+
+تكون الكائنات مفيدة لتخزين البيانات بطريقة منظمة، ويمكن تمثل الكائن في الواقع، مثل القطة.
+
+هذا مثال مبسط عن كائن القطة:
+
+```js
+const cat = {
+  "name": "Whiskers",
+  "legs": 4,
+  "tails": 1,
+  "enemies": ["Water", "Dogs"]
+};
+```
+
+في المثال، يتم تخزين جميع الخصائص كمقاطع مثل `name`، و`legs`، و `tails`. ومع ذلك، يمكنك استخدام الأرقام كالخواص أيضاً. يمكنك حذف علامتان التنصيص (" ") لخصائص النص المكون من كلمة واحدة، على النحو التالي:
+
+```js
+const anotherObject = {
+  make: "Ford",
+  5: "five",
+  "model": "focus"
+};
+```
+
+ومع ذلك، إذا كان الكائن الخاص بك يحتوي على خصائص غير المقطع النصي، فإن JavaScript سيحتسبها تلقائياً كمقاطع.
+
+# --instructions--
+
+أنشئ كائن يمثل كلبا يسمى `myDog` الذي يحتوي على الخواص `name` (مقطع نصي)، `legs`, و `tails`, و `friends`.
+
+يمكنك وضع خصائص الكائن الذي تريدها، مادام أن `name` هو مقطع، `legs` و `tails` هي أرقام، و`friends` هو قائمة (array).
+
+# --hints--
+
+يجب أن يحتوي `myDog` على الخاصية `name`, ويجب أن تكون الخاصية بنوع `string`.
+
+```js
+assert(
+  (function (z) {
+    if (
+      z.hasOwnProperty('name') &&
+      z.name !== undefined &&
+      typeof z.name === 'string'
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })(myDog)
+);
+```
+
+يجب أن يحتوي `myDog` على الخاصية `legs`, ويجب أن تكون الخاصية بنوع `number`.
+
+```js
+assert(
+  (function (z) {
+    if (
+      z.hasOwnProperty('legs') &&
+      z.legs !== undefined &&
+      typeof z.legs === 'number'
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })(myDog)
+);
+```
+
+يجب أن يحتوي `myDog` على الخاصية `tails`, ويجب أن تكون الخاصية بنوع `number`.
+
+```js
+assert(
+  (function (z) {
+    if (
+      z.hasOwnProperty('tails') &&
+      z.tails !== undefined &&
+      typeof z.tails === 'number'
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })(myDog)
+);
+```
+
+يجب أن يحتوي `myDog` على الخاصية `friends`, ويجب أن تكون الخاصية بنوع `array`.
+
+```js
+assert(
+  (function (z) {
+    if (
+      z.hasOwnProperty('friends') &&
+      z.friends !== undefined &&
+      Array.isArray(z.friends)
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })(myDog)
+);
+```
+
+يجب أن يحتوي `myDog` على جميع الخصائص المعطاة فقط.
+
+```js
+assert(
+  (function (z) {
+    return Object.keys(z).length === 4;
+  })(myDog)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myDog);
+```
+
+## --seed-contents--
+
+```js
+const myDog = {
+  // Only change code below this line
+
+
+  // Only change code above this line
+};
+```
+
+# --solutions--
+
+```js
+const myDog = {
+  "name": "Camper",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["everything!"]
+};
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/chaining-if-else-statements.md

@@ -0,0 +1,149 @@
+---
+id: 56533eb9ac21ba0edf2244dc
+title: تَسلسل تعبيرات If Else الشرطية
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/caeJgsw'
+forumTopicId: 16772
+dashedName: chaining-if-else-statements
+---
+
+# --description--
+
+يمكن تسلسل -ربط- عدة تعبيرات `if/else` معًا في السياقات المنطقية المعقدة. إليك مثال من <dfn>pseudocode</dfn> أو ما يسمى بالتعليمات البرمجية الزائفة -وهن التعليمات الغير مرتبط بلغة برمجة معينة ولكنه قريب من لغة الإنسان- لعدة تعبير `if` و `else if`:
+
+```js
+if (condition1) {
+  statement1
+} else if (condition2) {
+  statement2
+} else if (condition3) {
+  statement3
+. . .
+} else {
+  statementN
+}
+```
+
+# --instructions--
+
+اكتب تعبيرات متسلسلة `if`/`else if` للتحقق من الشروط التالية:
+
+`num < 5` - تنتج (return) `Tiny`  
+`num < 10` - تنتج (return) `Small`  
+`num < 15` - تنتج (return) `Medium`  
+`num < 20` - تنتج (return) `Large`  
+`num >= 20` - تنتج (return) `Huge`
+
+# --hints--
+
+يجب أن يكون لديك في الأقل أربع تعبيرات `else`
+
+```js
+assert(code.match(/else/g).length > 3);
+```
+
+يجب أن يكون لديك في الأقل أربع تعبيرات `if`
+
+```js
+assert(code.match(/if/g).length > 3);
+```
+
+يجب أن يكون لديك في الأقل تعبير `return`
+
+```js
+assert(code.match(/return/g).length >= 1);
+```
+
+`testSize(0)` يجب ان تنتج (return) المقطع (string) `Tiny`
+
+```js
+assert(testSize(0) === 'Tiny');
+```
+
+`testSize(4)` يجب ان تنتج (return) المقطع (string) `Tiny`
+
+```js
+assert(testSize(4) === 'Tiny');
+```
+
+`testSize(5)` يجب ان تنتج (return) المقطع (string) `Small`
+
+```js
+assert(testSize(5) === 'Small');
+```
+
+`testSize(8)` يجب ان تنتج (return) المقطع (string) `Small`
+
+```js
+assert(testSize(8) === 'Small');
+```
+
+`testSize(10)` يجب ان تنتج (return) المقطع (string) `Medium`
+
+```js
+assert(testSize(10) === 'Medium');
+```
+
+`testSize(14)` يجب ان تنتج (return) المقطع (string) `Medium`
+
+```js
+assert(testSize(14) === 'Medium');
+```
+
+`testSize(15)` يجب ان تنتج (return) المقطع (string) `Large`
+
+```js
+assert(testSize(15) === 'Large');
+```
+
+`testSize(17)` يجب ان تنتج (return) المقطع (string) `Large`
+
+```js
+assert(testSize(17) === 'Large');
+```
+
+`testSize(20)` يجب ان تنتج (return) المقطع (string) `Huge`
+
+```js
+assert(testSize(20) === 'Huge');
+```
+
+`testSize(25)` يجب ان تنتج (return) المقطع (string) `Huge`
+
+```js
+assert(testSize(25) === 'Huge');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testSize(num) {
+  // Only change code below this line
+
+
+  return "Change Me";
+  // Only change code above this line
+}
+
+testSize(7);
+```
+
+# --solutions--
+
+```js
+function testSize(num) {
+  if (num < 5) {
+    return "Tiny";
+  } else if (num < 10) {
+    return "Small";
+  } else if (num < 15) {
+    return "Medium";
+  } else if (num < 20) {
+    return "Large";
+  } else {
+    return "Huge";
+  }
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/comment-your-javascript-code.md

@@ -0,0 +1,63 @@
+---
+id: bd7123c9c441eddfaeb4bdef
+title: التعليق علي تعليماتك البرمجية في JavaScript
+challengeType: 1
+removeComments: false
+videoUrl: 'https://scrimba.com/c/c7ynnTp'
+forumTopicId: 16783
+dashedName: comment-your-javascript-code
+---
+
+# --description--
+
+التعليقات هي أسطر من التعليمات البرمجية التي سيتجاهلها JavaScript عمداً. التعليقات هي طريقة رائعة لترك الملاحظات لنفسك وللأشخاص الآخرين الذين سيحتاجون لاحقاً إلى معرفة ما تفعله تلك التعليمات البرمجية.
+
+هناك طريقتان لكتابة التعليقات في JavaScript:
+
+استخدام `//` سيخبر JavaScript بتجاهل بقية النص في السطر الحالي. وهذه طريقة كتابة تعليق من سطر واحد:
+
+```js
+// This is an in-line comment.
+```
+
+يمكنك إنشاء تعليق متعدد الأسطر يبدأ من `/*` وينتهي في `*/`. وهذا تعليق متعدد الأسطر:
+
+```js
+/* This is a
+multi-line comment */
+```
+
+**ملاحظة:** عند كتابة التعليمات البرمجية، يجب عليك إضافة تعليقات بانتظام لتوضيح وظيفة أجزاء من التعليمات البرمجية الخاص بك. التعليق الجيد يمكن أن يساعد على إيصال المغزى من التعليمات البرمجية الخاص بك - للآخرين *و* لنفسك في المستقبل.
+
+# --instructions--
+
+حاول إنشاء واحد من كل نوع من التعليقات.
+
+# --hints--
+
+يجب عليك إنشاء تعليق باستخدام `//` يحتوي على خمس أحرف في الأقل.
+
+```js
+assert(code.match(/(\/\/)...../g));
+```
+
+يجب عليك إنشاء تعليق باستخدام `/* */` يحتوي على خمس أحرف في الأقل.
+
+```js
+assert(code.match(/(\/\*)([^\/]{5,})(?=\*\/)/gm));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+// Fake Comment
+/* Another Comment */
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator.md

@@ -0,0 +1,89 @@
+---
+id: 56533eb9ac21ba0edf2244d0
+title: المقارنات باستخدام عملية المساواة (==)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cKyVMAL'
+forumTopicId: 16784
+dashedName: comparison-with-the-equality-operator
+---
+
+# --description--
+
+هناك العديد من <dfn>عمليات المساواة</dfn> في JavaScript. كل هذه العمليات يعيدون قيمة boolean منطقية `true` أو `false`.
+
+ابسط أنواع هذه العمليات هي عملية مقارنة المساواة `==`. تقارن عملية المساواة بين قيمتين وتعيد `true` إذا كانتا القيمتين متساويتين أو `false` إذا لم تكونا متساويتين. لاحظ أن المساواة تختلف عن تعيين (`=`)، التي تعطي القيمة على يمين العملية إلى متغير على يسارها.
+
+```js
+function equalityTest(myVal) {
+  if (myVal == 10) {
+    return "Equal";
+  }
+  return "Not Equal";
+}
+```
+
+إذا كانت قيمة `myVal` تساوي `10`، عملية المساواة تعيد `true`، و بهذا سيتم تنفيذ التعليمات البرمجية في الأقواس، وستعيد الدالة `Equal`. وإلا فإن الوظيفة ستعيد `Not Equal`. لكي تقوم JavaScript بمقارنة نوعين مختلفين في ا <dfn> نوع البيانات</dfn> (على سبيل المثال، مقارنة بين نوع `numbers` و نوع `strings`)، يجب أن تحول احدمها إلى نوع الآخر. هذا يُعرف بالقسر النوع (Type Coercion). بمجرد فعل ذلك، يتمكن Javascript من المقارنة بين المصطلحات التالية:
+
+```js
+1   ==  1  // true
+1   ==  2  // false
+1   == '1' // true
+"3" ==  3  // true
+```
+
+# --instructions--
+
+اضف عملية المساواة إلى المكان المشار أليه كي تعيد الوظيفة `Equal` إذا تساوي `val` قيمة `12`.
+
+# --hints--
+
+يجب أن `testEqual(10)` تعيد `Not Equal`
+
+```js
+assert(testEqual(10) === 'Not Equal');
+```
+
+يجب أن `testEqual(12)` تعيد `Equal`
+
+```js
+assert(testEqual(12) === 'Equal');
+```
+
+يجب أن `testEqual("12")` تعيد `Equal`
+
+```js
+assert(testEqual('12') === 'Equal');
+```
+
+يجب عليك أن تستخدم العملية `==`
+
+```js
+assert(code.match(/==/g) && !code.match(/===/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function testEqual(val) {
+  if (val) { // Change this line
+    return "Equal";
+  }
+  return "Not Equal";
+}
+
+testEqual(10);
+```
+
+# --solutions--
+
+```js
+function testEqual(val) {
+  if (val == 12) {
+    return "Equal";
+  }
+  return "Not Equal";
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-operator.md

@@ -0,0 +1,111 @@
+---
+id: 56533eb9ac21ba0edf2244d4
+title: المقارنات باستخدام مشغل أكبر من (>)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cp6GbH4'
+forumTopicId: 16786
+dashedName: comparison-with-the-greater-than-operator
+---
+
+# --description--
+
+مشغل أكبر من (`>`) يقارن بين قيم رقمين. إذا كان الرَّقَم إلى اليسار أكبر من الرَّقَم إلى اليمين (لأن التعليمات البرمجية بالإنكليزية)، فإنه ينتج `true`. خلاف ذلك، فإنه ينتج `false`.
+
+وعلى غرار المشغل المعني بالمساواة، فإن مشغل أكبر من سيحول أنواع البيانات من القيم عند مقارنتها.
+
+**على سبيل المثال**
+
+```js
+5   >  3  // true
+7   > '3' // true
+2   >  3  // false
+'1' >  9  // false
+```
+
+# --instructions--
+
+أضف مشغل أكبر من (<) إلى الخطوط المشار إليها بحيث تكون التعبيرات المنتجة منطقية.
+
+# --hints--
+
+يجب أن ينتج `testGreaterThan(0)` مقطع نصي `10 or Under`
+
+```js
+assert(testGreaterThan(0) === '10 or Under');
+```
+
+يجب أن ينتج `testGreaterThan(10)` مقطع نصي `10 or Under`
+
+```js
+assert(testGreaterThan(10) === '10 or Under');
+```
+
+يجب أن ينتج `testGreaterThan(11)` مقطع نصي `Over 10`
+
+```js
+assert(testGreaterThan(11) === 'Over 10');
+```
+
+يجب أن ينتج `testGreaterThan(99)` مقطع نصي `Over 10`
+
+```js
+assert(testGreaterThan(99) === 'Over 10');
+```
+
+يجب أن ينتج `testGreaterThan(100)` مقطع نصي `Over 10`
+
+```js
+assert(testGreaterThan(100) === 'Over 10');
+```
+
+يجب أن ينتج `testGreaterThan(101)` مقطع نصي `Over 100`
+
+```js
+assert(testGreaterThan(101) === 'Over 100');
+```
+
+يجب أن ينتج `testGreaterThan(150)` مقطع نصي `Over 100`
+
+```js
+assert(testGreaterThan(150) === 'Over 100');
+```
+
+يجب عليك استخدام مشغل `>` مرتين في الأقل
+
+```js
+assert(code.match(/val\s*>\s*('|")*\d+('|")*/g).length > 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testGreaterThan(val) {
+  if (val) {  // Change this line
+    return "Over 100";
+  }
+
+  if (val) {  // Change this line
+    return "Over 10";
+  }
+
+  return "10 or Under";
+}
+
+testGreaterThan(10);
+```
+
+# --solutions--
+
+```js
+function testGreaterThan(val) {
+  if (val > 100) {  // Change this line
+    return "Over 100";
+  }
+  if (val > 10) {  // Change this line
+    return "Over 10";
+  }
+  return "10 or Under";
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-or-equal-to-operator.md

@@ -0,0 +1,113 @@
+---
+id: 56533eb9ac21ba0edf2244d5
+title: المقارنات باستخدام مشغل أكبر من أو يساوي (=>)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c6KBqtV'
+forumTopicId: 16785
+dashedName: comparison-with-the-greater-than-or-equal-to-operator
+---
+
+# --description--
+
+يقارن مشغل أكبر من أو يساوي (`>=`) بين قيمتين لرقمين. إذا كان الرَّقَم إلى اليسار أكبر من لو يساوي الرَّقَم إلى اليمين، فإنه يرجع `true`. خلاف ذلك، فإنه يرجع `false`.
+
+وعلى غرار المشغل المعني بالمساواة، سيحول مشغل أكبر من أو يساوي أنواع البيانات من القيم عند مقارنتها.
+
+**على سبيل المثال**
+
+```js
+6   >=  6  // true
+7   >= '3' // true
+2   >=  3  // false
+'7' >=  9  // false
+```
+
+# --instructions--
+
+أضف أكبر من أو يساوي إلى الخطوط المشار إليها بحيث تكون عبارات المراجعة منطقية.
+
+# --hints--
+
+يجب أن ينتج `testGreaterOrEqual(0)` مقطع `Less than 10`
+
+```js
+assert(testGreaterOrEqual(0) === 'Less than 10');
+```
+
+يجب أن ينتج `testGreaterOrEqual(9)` مقطع `Less than 10`
+
+```js
+assert(testGreaterOrEqual(9) === 'Less than 10');
+```
+
+يجب أن ينتج `testGreaterOrEqual(10)` مقطع `10 or Over`
+
+```js
+assert(testGreaterOrEqual(10) === '10 or Over');
+```
+
+يجب أن ينتج `testGreaterOrEqual(11)` مقطع `10 or Over`
+
+```js
+assert(testGreaterOrEqual(11) === '10 or Over');
+```
+
+يجب أن ينتج `testGreaterOrEqual(19)` مقطع `10 or Over`
+
+```js
+assert(testGreaterOrEqual(19) === '10 or Over');
+```
+
+يجب أن ينتج `testGreaterOrEqual(100)` مقطع `20 or Over`
+
+```js
+assert(testGreaterOrEqual(100) === '20 or Over');
+```
+
+يجب أن ينتج `testGreaterOrEqual(21)` مقطع `20 or Over`
+
+```js
+assert(testGreaterOrEqual(21) === '20 or Over');
+```
+
+يجب عليك استخدام مشغل `>=` مرتين في الأقل
+
+```js
+assert(code.match(/val\s*>=\s*('|")*\d+('|")*/g).length > 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testGreaterOrEqual(val) {
+  if (val) {  // Change this line
+    return "20 or Over";
+  }
+
+  if (val) {  // Change this line
+    return "10 or Over";
+  }
+
+  return "Less than 10";
+}
+
+testGreaterOrEqual(10);
+```
+
+# --solutions--
+
+```js
+function testGreaterOrEqual(val) {
+  if (val >= 20) {  // Change this line
+    return "20 or Over";
+  }
+
+  if (val >= 10) {  // Change this line
+    return "10 or Over";
+  }
+
+  return "Less than 10";
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-inequality-operator.md

@@ -0,0 +1,91 @@
+---
+id: 56533eb9ac21ba0edf2244d2
+title: المقارنات باستخدام مشغل لا مساواة (!=)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cdBm9Sr'
+forumTopicId: 16787
+dashedName: comparison-with-the-inequality-operator
+---
+
+# --description--
+
+مشغل لا مساواة (`!=`) هو يخالف مشغل المساواة. وهذا يعني لا مساواة يرجع `false` عندما ترجع المساواة `true` و*العكس كذلك*. وعلى غرار المشغل المعني بالمساواة، فإن مشغل لا مساواة سيحول أنواع البيانات من القيم عند مقارنتها.
+
+**على سبيل المثال**
+
+```js
+1 !=  2    // true
+1 != "1"   // false
+1 != '1'   // false
+1 != true  // false
+0 != false // false
+```
+
+# --instructions--
+
+أضف مشغل لا مساواة `!=` في `if` بحيث تقوم الوظيفة بإنشاء مقطع الآتي `Not Equal` عندما لا يساوي `val` القيمة `99`.
+
+# --hints--
+
+يجب أن ينتج `testNotEqual(99)` مقطع `Equal`
+
+```js
+assert(testNotEqual(99) === 'Equal');
+```
+
+يجب أن ينتج `testNotEqual("99")` مقطع `Equal`
+
+```js
+assert(testNotEqual('99') === 'Equal');
+```
+
+يجب أن ينتج `testNotEqual(12)` مقطع `Not Equal`
+
+```js
+assert(testNotEqual(12) === 'Not Equal');
+```
+
+يجب أن ينتج `testNotEqual("12")` مقطع `Not Equal`
+
+```js
+assert(testNotEqual('12') === 'Not Equal');
+```
+
+يجب أن ينتج `testNotEqual("bob")` مقطع `Not Equal`
+
+```js
+assert(testNotEqual('bob') === 'Not Equal');
+```
+
+يجب عليك استخدام المشغل `!=`
+
+```js
+assert(code.match(/(?!!==)!=/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function testNotEqual(val) {
+  if (val) { // Change this line
+    return "Not Equal";
+  }
+  return "Equal";
+}
+
+testNotEqual(10);
+```
+
+# --solutions--
+
+```js
+function testNotEqual(val) {
+  if (val != 99) {
+    return "Not Equal";
+  }
+  return "Equal";
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-operator.md

@@ -0,0 +1,106 @@
+---
+id: 56533eb9ac21ba0edf2244d6
+title: المقارنات باستخدام مشغل ألأصغر من (>)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cNVRWtB'
+forumTopicId: 16789
+dashedName: comparison-with-the-less-than-operator
+---
+
+# --description--
+
+يقارن مشغل آلأصغر من (`<`) بين قيمتين رقمين. إذا كان الرَّقَم إلى اليسار أصغر من الرَّقَم إلى اليمين، فإنه يرجع `true`. خلاف ذلك، فإنه يرجع `false`. وعلى غرار المشغل المعني بالمساواة، يقوم المشغل أقل من بتحويل أنواع البيانات عند مقارنتها.
+
+**مثال**
+
+```js
+2   < 5 // true
+'3' < 7 // true
+5   < 5 // false
+3   < 2 // false
+'8' < 4 // false
+```
+
+# --instructions--
+
+أضف مشغل أقل من إلى الخطوط المشار إليها بحيث تكون تعبيرات مراجعة منطقية.
+
+# --hints--
+
+يجب أن ينتج `testLessThan(0)` مقطع `Under 25`
+
+```js
+assert(testLessThan(0) === 'Under 25');
+```
+
+يجب أن ينتج `testLessThan(24)` مقطع `Under 25`
+
+```js
+assert(testLessThan(24) === 'Under 25');
+```
+
+يجب أن ينتج `testLessThan(25)` مقطع `Under 55`
+
+```js
+assert(testLessThan(25) === 'Under 55');
+```
+
+يجب أن ينتج `testLessThan(54)` مقطع `Under 55`
+
+```js
+assert(testLessThan(54) === 'Under 55');
+```
+
+يجب أن ينتج `testLessThan(55)` مقطع `55 or Over`
+
+```js
+assert(testLessThan(55) === '55 or Over');
+```
+
+يجب أن ينتج `testLessThan(99)` مقطع `55 or Over`
+
+```js
+assert(testLessThan(99) === '55 or Over');
+```
+
+يجب عليك استخدام مشغل `<` مرتين في الأقل
+
+```js
+assert(code.match(/val\s*<\s*('|")*\d+('|")*/g).length > 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testLessThan(val) {
+  if (val) {  // Change this line
+    return "Under 25";
+  }
+
+  if (val) {  // Change this line
+    return "Under 55";
+  }
+
+  return "55 or Over";
+}
+
+testLessThan(10);
+```
+
+# --solutions--
+
+```js
+function testLessThan(val) {
+  if (val < 25) {  // Change this line
+    return "Under 25";
+  }
+
+  if (val < 55) {  // Change this line
+    return "Under 55";
+  }
+
+  return "55 or Over";
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-or-equal-to-operator.md

@@ -0,0 +1,112 @@
+---
+id: 56533eb9ac21ba0edf2244d7
+title: المقارنات باستخدام مشغل اصغر من أو يساوي
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cNVR7Am'
+forumTopicId: 16788
+dashedName: comparison-with-the-less-than-or-equal-to-operator
+---
+
+# --description--
+
+مشغل اصغر من أو يساوي، (`<=`) يقارن بين قيم رقمين. إذا كان الرَّقَم إلى اليسار أقل من أو يساوي الرَّقَم إلى اليمين، فإنه يعيد `true`. إذا كان الرَّقَم الموجود على اليسار أكبر من الرَّقَم الموجود على اليمين، فإنه يعيد `false`. وعلى غرار المشغل المعني بالمساواة، يحول مشغل اصغر من أو يساوي أنواع البيانات من القيم عند مقارنتها.
+
+**مثال**
+
+```js
+4   <= 5 // true
+'7' <= 7 // true
+5   <= 5 // true
+3   <= 2 // false
+'8' <= 4 // false
+```
+
+# --instructions--
+
+أضف مشغل اصغر من أو يساوي إلى السطور المشار إليها بحيث تكون تعبيرات المراجعة منطقية.
+
+# --hints--
+
+يجب أن ينتج `testLessOrEqual(0)` المقطع `Smaller Than or Equal to 12`
+
+```js
+assert(testLessOrEqual(0) === 'Smaller Than or Equal to 12');
+```
+
+يجب أن ينتج `testLessOrEqual(11)` مقطع `Smaller Than or Equal to 12`
+
+```js
+assert(testLessOrEqual(11) === 'Smaller Than or Equal to 12');
+```
+
+يجب أن ينتج `testLessOrEqual(12)` مقطع `Smaller Than or Equal to 12`
+
+```js
+assert(testLessOrEqual(12) === 'Smaller Than or Equal to 12');
+```
+
+يجب أن ينتج `testLessOrEqual(23)` مقطع `Smaller Than or Equal to 24`
+
+```js
+assert(testLessOrEqual(23) === 'Smaller Than or Equal to 24');
+```
+
+يجب أن ينتج `testLessOrEqual(24)` مقطع `Smaller Than or Equal to 24`
+
+```js
+assert(testLessOrEqual(24) === 'Smaller Than or Equal to 24');
+```
+
+يجب أن ينتج `testLessOrEqual(25)` مقطع `More Than 24`
+
+```js
+assert(testLessOrEqual(25) === 'More Than 24');
+```
+
+يجب أن ينتج `testLessOrEqual(55)` مقطع `More Than 24`
+
+```js
+assert(testLessOrEqual(55) === 'More Than 24');
+```
+
+يجب عليك استخدام مشغل `<=` مرتين في الأقل
+
+```js
+assert(code.match(/val\s*<=\s*('|")*\d+('|")*/g).length > 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testLessOrEqual(val) {
+  if (val) {  // Change this line
+    return "Smaller Than or Equal to 12";
+  }
+
+  if (val) {  // Change this line
+    return "Smaller Than or Equal to 24";
+  }
+
+  return "More Than 24";
+}
+
+testLessOrEqual(10);
+```
+
+# --solutions--
+
+```js
+function testLessOrEqual(val) {
+  if (val <= 12) {  // Change this line
+    return "Smaller Than or Equal to 12";
+  }
+
+  if (val <= 24) {  // Change this line
+    return "Smaller Than or Equal to 24";
+  }
+
+  return "More Than 24";
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator.md

@@ -0,0 +1,80 @@
+---
+id: 56533eb9ac21ba0edf2244d1
+title: المقارنات باستخدام المساواة الصارمة
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cy87atr'
+forumTopicId: 16790
+dashedName: comparison-with-the-strict-equality-operator
+---
+
+# --description--
+
+يكون مشغل المساواة الصارمة (`===`) نظير مشغل المساواة (`==`). ومع ذلك، وخلافاً لمشغل المساواة، الذي يحاول تحويل القيمتين إلى نوع مشترك، لا يقوم مشغل المساواة الصارمة (strict equality) بإجراء تحويل من نوع إلى آخر.
+
+وإذا كانت القيم التي تجري مقارنتها ذات أنواع مختلفة، فإنها تعدّ غير متساوية، وسيعيد مشغل المساواة الصارمة القيمة false.
+
+**على سبيل المثال**
+
+```js
+3 ===  3  // true
+3 === '3' // false
+```
+
+في المثال الثاني، تكون `3` من نوع `Number` ويكون `'3'` من نوع `String`.
+
+# --instructions--
+
+استخدام مشغل المساواة الصارمة في بيان `if` حتي تنتج الوظيفة مقطع باسم `Equal` عندما يكون `val` مساوية بطريقة صارمة (strictly equal) إلى `7`.
+
+# --hints--
+
+يجب أن ينتج `testStrict(10)` مقطع `Not Equal`
+
+```js
+assert(testStrict(10) === 'Not Equal');
+```
+
+يجب أن ينتج `testStrict(7)` مقطع `Equal`
+
+```js
+assert(testStrict(7) === 'Equal');
+```
+
+يجب أن ينتج `testStrict("7")` مقطع `Not Equal`
+
+```js
+assert(testStrict('7') === 'Not Equal');
+```
+
+يجب عليك استخدام مشغل `===`
+
+```js
+assert(code.match(/(val\s*===\s*\d+)|(\d+\s*===\s*val)/g).length > 0);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function testStrict(val) {
+  if (val) { // Change this line
+    return "Equal";
+  }
+  return "Not Equal";
+}
+
+testStrict(10);
+```
+
+# --solutions--
+
+```js
+function testStrict(val) {
+  if (val === 7) {
+    return "Equal";
+  }
+  return "Not Equal";
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-inequality-operator.md

@@ -0,0 +1,83 @@
+---
+id: 56533eb9ac21ba0edf2244d3
+title: المقارنات باستخدام لا مساواة الصارمة
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cKekkUy'
+forumTopicId: 16791
+dashedName: comparison-with-the-strict-inequality-operator
+---
+
+# --description--
+
+مشغل لا مساواة الصارمة (`!==`) هو المضاد المنطقي لمشغل المساواة الصارمة. إنه يعني "ليس متساوياً تماماً" (Strictly Not Equal) ويعيد `false` عندما تعيد المساواة الصارمة `true` و *العكس صحيح*. ولن يحول مشغِّل لا المساواة الصارمة أنواع البيانات.
+
+**على سبيل المثال**
+
+```js
+3 !==  3  // false
+3 !== '3' // true
+4 !==  3  // true
+```
+
+# --instructions--
+
+استخدام مشغل لا مساواة صارمة في تعبير `if` حتي تعيد الوظيفة مقطع `Not Equal` عندما يكون `val` لا مساواة صارمة إلى `17`
+
+# --hints--
+
+يجب أن ينتج `testStrictNotEqual(17)` مقطع `Equal`
+
+```js
+assert(testStrictNotEqual(17) === 'Equal');
+```
+
+يجب أن ينتج `testStrictNotEqual("17")` مقطع `Not Equal`
+
+```js
+assert(testStrictNotEqual('17') === 'Not Equal');
+```
+
+يجب أن ينتج `testStrictNotEqual(12)` مقطع `Not Equal`
+
+```js
+assert(testStrictNotEqual(12) === 'Not Equal');
+```
+
+يجب أن ينتج `testStrictNotEqual("bob")` مقطع `Not Equal`
+
+```js
+assert(testStrictNotEqual('bob') === 'Not Equal');
+```
+
+يجب عليك استخدام المشغل `!==`
+
+```js
+assert(code.match(/(val\s*!==\s*\d+)|(\d+\s*!==\s*val)/g).length > 0);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function testStrictNotEqual(val) {
+  if (val) { // Change this line
+    return "Not Equal";
+  }
+  return "Equal";
+}
+
+testStrictNotEqual(10);
+```
+
+# --solutions--
+
+```js
+function testStrictNotEqual(val) {
+  if (val !== 17) {
+    return "Not Equal";
+  }
+  return "Equal";
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-and-operator.md

@@ -0,0 +1,130 @@
+---
+id: 56533eb9ac21ba0edf2244d8
+title: المقارنات باستخدام مشغل الإضافة المنطقي (&&)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cvbRVtr'
+forumTopicId: 16799
+dashedName: comparisons-with-the-logical-and-operator
+---
+
+# --description--
+
+ستحتاج أحيانًا إلى اختبار أكثر من شيء في وقت واحد. مشغل <dfn>الإضافة المنطقي</dfn> ورمزه (`&&`) يرجع `true` فقط إذا كان <dfn>المعاملتين</dfn> إلى اليسار واليمين صحيحين.
+
+ويمكن تحقيق نفس التأثير عن طريق أدخال if statement داخل if أخري:
+
+```js
+if (num > 5) {
+  if (num < 10) {
+    return "Yes";
+  }
+}
+return "No";
+```
+
+سوف يعيد `Yes` فقط إذا كان `num` أكبر من `5` وأقل من `10`. ويمكن كتابة نفس المنطق كما يلي:
+
+```js
+if (num > 5 && num < 10) {
+  return "Yes";
+}
+return "No";
+```
+
+# --instructions--
+
+استبدل بيانين if إلى if statement واحدة، باستخدام المشغل `&&`، الذي سوف يعيد المقطع `Yes` إذا كان `val` أقل من أو يساوي `50` وأكثر من أو يساوي `25`. خلاف ذلك، سوف يعيد المقطع `No`.
+
+# --hints--
+
+يجب عليك استخدام المشغل `&&` مرة واحدة
+
+```js
+assert(code.match(/&&/g).length === 1);
+```
+
+يجب أن يكون لديك بيان `if` واحد فقط
+
+```js
+assert(code.match(/if/g).length === 1);
+```
+
+يجب أن ينتج `testLogicalAnd(0)` مقطع `No`
+
+```js
+assert(testLogicalAnd(0) === 'No');
+```
+
+يجب أن ينتج `testLogicalAnd(24)` المقطع `No`
+
+```js
+assert(testLogicalAnd(24) === 'No');
+```
+
+يجب أن ينتج `testLogicalAnd(25)` المقطع `Yes`
+
+```js
+assert(testLogicalAnd(25) === 'Yes');
+```
+
+يجب أن ينتج `testLogicalAnd(30)` المقطع `Yes`
+
+```js
+assert(testLogicalAnd(30) === 'Yes');
+```
+
+يجب أن ينتج `testLogicalAnd(50)` المقطع `Yes`
+
+```js
+assert(testLogicalAnd(50) === 'Yes');
+```
+
+يجب أن ينتج `testLogicalAnd(51)` المقطع `No`
+
+```js
+assert(testLogicalAnd(51) === 'No');
+```
+
+يجب أن ينتج `testLogicalAnd(75)` المقطع `No`
+
+```js
+assert(testLogicalAnd(75) === 'No');
+```
+
+يجب أن ينتج `testLogicalAnd(80)` المقطع `No`
+
+```js
+assert(testLogicalAnd(80) === 'No');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testLogicalAnd(val) {
+  // Only change code below this line
+
+  if (val) {
+    if (val) {
+      return "Yes";
+    }
+  }
+
+  // Only change code above this line
+  return "No";
+}
+
+testLogicalAnd(10);
+```
+
+# --solutions--
+
+```js
+function testLogicalAnd(val) {
+  if (val >= 25 && val <= 50) {
+    return "Yes";
+  }
+  return "No";
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-or-operator.md

@@ -0,0 +1,135 @@
+---
+id: 56533eb9ac21ba0edf2244d9
+title: المقارنات باستخدام مشغل إي من المنطقي
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cEPrGTN'
+forumTopicId: 16800
+dashedName: comparisons-with-the-logical-or-operator
+---
+
+# --description--
+
+يرجع مشغل <dfn>إي من</dfn> الآتي (`||`) القيمة `true` إذا كان أي من <dfn>المعاملتين</dfn> هما `true`. خلاف ذلك، فإنه يرجع `false`.
+
+يتكون مشغل <dfn>المعاملات</dfn> من رمزين و هما خطين مستقيمين ألآتيه: (`||`). يمكن العثور على هذا الرمز عادة بين مفاتيح Backspace و Enter.
+
+يجب أن يبدو النمط أدناه مألوفًا من الدروس السابقة:
+
+```js
+if (num > 10) {
+  return "No";
+}
+if (num < 5) {
+  return "No";
+}
+return "Yes";
+```
+
+سوف يعيد `Yes` فقط إذا كان `num` بين `5` و `10` (5 و 10 مشمولين). ويمكن كتابة نفس المنطق كما يلي:
+
+```js
+if (num > 10 || num < 5) {
+  return "No";
+}
+return "Yes";
+```
+
+# --instructions--
+
+قم بدمج تعبيرات `if` في تعبير واحدة تعيد المقطع `Outside` إذا كان `val` ليس بين `10` و `20` بشمول 10 و 20. خلاف ذلك، ارجع المقطع `Inside`.
+
+# --hints--
+
+يجب عليك استخدام المشغل `||` مرة واحدة
+
+```js
+assert(code.match(/\|\|/g).length === 1);
+```
+
+يجب أن يكون لديك تعبير `if` واحد فقط
+
+```js
+assert(code.match(/if/g).length === 1);
+```
+
+يجب أن ينتج `testLogicalOr(0)` مقطع `Outside`
+
+```js
+assert(testLogicalOr(0) === 'Outside');
+```
+
+يجب أن ينتج `testLogicalOr(9)` مقطع `Outside`
+
+```js
+assert(testLogicalOr(9) === 'Outside');
+```
+
+يجب أن ينتج `testLogicalOr(10)` مقطع `Inside`
+
+```js
+assert(testLogicalOr(10) === 'Inside');
+```
+
+يجب أن ينتج `testLogicalOr(15)` مقطع `Inside`
+
+```js
+assert(testLogicalOr(15) === 'Inside');
+```
+
+يجب أن ينتج `testLogicalOr(19)` مقطع `Inside`
+
+```js
+assert(testLogicalOr(19) === 'Inside');
+```
+
+يجب أن ينتج `testLogicalOr(20)` مقطع `Inside`
+
+```js
+assert(testLogicalOr(20) === 'Inside');
+```
+
+يجب أن ينتج `testLogicalOr(21)` مقطع `Outside`
+
+```js
+assert(testLogicalOr(21) === 'Outside');
+```
+
+يجب أن ينتج `testLogicalOr(25)` مقطع `Outside`
+
+```js
+assert(testLogicalOr(25) === 'Outside');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testLogicalOr(val) {
+  // Only change code below this line
+
+  if (val) {
+    return "Outside";
+  }
+
+  if (val) {
+    return "Outside";
+  }
+
+  // Only change code above this line
+  return "Inside";
+}
+
+testLogicalOr(15);
+```
+
+# --solutions--
+
+```js
+function testLogicalOr(val) {
+  if (val < 10 || val > 20) {
+    return "Outside";
+  }
+  return "Inside";
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-addition.md

@@ -0,0 +1,101 @@
+---
+id: 56533eb9ac21ba0edf2244af
+title: التخصيص المركب مع الجمع المعزز (Compound Assignment With Augmented Addition)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cDR6LCb'
+forumTopicId: 16661
+dashedName: compound-assignment-with-augmented-addition
+---
+
+# --description--
+
+في البرمجة، من الشائع استخدام assignments (التعيينات) لتعديل محتوي المتغير. تذكر أن كل شيء إلى يمين علامة المساواة يتم تقييمه أولا، لذلك يمكننا القول:
+
+```js
+myVar = myVar + 5;
+```
+
+لإضافة `5` إلى `myVar`. نظرًا لأن هذا نمط شائع، فهناك مشغلين يقوموا بعملية رياضية وتعيين في خطوة واحدة.
+
+أحد هؤلاء المشغلين هو مشغل `+=`.
+
+```js
+let myVar = 1;
+myVar += 5;
+console.log(myVar);
+```
+
+سوف يتم عرض `6` في وحدة التحكم.
+
+# --instructions--
+
+تحويل التعيينات `a`, و `b`, و `c` لتستخدم المشغل `+=`.
+
+# --hints--
+
+يجب أن يساوي `a` قيمة `15`.
+
+```js
+assert(a === 15);
+```
+
+يجب أن يساوي `b` قيمة `26`.
+
+```js
+assert(b === 26);
+```
+
+يجب أن يساوي `c` قيمة `19`.
+
+```js
+assert(c === 19);
+```
+
+يجب عليك استخدام مشغل `+=` لكل متغير.
+
+```js
+assert(code.match(/\+=/g).length === 3);
+```
+
+لا يجب عليك تعديل الكود فوق التعليق المحدد.
+
+```js
+assert(
+  /let a = 3;/.test(code) &&
+    /let b = 17;/.test(code) &&
+    /let c = 12;/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+let a = 3;
+let b = 17;
+let c = 12;
+
+// Only change code below this line
+a = a + 12;
+b = 9 + b;
+c = c + 7;
+```
+
+# --solutions--
+
+```js
+let a = 3;
+let b = 17;
+let c = 12;
+
+a += 12;
+b += 9;
+c += 7;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-division.md

@@ -0,0 +1,95 @@
+---
+id: 56533eb9ac21ba0edf2244b2
+title: التخصيص المركب مع التقسيم المعزز (Compound Assignment With Augmented Division)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2QvKT2'
+forumTopicId: 16659
+dashedName: compound-assignment-with-augmented-division
+---
+
+# --description--
+
+يقوم المشغل `/=` بتقسيم متغير علي رَقَم أخر.
+
+```js
+myVar = myVar / 5;
+```
+
+سيتم تقسيم `myVar` علي `5`. ويمكن إعادة كتابة هذا على النحو التالي:
+
+```js
+myVar /= 5;
+```
+
+# --instructions--
+
+حول التعيينات `a`, و `b`, و `c` لتستخدم المشغل `/=`.
+
+# --hints--
+
+يجب أن يساوي `a` قيمة `4`.
+
+```js
+assert(a === 4);
+```
+
+يجب أن يساوي `b` قيمة `27`.
+
+```js
+assert(b === 27);
+```
+
+يجب أن يساوي `c` قيمة `3`.
+
+```js
+assert(c === 3);
+```
+
+يجب عليك استخدام مشغل `/=` لكل متغير.
+
+```js
+assert(code.match(/\/=/g).length === 3);
+```
+
+لا يجب عليك تعديل الكود فوق التعليق المحدد.
+
+```js
+assert(
+  /let a = 48;/.test(code) &&
+    /let b = 108;/.test(code) &&
+    /let c = 33;/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+let a = 48;
+let b = 108;
+let c = 33;
+
+// Only change code below this line
+a = a / 12;
+b = b / 4;
+c = c / 11;
+```
+
+# --solutions--
+
+```js
+let a = 48;
+let b = 108;
+let c = 33;
+
+a /= 12;
+b /= 4;
+c /= 11;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-multiplication.md

@@ -0,0 +1,95 @@
+---
+id: 56533eb9ac21ba0edf2244b1
+title: التخصيص المركب مع الضرب المعزز (Compound Assignment With Augmented Multiplication)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c83vrfa'
+forumTopicId: 16662
+dashedName: compound-assignment-with-augmented-multiplication
+---
+
+# --description--
+
+يقوم المشغل `*=` مضاعفة متغير في عدد.
+
+```js
+myVar = myVar * 5;
+```
+
+سوف تضاعف `myVar` في `5`. ويمكن إعادة كتابة هذا على النحو التالي:
+
+```js
+myVar *= 5;
+```
+
+# --instructions--
+
+حول التعيينات `a`, و `b`, و `c` لتستخدم المشغل `*=`.
+
+# --hints--
+
+يجب أن يساوي `a` قيمة `25`.
+
+```js
+assert(a === 25);
+```
+
+يجب أن يساوي `b` قيمة `36`.
+
+```js
+assert(b === 36);
+```
+
+يجب أن يساوي `c` قيمة `46`.
+
+```js
+assert(c === 46);
+```
+
+يجب عليك استخدام مشغل `*=` لكل متغير.
+
+```js
+assert(code.match(/\*=/g).length === 3);
+```
+
+لا يجب عليك تعديل الكود فوق التعليق المحدد.
+
+```js
+assert(
+  /let a = 5;/.test(code) &&
+    /let b = 12;/.test(code) &&
+    /let c = 4\.6;/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+let a = 5;
+let b = 12;
+let c = 4.6;
+
+// Only change code below this line
+a = a * 5;
+b = 3 * b;
+c = c * 10;
+```
+
+# --solutions--
+
+```js
+let a = 5;
+let b = 12;
+let c = 4.6;
+
+a *= 5;
+b *= 3;
+c *= 10;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-subtraction.md

@@ -0,0 +1,93 @@
+---
+id: 56533eb9ac21ba0edf2244b0
+title: التخصيص المركب مع الطرح المعزز (Compound Assignment With Augmented Subtraction)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2Qv7AV'
+forumTopicId: 16660
+dashedName: compound-assignment-with-augmented-subtraction
+---
+
+# --description--
+
+مثل مشغل `+=`, يقوم مشغل`-=` بطرح رقماً من متغير.
+
+```js
+myVar = myVar - 5;
+```
+
+سيتم طرح `5` من `myVar`. ويمكن إعادة كتابة هذا على النحو التالي:
+
+```js
+myVar -= 5;
+```
+
+# --instructions--
+
+حول التعيينات `a`, و `b`, و `c` لتستخدم المشغل `-=`.
+
+# --hints--
+
+يجب أن يساوي `a` قيمة `5`.
+
+```js
+assert(a === 5);
+```
+
+يجب أن يساوي `b` قيمة `-6`.
+
+```js
+assert(b === -6);
+```
+
+يجب أن يساوي `c` قيمة `2`.
+
+```js
+assert(c === 2);
+```
+
+يجب عليك استخدام مشغل `-=` لكل متغير.
+
+```js
+assert(code.match(/-=/g).length === 3);
+```
+
+لا يجب عليك تعديل الكود فوق التعليق المحدد.
+
+```js
+assert(
+  /let a = 11;/.test(code) && /let b = 9;/.test(code) && /let c = 3;/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+let a = 11;
+let b = 9;
+let c = 3;
+
+// Only change code below this line
+a = a - 6;
+b = b - 15;
+c = c - 1;
+```
+
+# --solutions--
+
+```js
+let a = 11;
+let b = 9;
+let c = 3;
+
+a -= 6;
+b -= 15;
+c -= 1;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-plus-operator.md

@@ -0,0 +1,89 @@
+---
+id: 56533eb9ac21ba0edf2244b7
+title: ربط المقاطع النصية باستخدام مشغل الجمع (Concatenating Strings with Plus Operator)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cNpM8AN'
+forumTopicId: 16802
+dashedName: concatenating-strings-with-plus-operator
+---
+
+# --description--
+
+في JavaScript، عندما يستخدم مشغل `+` مع `String`، فإنه يسمى مشغل <dfn>سلسلة</dfn>. يمكنك بناء مقطع جديد من المقاطع الأخرى من طريق تجميع <dfn>السلسلة</dfn> بعضها مع بعض.
+
+**مثال**
+
+```js
+'My name is Alan,' + ' I concatenate.'
+```
+
+**ملاحظة:** احترس من المسافات. لإن ربط السلسلة لا تضيف مسافات بين المقاطع الذي تم جمعها، لذا ستحتاج إلى إضافتها بنفسك.
+
+مثال:
+
+```js
+const ourStr = "I come first. " + "I come second.";
+```
+
+المقطع الآتي `I come first. I come second.` سيتم عرضه في وحدة التحكم.
+# --instructions--
+
+أنشئ `myStr` من المقاطع الآتية `This is the start.` و `This is the end.` باستخدام المشغل `+`. تيقن من تضمين مسافة بين المقاطع.
+
+# --hints--
+
+يجب أن يوجد حرف الفراغ واحد بين المقطعين في `myStr`.
+
+```js
+assert(/start\. This/.test(myStr));
+```
+
+يجب أن يكون قيمة `myStr` النص الآتي `This is the start. This is the end.`
+
+```js
+assert(myStr === 'This is the start. This is the end.');
+```
+
+يجب عليك استخدام مشغل `+` لبناء `myStr`.
+
+```js
+assert(code.match(/(["']).*\1\s*\+\s*(["']).*\2/g));
+```
+
+يجب أن يتم إنشاء `myStr` باستخدام كلمة `const`.
+
+```js
+assert(/const\s+myStr/.test(code));
+```
+
+يجب عليك تعيين النتيجة إلى متغير `myStr`.
+
+```js
+assert(/myStr\s*=/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+  if(typeof myStr === 'string') {
+    return 'myStr = "' + myStr + '"';
+  } else {
+    return 'myStr is not a string';
+  }
+})();
+```
+
+## --seed-contents--
+
+```js
+const myStr = ""; // Change this line
+```
+
+# --solutions--
+
+```js
+const myStr = "This is the start. " + "This is the end.";
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-the-plus-equals-operator.md

@@ -0,0 +1,74 @@
+---
+id: 56533eb9ac21ba0edf2244b8
+title: ربط المقاطع النصية باستخدام مشغل =+ (Concatenating Strings with the Plus Equals Operator)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cbQmmC4'
+forumTopicId: 16803
+dashedName: concatenating-strings-with-the-plus-equals-operator
+---
+
+# --description--
+
+يمكننا أيضًا استخدام المشغل `+=` لربط مقطع <dfn>كسلسلة</dfn> في نهاية متغير مقطع نصي أخر موجود. ويمكن أن يكون ذلك مفيدا جدا لكسر المقطع طويل على عدة اسطر.
+
+**ملاحظة:** احترس من المسافات. لا يضيف التسلسل مسافات بين مقاطع نصية المتسلسلة التي تم جمعها، لذا ستحتاج إلى إضافتها بنفسك.
+
+مثال:
+
+```js
+let ourStr = "I come first. ";
+ourStr += "I come second.";
+```
+
+يحتوي `ourStr` قيمة مقطع الآتي `I come first. I come second.` الآن.
+
+# --instructions--
+
+أبني `myStr` على عدة اسطر بواسطة عمل سلسلة من المقاطع الآتية: `This is the first sentence.` و `This is the second sentence.` باستخدام المشغل `+=`. استخدم مشغل `+=` بطريقة مشابهة لكيفية عرضه في المثال وتيقن من تضمين مسافة بين المقاطع. ابدأ بتعيين المقطع الأول إلى `myStr`، ثم أضف المقطع الثاني.
+
+# --hints--
+
+يجب أن يوجد حرف الفراغ واحد بين المقطعين في `myStr`.
+
+```js
+assert(/sentence\. This/.test(myStr));
+```
+
+يجب أن يكون قيمة `myStr` مقطع الآتي `This is the first sentence. This is the second sentence.`
+
+```js
+assert(myStr === 'This is the first sentence. This is the second sentence.');
+```
+
+يجب عليك استخدام مشغل `+=` لبناء `myStr`.
+
+```js
+assert(code.match(/myStr\s*\+=\s*(["']).*\1/g));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+  if(typeof myStr === 'string') {
+    return 'myStr = "' + myStr + '"';
+  } else {
+    return 'myStr is not a string';
+  }
+})();
+```
+
+## --seed-contents--
+
+```js
+let myStr;
+```
+
+# --solutions--
+
+```js
+let myStr = "This is the first sentence. ";
+myStr += "This is the second sentence.";
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/constructing-strings-with-variables.md

@@ -0,0 +1,75 @@
+---
+id: 56533eb9ac21ba0edf2244b9
+title: بناء المقاطع النصية باستخدام المتغيرات (Constructing Strings with Variables)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cqk8rf4'
+forumTopicId: 16805
+dashedName: constructing-strings-with-variables
+---
+
+# --description--
+
+أحيانا قد تحتاج إلي إنشاء مقطع. في أثناء استخدام مشغل التسلسل الآتي (`+`)، يمكنك إدخال متغير واحد أو أكثر في مقطع الذي تقوم ببنائه.
+
+مثال:
+
+```js
+const ourName = "freeCodeCamp";
+const ourStr = "Hello, our name is " + ourName + ", how are you?";
+```
+
+سيحتوي `ourStr` على قيمة المقطع الآتي `Hello, our name is freeCodeCamp, how are you?`.
+
+# --instructions--
+
+عيّن `myName` إلى مقطع مساوي لأسمك وأبني `myStr` بقيمة `myName` بين المقطعين الآتيين `My name is` و `and I am well!`
+
+# --hints--
+
+يجب تعيين `myName` كمقطع يحتوي 3 رموز في الأقل.
+
+```js
+assert(typeof myName !== 'undefined' && myName.length > 2);
+```
+
+يجب عليك استخدام مشغلين اثنين من `+` لبناء `myStr` يحتوي `myName` داخله.
+
+```js
+assert(code.match(/["']\s*\+\s*myName\s*\+\s*["']/g).length > 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+  var output = [];
+  if(typeof myName === 'string') {
+    output.push('myName = "' + myName + '"');
+  } else {
+    output.push('myName is not a string');
+  }
+  if(typeof myStr === 'string') {
+    output.push('myStr = "' + myStr + '"');
+  } else {
+    output.push('myStr is not a string');
+  }
+  return output.join('\n');
+})();
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+const myName = "";
+const myStr = "";
+```
+
+# --solutions--
+
+```js
+const myName = "Bob";
+const myStr = "My name is " + myName + " and I am well!";
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop.md

@@ -0,0 +1,77 @@
+---
+id: 56105e7b514f539506016a5e
+title: العد إلى الوراء باستخدام الحلقة التكرارية (Count Backwards With a For Loop)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2R6BHa'
+forumTopicId: 16808
+dashedName: count-backwards-with-a-for-loop
+---
+
+# --description--
+
+يمكن لحلقة التكرارية (for loop) أن تعد للوراء أيضا، مادام تستطيع تحديد الشروط الصحيحة.
+
+من أجل التراجع بمقدار اثنين في كل دورة (iteration)، سنحتاج إلى تغيير البادئ (initialization) و الشرط (condition) و التعبير الأخير (final expression).
+
+سنبدأ عند `i = 10` وتكرر مادام `i > 0`. خفض `i` بمقدار 2 مع كل تكرار باستخدام `i -= 2`.
+
+```js
+const ourArray = [];
+
+for (let i = 10; i > 0; i -= 2) {
+  ourArray.push(i);
+}
+```
+
+سوف تحتوي `ourArray` الآن على `[10, 8, 6, 4, 2]`. غير التغيير البادئ (initialization) و التعبير الأخير (final expression) حتى نتمكن من العد إلى الوراء بمقدار اثنين لإنشاء قائمة (array) من الأعداد التنازلية الفردية.
+
+# --instructions--
+
+اضغط الأرقام الفردية من 9 إلى 1 إلى `myArray` باستخدام الحلقة التكرارية `for`.
+
+# --hints--
+
+يجب أن تستخدم الحلقة التكرارية `for`.
+
+```js
+assert(/for\s*\([^)]+?\)/.test(code));
+```
+
+يجب أن تستخدم طريقة للقائمة (array method) باسم `push`.
+
+```js
+assert(code.match(/myArray.push/));
+```
+
+يجب أن تساوي `myArray` قيمة `[9, 7, 5, 3, 1]`.
+
+```js
+assert.deepEqual(myArray, [9, 7, 5, 3, 1]);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [];
+for (let i = 9; i > 0; i -= 2) {
+  myArray.push(i);
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/counting-cards.md

@@ -0,0 +1,214 @@
+---
+id: 565bbe00e9cc8ac0725390f4
+title: عدد الأوراق (Counting Cards)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c6KE7ty'
+forumTopicId: 16809
+dashedName: counting-cards
+---
+
+# --description--
+
+في لُعْبَة النادي بلاك جاك، يمكن للاعب أن يحدد ما إذا كان يتمتع بميزة على المنزل بواسطة تتبع العدد النسبي للبطاقات المرتفعة والمنخفضة المتبقية في مجموعة الورق. هذا يسمى إحصاء الورق (Card Counting).
+
+يكون وجود المزيد من الورق عالي القيمة المتبقي في المجموعة, أفضل للاعب. يتم تعيين قيمة لكل بطاقة وفقاً للجدول بالأدنى. عندما يكون العد موجبًا، يجب على اللاعب المراهنة بشكل مرتفع. عندما يكون العد صفرًا أو سلبيًا، يجب أن يراهن اللاعب على انخفاض.
+
+<table class='table table-striped'><thead><tr><th>تغيير العد</th><th>الأوراق</th></tr></thead><tbody><tr><td>+1</td><td>2, 3, 4, 5, 6</td></tr><tr><td>0</td><td>7, 8, 9</td></tr><tr><td>-1</td><td>10, 'J', 'Q', 'K', 'A'</td></tr></tbody></table>
+
+سوف تكتب وظيفة لعد الورق. سوف يتلقى حِجَّة `card`, الذي يمكن أن يكون رقما أو مقطع، ويزيد أو يخفض متغير `count` وفقا لقيمة الورقة (انظر إلى الجدول). ثم ستقوم الوظيفة (function) بإنشاء مقطع (string) يحتوي علي العد الحالي والمقطع `Bet` إذا كان العد إيجابياً، أو `Hold` إذا كان العد صفر أو سلبي. يجب أن يفصل العد الحالي وقرار اللاعب (`Bet` أو `Hold`) بمسافة واحدة.
+
+**مثال على النتائج:** كالآتي `-3 Hold` أو `5 Bet`
+
+**تلميح**  
+لا تعيد تعيين `count` إلى 0 عندما تكون القيمة 7 أو 8 أو 9. لا بإنشاء قائمة.  
+لا تتضمن الاقتباسات (واحدة أو مزدوجة) في الإخراج.
+
+# --hints--
+
+يجب أن تعيد وظيفتك قيمة للعدد والنص (`Bet` أو `Hold`) مع حرف فارغ واحد بينهما.
+
+```js
+assert(//
+  (function () {
+    count = 0;
+    let out = cc(10);
+    const hasSpace = /-?\d+ (Bet|Hold)/.test('' + out);
+    return hasSpace;
+  })()
+);
+```
+
+يجب أن ينتج تسلسل الورق 2، 3، 4، 5، 6 المقطع `5 Bet`
+
+```js
+assert(
+  (function () {
+    count = 0;
+    cc(2);
+    cc(3);
+    cc(4);
+    cc(5);
+    var out = cc(6);
+    if (out === '5 Bet') {
+      return true;
+    }
+    return false;
+  })()
+);
+```
+
+يجب أن ينتج تسلسل الورق 7، 8، 9 المقطع `0 Hold`
+
+```js
+assert(
+  (function () {
+    count = 0;
+    cc(7);
+    cc(8);
+    var out = cc(9);
+    if (out === '0 Hold') {
+      return true;
+    }
+    return false;
+  })()
+);
+```
+
+يجب أن ينتج تسلسل الورق 10, J, Q, K, A المقطع `-5 Hold`
+
+```js
+assert(
+  (function () {
+    count = 0;
+    cc(10);
+    cc('J');
+    cc('Q');
+    cc('K');
+    var out = cc('A');
+    if (out === '-5 Hold') {
+      return true;
+    }
+    return false;
+  })()
+);
+```
+
+يجب أن ينتج تسلسل الورق 3, 7, Q, 8, A المقطع `-1 Hold`
+
+```js
+assert(
+  (function () {
+    count = 0;
+    cc(3);
+    cc(7);
+    cc('Q');
+    cc(8);
+    var out = cc('A');
+    if (out === '-1 Hold') {
+      return true;
+    }
+    return false;
+  })()
+);
+```
+
+يجب أن ينتج تسلسل الورق 2, J, 9, 2, 7 المقطع `1 Bet`
+
+```js
+assert(
+  (function () {
+    count = 0;
+    cc(2);
+    cc('J');
+    cc(9);
+    cc(2);
+    var out = cc(7);
+    if (out === '1 Bet') {
+      return true;
+    }
+    return false;
+  })()
+);
+```
+
+يجب أن ينتج تسلسل الورق 2، 2، 10 المقطع `1 Bet`
+
+```js
+assert(
+  (function () {
+    count = 0;
+    cc(2);
+    cc(2);
+    var out = cc(10);
+    if (out === '1 Bet') {
+      return true;
+    }
+    return false;
+  })()
+);
+```
+
+يجب أن ينتج تسلسل الورق 3, 2, A, 10, K المقطع `-1 Hold`
+
+```js
+assert(
+  (function () {
+    count = 0;
+    cc(3);
+    cc(2);
+    cc('A');
+    cc(10);
+    var out = cc('K');
+    if (out === '-1 Hold') {
+      return true;
+    }
+    return false;
+  })()
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+let count = 0;
+
+function cc(card) {
+  // Only change code below this line
+
+
+  return "Change Me";
+  // Only change code above this line
+}
+
+cc(2); cc(3); cc(7); cc('K'); cc('A');
+```
+
+# --solutions--
+
+```js
+let count = 0;
+function cc(card) {
+  switch(card) {
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+      count++;
+      break;
+    case 10:
+    case 'J':
+    case 'Q':
+    case 'K':
+    case 'A':
+      count--;
+  }
+  if(count > 0) {
+    return count + " Bet";
+  } else {
+    return count + " Hold";
+  }
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/create-decimal-numbers-with-javascript.md

@@ -0,0 +1,55 @@
+---
+id: cf1391c1c11feddfaeb4bdef
+title: إنشاء أرقام عشرية باستخدام JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ca8GEuW'
+forumTopicId: 16826
+dashedName: create-decimal-numbers-with-javascript
+---
+
+# --description--
+
+يمكننا تخزين أرقام عشرية في المتغيرات أيضا. يشار أحياناً إلى الأرقام العشرية على أنها أرقام <dfn>نُقَط عائمة (floating point)</dfn> أو <dfn>عائمات (floats)</dfn>.
+
+**ملاحظة:** عندما حساب الأرقام، يتم حسابها بدقة محدودة. وقد تؤدي العمليات التي تستخدم نُقَط عائمة إلى نتائج مختلفة عن النتائج المرجوة. إذا حصلت على واحدة من هذه النتائج، أفتح موضوع في <a href="https://forum.freecodecamp.org/" target="_blank" rel="noopener noreferrer nofollow">منتدى freeCodeCamp</a>.
+
+# --instructions--
+
+أنشئ متغير `myDecimal` وإعطائه قيمة عشرية بجزء كسري (على سبيل المثال `5.7`).
+
+# --hints--
+
+يجب أن يكون `myDecimal` رقما.
+
+```js
+assert(typeof myDecimal === 'number');
+```
+
+يجب أن يحتوي `myDecimal` على نقطة عشرية
+
+```js
+assert(myDecimal % 1 != 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){if(typeof myDecimal !== "undefined"){return myDecimal;}})();
+```
+
+## --seed-contents--
+
+```js
+const ourDecimal = 5.7;
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myDecimal = 9.9;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/declare-a-read-only-variable-with-the-const-keyword.md

@@ -0,0 +1,88 @@
+---
+id: 587d7b87367417b2b2512b41
+title: تعريف متغير للقراءة ثابت باستخدام كلمة Const
+challengeType: 1
+forumTopicId: 301201
+dashedName: declare-a-read-only-variable-with-the-const-keyword
+---
+
+# --description--
+
+لا يكون أستخدام كلمة `let` الطريقة الجديدة الوحيدة لتعريف المتغيرات. في ES6، يمكنك أيضا تعريف المتغيرات باستخدام كلمة `const`.
+
+تحتوي `const` كل الميزات الرائعة الموجودة في `let`، مع المكافأة المضافة و هي أن المتغيرات المعرفة بواسطة `const` ثابته. هي قيمة ثابتة، مما يعني أنه بمجرد تعيين متغير باستخدام `const`، فلا يمكن إعادة تعيينه:
+
+```js
+const FAV_PET = "Cats";
+FAV_PET = "Dogs";
+```
+
+سيتم عرض خطأ في وحدة التحكم بسبب إعادة تعيين قيمة `FAV_PET`.
+
+يجب عليك دائماً تسمية المتغيرات التي لا ترد إعادة تعيينها باستخدام كلمة `const`. يساعد هذا عندما تحاول بالخطأ إعادة تعيين متغير من المفترض أن يظل ثابتًا.
+
+**ملاحظة:** من الشائع عند المطورين استخدام معرّفات uppercase للمتغيرات ذات القيم الثابتة و lowercase أو camelCase للقيم القابلة للتغيير (objects و arrays). سوف تتعلم المزيد عن الكائنات والقوائم و القيم الثابتة والقابلة للتغيير في تحديات لاحقة. أيضا في التحديات اللاحقة، سترى أمثلة لمعرِّفات المتغيرات uppercase أو lowercase أو camelCase.
+
+# --instructions--
+
+غيّر التعليمات البرمجية بحيث يتم تعريف جميع المتغيرات باستخدام `let` أو `const`. استخدم `let` عندما ترغب بتغير المتغير، و استخدم `const` عندما ترغب ببقي المتغير ثابتاً. كذلك اعد تسمية المتغيرات المعرفة باستخدام `const` لتتوافق مع الممارسات الشائعة. لا تغيير المقاطع المعينة للمتغيرات.
+
+# --hints--
+
+يجب ألا تكون `var` موجودة في التعليمات البرمجية.
+
+```js
+assert.notMatch(code, /var/g);
+```
+
+يجب عليك تغيير `fCC` لتكون كلها uppercase.
+
+```js
+assert.match(code, /(FCC)/);
+assert.notMatch(code, /(fCC)/);
+```
+
+يجب أن يكون متغير `FCC` ثابت تم تعريفه باستخدام `const`.
+
+```js
+assert.match(code, /const\s+FCC/);
+```
+
+لا ينبغي تغيير المقطع المسندة في المتغير `FCC`.
+
+```js
+assert.equal(FCC, 'freeCodeCamp');
+```
+
+يجب أن يتم تعريف `fact` باستخدام `let`.
+
+```js
+assert.match(code, /(let\s+fact)/g);
+```
+
+يجب تغيير `console.log` لطباعة المتغيرات `FCC` و `fact`.
+
+```js
+assert.match(code, /console\.log\(\s*FCC\s*\,\s*fact\s*\)\s*;?/g);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+var fCC = "freeCodeCamp"; // Change this line
+var fact = "is cool!"; // Change this line
+fact = "is awesome!";
+console.log(fCC, fact); // Change this line
+```
+
+# --solutions--
+
+```js
+const FCC = "freeCodeCamp";
+let fact = "is cool!";
+
+fact = "is awesome!";
+console.log(FCC, fact);
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/declare-javascript-variables.md

@@ -0,0 +1,61 @@
+---
+id: bd7123c9c443eddfaeb5bdef
+title: إنشاء متغيرات في JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cNanrHq'
+forumTopicId: 17556
+dashedName: declare-javascript-variables
+---
+
+# --description--
+
+في علوم الحاسب، تكون <dfn>البيانات</dfn> أي شيء ذو معني للحواسيب. يوفر JavaScript ثماني <dfn>أنواع بيانات</dfn> مختلفة و هي كالآتي `undefined`, و`null`, و`boolean`, و`string`, و`symbol`, و`bigint`, و`number`, و `object`.
+
+على سبيل المثال، تقوم الحاسوب بالتمييز بين الأرقام، مثل الرَّقَم `12` و `strings` مثل `"12"` و `"dog"` أو `"123 cats"`, وهي مجموعات من الرموز. يمكن للحواسيب عمليات رياضية على الأعداد، ولكن ليس على المقاطع النصية (strings).
+
+تسمح <dfn>المتغيرات</dfn> للحواسيب بتخزين البيانات ومعالجتها بطريقة ديناميكية. وهم يفعلون ذلك باستخدام "تسمية" للإشارة إلى البيانات بدلاً من استخدام البيانات نفسها. ويمكن تخزين أي نوع من أنواع البيانات الثمانية في متغير.
+
+المتغيرات مشابهة للمتغيرات x و y التي تستخدمها في الرياضيات، مما يعني أنهم اسم بسيط لتمثيل البيانات التي نريد الرجوع إليها. وتختلف متغيرات الحاسوب عن المتغيرات الرياضية من حيث أنها تستطيع تخزين قيم مختلفة في أوقات مختلفة.
+
+نحن نطلب من JavaScript إنشاء أو <dfn>تعين</dfn> متغير عن طريق وضع الكلمة `var` أمامه، مثل ذلك:
+
+```js
+var ourName;
+```
+
+هذا ينشئ متغير يسمى `ourName`. في JavaScript تنهي التعبيرات باستخدام الفاصلة المنقوطة (;). أسماء المتغيرات يمكن أن تتكون من أرقام وحروف و `$` أو `_`، ولكن قد لا تحتوي على مسافات أو تبدأ برقم.
+
+# --instructions--
+
+استخدم كلمة `var` لإنشاء متغير يسمى `myName`.
+
+**تلميح**  
+أنظر إلى مثال `ourName` أعلاه إذا علقت.
+
+# --hints--
+
+يجب أن تعرف `myName` باستخدام كلمة `var` و تنهي بالفاصلة المنقوطة (;)
+
+```js
+assert(/var\s+myName\s*;/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myName !== "undefined"){(function(v){return v;})(myName);}
+```
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+var myName;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/declare-string-variables.md

@@ -0,0 +1,87 @@
+---
+id: bd7123c9c444eddfaeb5bdef
+title: أنشاء متغيرات المقاطع نصية (Declare String Variables)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2QvWU6'
+forumTopicId: 17557
+dashedName: declare-string-variables
+---
+
+# --description--
+
+في السابق كنت تستخدم الكود التالي لإنشاء متغير:
+
+```js
+var myName;
+```
+
+ولكن يمكنك أيضا أنشاء متغير المقطع بهذه الطريقة:
+
+```js
+var myName = "your name";
+```
+
+`"your name"` يسمي <dfn>مقطع</dfn> <dfn>حرفي</dfn>. المقطع النصي أو مقطع هي مقطع تتكون من رمز أو أكثر، مرفقين في علامات اقتباس (Quotes) مفردة أو مزدوجة.
+
+# --instructions--
+
+إنشاء متغيرين مقطعين جديدين: `myFirstName` و `myLastName` وعيين قيم الاسم الأول والاسم الأخير على التوالي.
+
+# --hints--
+
+يجب أن يحتوي مقطع `myFirstName` على حرف واحد في الأقل.
+
+```js
+assert(
+  (function () {
+    if (
+      typeof myFirstName !== 'undefined' &&
+      typeof myFirstName === 'string' &&
+      myFirstName.length > 0
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })()
+);
+```
+
+يجب أن يحتوي مقطع `myLastName` على حرف واحد في الأقل.
+
+```js
+assert(
+  (function () {
+    if (
+      typeof myLastName !== 'undefined' &&
+      typeof myLastName === 'string' &&
+      myLastName.length > 0
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })()
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myFirstName !== "undefined" && typeof myLastName !== "undefined"){(function(){return myFirstName + ', ' + myLastName;})();}
+```
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+var myFirstName = "Alan";
+var myLastName = "Turing";
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/decrement-a-number-with-javascript.md

@@ -0,0 +1,84 @@
+---
+id: 56533eb9ac21ba0edf2244ad
+title: إنقاص رَقَم باستخدام JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cM2KeS2'
+forumTopicId: 17558
+dashedName: decrement-a-number-with-javascript
+---
+
+# --description--
+
+يمكنك بسهولة <dfn>أنقاص</dfn> أو تقليل متغير بواحد باستخدام المشغل `--`.
+
+```js
+i--;
+```
+
+هو ما يعادل
+
+```js
+i = i - 1;
+```
+
+**ملاحظة:** السطر بِرُمَّته يصبح `i--;`، وإلغاء الحاجة إلى علامة المساواة.
+
+# --instructions--
+
+غير الكود لاستخدام المشغل `--` على `myVar`.
+
+# --hints--
+
+يجب أن يساوي `myVar` قيمة `10`.
+
+```js
+assert(myVar === 10);
+```
+
+يجب تغيير `myVar = myVar - 1;`.
+
+```js
+assert(!code.match(/myVar\s*=\s*myVar\s*[-]\s*1.*?;?/));
+```
+
+لا يجب عليك تعيين `myVar` بقيمة `10`.
+
+```js
+assert(!code.match(/myVar\s*=\s*10.*?;?/));
+```
+
+يجب عليك استخدام المشغل `--` على `myVar`.
+
+```js
+assert(/[-]{2}\s*myVar|myVar\s*[-]{2}/.test(code));
+```
+
+لا يجب عليك تعديل الكود فوق التعليق المحدد.
+
+```js
+assert(/let myVar = 11;/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'myVar = ' + z;})(myVar);
+```
+
+## --seed-contents--
+
+```js
+let myVar = 11;
+
+// Only change code below this line
+myVar = myVar - 1;
+```
+
+# --solutions--
+
+```js
+let myVar = 11;
+myVar--;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/delete-properties-from-a-javascript-object.md

@@ -0,0 +1,96 @@
+---
+id: 56bbb991ad1ed5201cd392d3
+title: حذف الخصائص من كائن JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cDqKdTv'
+forumTopicId: 17560
+dashedName: delete-properties-from-a-javascript-object
+---
+
+# --description--
+
+يمكننا أيضا حذف الخصائص من كائنات (objects) كالآتي:
+
+```js
+delete ourDog.bark;
+```
+
+مثال:
+
+```js
+const ourDog = {
+  "name": "Camper",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["everything!"],
+  "bark": "bow-wow"
+};
+
+delete ourDog.bark;
+```
+
+بعد السطر الأخير المبين أعلاه، يبدو `ourDog` كذلك:
+
+```js
+{
+  "name": "Camper",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["everything!"]
+}
+```
+
+# --instructions--
+
+احذف خاصية `tails` من `myDog`. يمكنك استخدام النقطة (dot) أو القوسان المعكوفان (bracket notation).
+
+# --hints--
+
+يجب عليك حذف الخاصية `tails` من `myDog`.
+
+```js
+assert(typeof myDog === 'object' && myDog.tails === undefined);
+```
+
+لا يجب عليك تعديل أسس `myDog`.
+
+```js
+assert(code.match(/"tails": 1/g).length > 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myDog);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myDog = {
+  "name": "Happy Coder",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["freeCodeCamp Campers"],
+  "bark": "woof"
+};
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myDog = {
+  "name": "Happy Coder",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["freeCodeCamp Campers"],
+  "bark": "woof"
+};
+delete myDog.tails;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-decimal-by-another-with-javascript.md

@@ -0,0 +1,50 @@
+---
+id: bd7993c9ca9feddfaeb7bdef
+title: قسّم رَقَم عشري على رَقَم عشري آخر باستخدام JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBZe9AW'
+forumTopicId: 18255
+dashedName: divide-one-decimal-by-another-with-javascript
+---
+
+# --description--
+
+قسم رَقَم عشري على أخر.
+
+# --instructions--
+
+غيّر `0.0` بحيث أن `quotient` تساوي `2.2`.
+
+# --hints--
+
+يجب أن يساوي المتغير `quotient` قيمة `2.2`
+
+```js
+assert(quotient === 2.2);
+```
+
+يجب عليك استخدام المشغل `/` لتقسيم 4.4 على 2
+
+```js
+assert(/4\.40*\s*\/\s*2\.*0*/.test(code));
+```
+
+يجب تعيين متغير quotient مرة واحدة فقط
+
+```js
+assert(code.match(/quotient/g).length === 1);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const quotient = 0.0 / 2.0; // Change this line
+```
+
+# --solutions--
+
+```js
+const quotient = 4.4 / 2.0;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-number-by-another-with-javascript.md

@@ -0,0 +1,59 @@
+---
+id: cf1111c1c11feddfaeb6bdef
+title: قسّم رقمًا على رَقْم آخر باستخدام JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cqkbdAr'
+forumTopicId: 17566
+dashedName: divide-one-number-by-another-with-javascript
+---
+
+# --description--
+
+يمكننا أيضًا قسمة رَقْم على آخر.
+
+يستخدم JavaScript رمز `/` لعملية القسمة.
+
+**مثال**
+
+```js
+const myVar = 16 / 2;
+```
+
+لدي `myVar` قيمة `8` الآن.
+# --instructions--
+
+غيّر `0` بحيث أن `quotient` تساوي `2`.
+
+# --hints--
+
+يجب أن يساوي المتغير `quotient` قيمة 2.
+
+```js
+assert(quotient === 2);
+```
+
+يجب عليك استخدام المشغل `/`.
+
+```js
+assert(/\d+\s*\/\s*\d+/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'quotient = '+z;})(quotient);
+```
+
+## --seed-contents--
+
+```js
+const quotient = 66 / 0;
+```
+
+# --solutions--
+
+```js
+const quotient = 66 / 33;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings.md

@@ -0,0 +1,91 @@
+---
+id: 56533eb9ac21ba0edf2244b6
+title: تسلسلات الهروب في المقاطع (Escape Sequences in Strings)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cvmqRh6'
+forumTopicId: 17567
+dashedName: escape-sequences-in-strings
+---
+
+# --description--
+
+الاقتباسات (Quotes) ليست الرموز الوحيدة التي يمكن أن تكتب <dfn>باحتياليه</dfn> داخل المقطع (string). وهناك سببان لاستخدام رموز احتيالية (escaping characters):
+
+1.  للسماح لك باستخدام الرموز التي قد لا تتمكن من استخدامها، مثل سطر جديد (newline).
+2.  للسماح لك بتمثيل الاقتباسات (Quotes) متعددة في مقطع دون أن يسيء JavaScript فهم ما تعنيه.
+
+وقد تعلمنا ذلك في التحدي السابق.
+
+<table class='table table-striped'><thead><tr><th>الكود</th><th>الناتج</th></tr></thead><tbody><tr><td><code>\'</code></td><td>single quote</td></tr><tr><td><code>\"</code></td><td>double quote</td></tr><tr><td><code>\\</code></td><td>backslash</td></tr><tr><td><code>\n</code></td><td>newline</td></tr><tr><td><code>\t</code></td><td>مساحة يختارها المستخدم (tab)</td></tr><tr><td><code>\r</code></td><td>إعادة التنقل إلى أول السطر (carriage return)</td></tr><tr><td><code>\b</code></td><td>word boundary</td></tr><tr><td><code>\f</code></td><td>form feed</td></tr></tbody></table>
+
+*لاحظ أن يجب أن تكون الخط المائل (backslash) نفسه أحتيالي (escaped) ليتم عرضها كخط مائل backslash.*
+
+# --instructions--
+
+عيّن الأسطر الثلاثة التالية من النص في المتغير `myStr` الوحيد باستخدام تسلسل احتيالي (escape sequences).
+
+<blockquote>FirstLine<br>    \SecondLine<br>ThirdLine</blockquote>
+
+سوف تحتاج إلى استخدام تسلسل احتيالي لإدراج الرموز الخاصة (special characters) بشكل صحيح. ستحتاج أيضًا إلى اتباع التباعد كما هو موضح أعلاه، دون مسافات بين التسلسل الاحتيالي escape sequences أو الكلمات.
+
+**ملاحظة:** يتم الحصول على التباعد (indentation) في `SecondLine` باستخدام رمز التحايل الشريط (tab escape character) وليس المسافة الفارغة (space).
+
+# --hints--
+
+يجب ألا يحتوي `myStr` على أي مسافات
+
+```js
+assert(!/ /.test(myStr));
+```
+
+يجب أن يحتوي `myStr` على المقطع (string) الآتي `FirstLine`, و `SecondLine`, و `ThirdLine` (تذكر الحساسية حالة الحرف (case sensitivity))
+
+```js
+assert(
+  /FirstLine/.test(myStr) && /SecondLine/.test(myStr) && /ThirdLine/.test(myStr)
+);
+```
+
+يجب أن يتبع `FirstLine` رمز السطر الجديد (newline character) الاتي `\n`
+
+```js
+assert(/FirstLine\n/.test(myStr));
+```
+
+يجب أن يحتوي `myStr` على رمز الشريط (tab character) وهو `\t` الذي يتبع رمز السطر الجديد (newline character)
+
+```js
+assert(/\n\t/.test(myStr));
+```
+
+يجب أن يسبق `SecondLine` رمز خط مائل (backslash character) يكتب هكذا `\`
+
+```js
+assert(/\\SecondLine/.test(myStr));
+```
+
+يجب أن يكون هناك رمز السطر الجديد (newline character) بين `SecondLine` و `ThirdLine`
+
+```js
+assert(/SecondLine\nThirdLine/.test(myStr));
+```
+
+يجب أن يحتوي `myStr` فقط على الرموز التي تظهر في التعليمات
+
+```js
+assert(myStr === 'FirstLine\n\t\\SecondLine\nThirdLine');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const myStr = ""; // Change this line
+```
+
+# --solutions--
+
+```js
+const myStr = "FirstLine\n\t\\SecondLine\nThirdLine";
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings.md

@@ -0,0 +1,72 @@
+---
+id: 56533eb9ac21ba0edf2244b5
+title: الاحتيال على علامات التنصيص في المقاطع النصية
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2QvgSr'
+forumTopicId: 17568
+dashedName: escaping-literal-quotes-in-strings
+---
+
+# --description--
+
+عندما تحديد مقطع نصي يجب أن تبدأ وتنتهي علامتا التنصيص واحد ('') أو مزدوج (""). ماذا يحدث عندما تحتاج إلى استخدام علامتا التنصيص مثل: `"` أو `'` داخل مقطع نصي خاص بك؟
+
+في JavaScript، يمكنك عمل <dfn>خدعة</dfn> داخل علامتا التنصيص حتي لا تعدّ نهاية للعلامة الأولى في المقطع النصي عن طريق وضع <dfn>خط مائل</dfn> بشكل (`\`) أمام علامتا التنصيص.
+
+```js
+const sampleStr = "Alan said, \"Peter is learning JavaScript\".";
+```
+
+هذا يوضح إلى JavaScript أن علامة التنصيص التالية ليس نهاية للمقطع، بل يجب أن تظهر داخل المقطع. لذا عند طبع هذا إلى وحدة التحكم ستحصل على:
+
+```js
+Alan said, "Peter is learning JavaScript".
+```
+
+# --instructions--
+
+استخدم <dfn>خطوط مائلة</dfn> لتعيين مقطع إلى متغير `myStr` بحيث إذا كنت تريد طباعته إلى وحدة التحكم، ستري ما يلي:
+
+```js
+I am a "double quoted" string inside "double quotes".
+```
+
+# --hints--
+
+يجب عليك استخدام علامة التنصيص المزدوجة (`"`) وتتحايل على العلامات أربع مرات مثل (`\"`).
+
+```js
+assert(code.match(/\\"/g).length === 4 && code.match(/[^\\]"/g).length === 2);
+```
+
+يجب أن يحتوي المتغير `myStr` على المقطع النصي الآتي: `I am a "double quoted" string inside "double quotes".`
+
+```js
+assert(/I am a "double quoted" string inside "double quotes(\."|"\.)$/.test(myStr));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){
+  if(typeof myStr === 'string') {
+    console.log("myStr = \"" + myStr + "\"");
+  } else {
+    console.log("myStr is undefined");
+  }
+})();
+```
+
+## --seed-contents--
+
+```js
+const myStr = ""; // Change this line
+```
+
+# --solutions--
+
+```js
+const myStr = "I am a \"double quoted\" string inside \"double quotes\".";
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/explore-differences-between-the-var-and-let-keywords.md

@@ -0,0 +1,74 @@
+---
+id: 587d7b87367417b2b2512b3f
+title: استكشاف الاختلافات بين كلمتين var و let
+challengeType: 1
+forumTopicId: 301202
+dashedName: explore-differences-between-the-var-and-let-keywords
+---
+
+# --description--
+
+واحدة من أكبر مشكلات إنشاء المتغيرات باستخدام كلمة `var` هي أنه يمكنك بسهولة تغيير تعريفات المتغيرات السابقة:
+
+```js
+var camper = "James";
+var camper = "David";
+console.log(camper);
+```
+
+في الكود أعلاه، تم أنشاء متغير `camper` في الأصل بقيمة `James`، وتم تغيره بعد ذلك ليصبح `David`. ثم يعرض وحدة التحكم المقطع (string) الآتي `David`.
+
+في تطبيق صغير، قد لا تواجه هذا النوع من المشاكل. لكن كلما أصبح الكود الخاص بك أكبر، قد تغير المتغير عن طريق الخطأ الذي لم تكن تنوي تغييره. ولأذن هذا السلوك لا يوقع خطأ، يصبح البحث عن الأخطاء وإصلاحها أكثر صعوبة.
+
+تم تقديم كلمة `let` في ES6، وهو تحديث رئيس JavaScript، لحل هذه المشكلة المحتملة باستخدام `var`. ستتعرف إلى ميزات ES6 الأخرى في التحديات اللاحقة.
+
+إذا استبدلت `var` إلى `let` في الكود أعلاه، فإنه يؤدي إلى خطأ:
+
+```js
+let camper = "James";
+let camper = "David";
+```
+
+يمكن رؤية الخطأ في وحدة تحكم المتصفح الخاص بك.
+
+لذلك على خلاف `var`، عندما تستخدم `let`، يمكن تعريف متغير بنفس الاسم مرة واحدة فقط.
+
+# --instructions--
+
+حديث الكود بحيث يستخدم فقط كلمة `let`.
+
+# --hints--
+
+يجب ألا تكون `var` موجودة في الكود.
+
+```js
+assert.notMatch(code, /var/g);
+```
+
+يجب أن تساوي `catName` المقطع (string) الآتي `Oliver`.
+
+```js
+assert.equal(catName, 'Oliver');
+```
+
+يجب أن تساوي `catSound` المقطع (string) الآتي `Meow!`
+
+```js
+assert.equal(catSound, 'Meow!');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+var catName = "Oliver";
+var catSound = "Meow!";
+```
+
+# --solutions--
+
+```js
+let catName = "Oliver";
+let catSound = "Meow!";
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string.md

@@ -0,0 +1,68 @@
+---
+id: bd7123c9c448eddfaeb5bdef
+title: العثور على طول مقطع نصي (Find the Length of a String)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cvmqEAd'
+forumTopicId: 18182
+dashedName: find-the-length-of-a-string
+---
+
+# --description--
+
+يمكنك العثور على قيمة طول `String` بكتابة `.length` بعد متغير المقطع (string) أو المقطع النصي (string literal).
+
+```js
+console.log("Alan Peter".length);
+```
+
+سوف يتم عرض القيمة `10` في وحدة التحكم. لاحظ أن رمز المسافة بين "Alan" و "Peter" يتم حسابه أيضا.
+
+على سبيل المثال، إذا أنشئت متغير `const firstName = "Ada"`، يمكننا معرفة طول المقطع (string) الآتي `Ada` باستخدام `firstName.length`.
+
+# --instructions--
+
+استخدم خاصية `.length` لتعيين `lastNameLength` إلى عدد الأحرف في `lastName`.
+
+# --hints--
+
+لا يجب عليك تغيير تعريفات المتغيرات في قسم `// Setup`.
+
+```js
+assert(
+  code.match(/let lastNameLength = 0;/) &&
+    code.match(/const lastName = "Lovelace";/)
+);
+```
+
+يجب أن يساوي `lastNameLength` ثمانية.
+
+```js
+assert(typeof lastNameLength !== 'undefined' && lastNameLength === 8);
+```
+
+يجب الحصول على الطول `lastName` باستخدام `.length` مثل: `lastName.length`.
+
+```js
+assert(code.match(/=\s*lastName\.length/g) && !code.match(/lastName\s*=\s*8/));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+let lastNameLength = 0;
+const lastName = "Lovelace";
+
+// Only change code below this line
+lastNameLength = lastName;
+```
+
+# --solutions--
+
+```js
+let lastNameLength = 0;
+const lastName = "Lovelace";
+lastNameLength = lastName.length;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/finding-a-remainder-in-javascript.md

@@ -0,0 +1,67 @@
+---
+id: 56533eb9ac21ba0edf2244ae
+title: العثور على باقي القسمة باستخدام JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWP24Ub'
+forumTopicId: 18184
+dashedName: finding-a-remainder-in-javascript
+---
+
+# --description--
+
+مشغل <dfn>المتبقي</dfn> الآتي `%` يعطي الجزء المتبقي من عملية تقسيم رقمين.
+
+**مثال**
+
+<blockquote>5 % 2 = 1 لأن <br>Math.floor(5 / 2) = 2 (الناتج)<br>2 * 2 = 4<br>5 - 4 = 1 (المتبقي)</blockquote>
+
+**الاستخدام**  
+في الرياضيات، يمكن التحقق من أن الرَّقَم زوجي أو فردي عن طريق التحقق من بقية قسمة العدد على `2`.
+
+<blockquote>17 % 2 = 1 (17 فردي)<br>48 % 2 = 0 (48 زوجي)</blockquote>
+
+**ملاحظة:** مشغل <dfn>المتبقي</dfn> يشار إليه أحياناً بشكل غير صحيح على أنه مشغل بالمائة (modulus operator). إنه شبيه جداً بالـمائه (modulus)، ولكنه لا يعمل بشكل صحيح مع الأعداد السالبة.
+
+# --instructions--
+
+عيّن `remainder` مساوية لبقية `11` مقسوما على `3` باستخدام مشغل <dfn>المتبقي</dfn> الآتي (`%`).
+
+# --hints--
+
+يجب تهيئة المتغير `remainder` بمعني أخر يجب أن يكون initialized
+
+```js
+assert(/(const|let|var)\s+?remainder/.test(code));
+```
+
+يجب أن تكون قيمة `remainder` تساوي `2`
+
+```js
+assert(remainder === 2);
+```
+
+يجب عليك استخدام المشغل `%`
+
+```js
+assert(/\s+?remainder\s*?=\s*?.*%.*;?/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(y){return 'remainder = '+y;})(remainder);
+```
+
+## --seed-contents--
+
+```js
+const remainder = 0;
+```
+
+# --solutions--
+
+```js
+const remainder = 11 % 3;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-fractions-with-javascript.md

@@ -0,0 +1,69 @@
+---
+id: cf1111c1c11feddfaeb9bdef
+title: إنشاء كسور عشوائية باستخدام JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cyWJJs3'
+forumTopicId: 18185
+dashedName: generate-random-fractions-with-javascript
+---
+
+# --description--
+
+الأرقام العشوائية مفيدة لخلق سلوك عشوائي.
+
+لدى JavaScript وظيفة `Math.random()` التي تولد رَقَم عشري عشوائي بين `0` (مشمول) و `1` (غير مشمول). ولذلك يمكن أن ينتج `Math.random()` رَقَم `0` ولكن لا يمكن أبدا أن ينتج رَقَم `1`.
+
+**ملاحظة:** مثل <a href="/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator" target="_blank" rel="noopener noreferrer nofollow">قيم التخزين مع مشغل التعيين (=)</a>، سيتم حل جميع مكالمات الوظيفة قبل تنفيذ `return` حتى نتمكن من `return` قيمة وظيفة `Math.random()`.
+
+# --instructions--
+
+غيّر `randomFraction` لإنتاج رَقَم عشوائي بدلا من إنتاج `0`.
+
+# --hints--
+
+يجب أن ينتج `randomFraction` رقما عشوائيا.
+
+```js
+assert(typeof randomFraction() === 'number');
+```
+
+يجب أن يكون الرَّقْم المنتج بواسطة `randomFraction` عشري.
+
+```js
+assert((randomFraction() + '').match(/\./g));
+```
+
+يجب أن تستخدم `Math.random` لإنشاء رَقَم عشري عشوائي.
+
+```js
+assert(code.match(/Math\.random/g).length >= 0);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){return randomFraction();})();
+```
+
+## --seed-contents--
+
+```js
+function randomFraction() {
+
+  // Only change code below this line
+
+  return 0;
+
+  // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function randomFraction() {
+  return Math.random();
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-with-javascript.md

@@ -0,0 +1,90 @@
+---
+id: cf1111c1c12feddfaeb1bdef
+title: إنشاء أرقام صحيحة عشوائية باستخدام JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRn6bfr'
+forumTopicId: 18186
+dashedName: generate-random-whole-numbers-with-javascript
+---
+
+# --description--
+
+من الرائع أنه يمكننا توليد أرقام عشرية عشوائية، ولكن من المفيد أكثر إذا استخدمنا ذلك لتوليد أعداد عشوائية صحيحة.
+
+<ol><li>استخدم <code>Math.random()</code> لإنشاء رَقَم عشري عشوائي.</li><li>ضاعف هذا الرَّقَم العشري العشوائي في <code>20</code>.</li><li>استخدم الوظيفة أخر، <code>Math.floor()</code> لتقريب الرَّقْم إلى أقرب رَقَم صحيح.</li></ol>
+
+تذكر ألا يمكن `Math.random()` أن يعيد `1` و لأنك تقريب لأقل رَقْم، من المستحيل في الواقع الحصول على `20`. ستعطينا هذه التقنية رَقَما صحيحا بين `0` و `19`.
+
+بتجميع كل شيء معًا، هذا هو الكود الخاص بنا:
+
+```js
+Math.floor(Math.random() * 20);
+```
+
+نحن نستدعي `Math.random()` ثم نضرب النتيجة في 20، ثم نمرر القيمة إلى وظيفة `Math.floor()` لتقريب القيمة إلى أقرب عدد صحيح.
+
+# --instructions--
+
+استخدم هذه التقنية لإنشاء وإعادة عدد صحيح عشوائي بين `0` و `9`.
+
+# --hints--
+
+يجب أن تكون نتيجة `randomWholeNum` عدداً صحيحاً.
+
+```js
+assert(
+  typeof randomWholeNum() === 'number' &&
+    (function () {
+      var r = randomWholeNum();
+      return Math.floor(r) === r;
+    })()
+);
+```
+
+يجب عليك استخدام `Math.random` لتوليد رَقَم عشوائي.
+
+```js
+assert(code.match(/Math.random/g).length >= 1);
+```
+
+عليك ضرب نتيجة `Math.random` في 10 لجعلها رقما بين صفر و تسعة.
+
+```js
+assert(
+  code.match(/\s*?Math.random\s*?\(\s*?\)\s*?\*\s*?10[\D]\s*?/g) ||
+    code.match(/\s*?10\s*?\*\s*?Math.random\s*?\(\s*?\)\s*?/g)
+);
+```
+
+يجب عليك استخدام `Math.floor` لإزالة الجزء العشري من الرَّقَم.
+
+```js
+assert(code.match(/Math.floor/g).length >= 1);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){return randomWholeNum();})();
+```
+
+## --seed-contents--
+
+```js
+function randomWholeNum() {
+
+  // Only change code below this line
+
+  return Math.random();
+}
+```
+
+# --solutions--
+
+```js
+function randomWholeNum() {
+  return Math.floor(Math.random() * 10);
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-within-a-range.md

@@ -0,0 +1,102 @@
+---
+id: cf1111c1c12feddfaeb2bdef
+title: توليد أعداد صحيحة عشوائية داخل نطاق (Generate Random Whole Numbers within a Range)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cm83yu6'
+forumTopicId: 18187
+dashedName: generate-random-whole-numbers-within-a-range
+---
+
+# --description--
+
+بدلاً من إنشاء رَقَم صحيح عشوائي بين صفر ورَقَم أخر معين، كما فعلنا من قبل، يمكننا إنشاء رَقَم صحيح عشوائي يقع ضمن نطاق رَقَمين محددين.
+
+لفعل ذلك، سنحدد الحد الأدنى للرَقْم `min` والحد الأقصى `max`.
+
+هذه هي الصيغة التي سنستخدمها. خذ لحظة لقراءتها ومحاولة فهم ما يفعله هذا الكود:
+
+```js
+Math.floor(Math.random() * (max - min + 1)) + min
+```
+
+# --instructions--
+
+أنشئ وظيفة (function) تسمى `randomRange` التي تأخذ نطاق `myMin` و `myMax` وترجع رَقَماً صحيحاً عشوائياً أكبر من أو يساوي `myMax`، و أقل من أو يساوي `myMin`، بشمول الاثنين.
+
+# --hints--
+
+أقل عدد عشوائي يمكن إنشاؤه بواسطة `randomRange` يجب أن يكون مساويا للحد الأدنى من الرَّقْم الخاص بك `myMin`.
+
+```js
+assert(calcMin === 5);
+```
+
+أعلى رقم عشوائي يمكن إنشاؤه بواسطة `randomRange` يجب أن يكون مساوياً للحد الأقصى من الرقم الخاص بك `myMax`.
+
+```js
+assert(calcMax === 15);
+```
+
+الرَّقَم العشوائي التي تم إنشاؤه بواسطة `randomRange` يجب أن يكون عددًا صحيحًا وليس عشريًا.
+
+```js
+assert(randomRange(0, 1) % 1 === 0);
+```
+
+يجب أن يستخدم `randomRange` كلا من `myMax` و `myMin`, لإنتاج رَقَم عشوائي في نطاقك.
+
+```js
+assert(
+  (function () {
+    if (
+      code.match(/myMax/g).length > 1 &&
+      code.match(/myMin/g).length > 2 &&
+      code.match(/Math.floor/g) &&
+      code.match(/Math.random/g)
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })()
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+var calcMin = 100;
+var calcMax = -100;
+for(var i = 0; i < 100; i++) {
+  var result = randomRange(5,15);
+  calcMin = Math.min(calcMin, result);
+  calcMax = Math.max(calcMax, result);
+}
+(function(){
+  if(typeof myRandom === 'number') {
+    return "myRandom = " + myRandom;
+  } else {
+    return "myRandom undefined";
+  }
+})()
+```
+
+## --seed-contents--
+
+```js
+function randomRange(myMin, myMax) {
+  // Only change code below this line
+  return 0;
+  // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function randomRange(myMin, myMax) {
+  return Math.floor(Math.random() * (myMax - myMin + 1)) + myMin;
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/global-scope-and-functions.md

@@ -0,0 +1,128 @@
+---
+id: 56533eb9ac21ba0edf2244be
+title: النطاق الشامل والوظائف
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cQM7mCN'
+forumTopicId: 18193
+dashedName: global-scope-and-functions
+---
+
+# --description--
+
+في JavaScript، يشير <dfn>النطاق</dfn> إلى رؤية المتغيرات. يكون إلى المتغيرات التي تم تعريفها خارج الوظيفة نطاق يسمي <dfn>شامل</dfn>. وهذا يعني أنه يمكن رؤيتها في كل مكان في التعليمات البرمجية JavaScript الخاص بك.
+
+يتم تعريف المتغيرات دون استخدام الكلمات الآتية `let` أو `const` يتم إنشاؤها تلقائيًا في نطاق `global`. هذا يمكن أن يؤدي إلى عواقب غير مقصودة في مكان آخر من التعليمات البرمجية الخاص بك أو عند تشغيل الوظيفة مرة أخرى. يجب عليك دائماً تعريف المتغيرات الخاصة بك باستخدام `let` أو `const`.
+
+# --instructions--
+
+باستخدام `let` أو `const`، عرف متغير شامل يسمى `myGlobal` خارج الوظيفة ما. قم بتهيئته بقيمة `10`.
+
+داخل الوظيفة `fun1`، عيّّن `5` إلى `oopsGlobal` ولكن ***دون*** استخدام `var`, أو `let`, أو `const`.
+
+# --hints--
+
+يجب أن يتم تعريف `myGlobal`
+
+```js
+assert(typeof myGlobal != 'undefined');
+```
+
+يجب أن يساوي `myGlobal` قيمة `10`
+
+```js
+assert(myGlobal === 10);
+```
+
+يجب تعريف `myGlobal` باستخدام `let` أو `const`
+
+```js
+assert(/(let|const)\s+myGlobal/.test(code));
+```
+
+يجب أن يكون متغير `oopsGlobal` شامل وأن يساوي `5`
+
+```js
+assert(typeof oopsGlobal != 'undefined' && oopsGlobal === 5);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+var logOutput = "";
+var originalConsole = console
+function capture() {
+    var nativeLog = console.log;
+    console.log = function (message) {
+        logOutput = message;
+        if(nativeLog.apply) {
+          nativeLog.apply(originalConsole, arguments);
+        } else {
+          var nativeMsg = Array.prototype.slice.apply(arguments).join(' ');
+          nativeLog(nativeMsg);
+        }
+    };
+}
+
+function uncapture() {
+  console.log = originalConsole.log;
+}
+var oopsGlobal;
+capture();
+```
+
+## --after-user-code--
+
+```js
+fun1();
+fun2();
+uncapture();
+(function() { return logOutput || "console.log never called"; })();
+```
+
+## --seed-contents--
+
+```js
+// Declare the myGlobal variable below this line
+
+
+function fun1() {
+  // Assign 5 to oopsGlobal Here
+
+}
+
+// Only change code above this line
+
+function fun2() {
+  var output = "";
+  if (typeof myGlobal != "undefined") {
+    output += "myGlobal: " + myGlobal;
+  }
+  if (typeof oopsGlobal != "undefined") {
+    output += " oopsGlobal: " + oopsGlobal;
+  }
+  console.log(output);
+}
+```
+
+# --solutions--
+
+```js
+const myGlobal = 10;
+
+function fun1() {
+  oopsGlobal = 5;
+}
+
+function fun2() {
+  var output = "";
+  if(typeof myGlobal != "undefined") {
+    output += "myGlobal: " + myGlobal;
+  }
+  if(typeof oopsGlobal != "undefined") {
+    output += " oopsGlobal: " + oopsGlobal;
+  }
+  console.log(output);
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/global-vs.-local-scope-in-functions.md

@@ -0,0 +1,77 @@
+---
+id: 56533eb9ac21ba0edf2244c0
+title: النطاق العام مقابل النطاق المحلي في الوظائف (Global vs. Local Scope in Functions)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c2QwKH2'
+forumTopicId: 18194
+dashedName: global-vs--local-scope-in-functions
+---
+
+# --description--
+
+من الممكن الحصول على متغيرات <dfn>محالية (Local)</dfn> و <dfn>عامة (Global)</dfn> بنفس الاسم. عندما تقوم ذلك، يكون المتغير المحالي (local) له الأسبقية على المتغير العام (global).
+
+وفي هذا المثال:
+
+```js
+const someVar = "Hat";
+
+function myFun() {
+  const someVar = "Head";
+  return someVar;
+}
+```
+
+سوف تنتج الوظيفة `myFun` السلسلة `Head` لأن النسخة المحالية (local) من المتغير موجودة.
+
+# --instructions--
+
+أضف متغير محالي (local) إلى وظيفة `myOutfit` لتجاوز قيمة `outerWear` بالمقطع `sweater`.
+
+# --hints--
+
+لا يجب عليك تغيير قيمة العام (global) الآتي `outerWear`.
+
+```js
+assert(outerWear === 'T-Shirt');
+```
+
+يجب أن ينتج `myOutfit` المقطع `sweater`.
+
+```js
+assert(myOutfit() === 'sweater');
+```
+
+لا يجب عليك تغيير التعبير المنتج (return statement).
+
+```js
+assert(/return outerWear/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+const outerWear = "T-Shirt";
+
+function myOutfit() {
+  // Only change code below this line
+
+  // Only change code above this line
+  return outerWear;
+}
+
+myOutfit();
+```
+
+# --solutions--
+
+```js
+const outerWear = "T-Shirt";
+function myOutfit() {
+  const outerWear = "sweater";
+  return outerWear;
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/golf-code.md

@@ -0,0 +1,136 @@
+---
+id: 5664820f61c48e80c9fa476c
+title: تعليمات برمجية للعبة الجولف
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9ykNUR'
+forumTopicId: 18195
+dashedName: golf-code
+---
+
+# --description--
+
+في لُعْبَة الجولف، كل ثقب لديه `par`، التي تصف متوسط عدد الضربات `strokes` المتوقعة من اللاعب من أجل أدخال الكرة في الثَّقب لإكمال اللعب. اعتمادًا على مدى بعد `strokes` من `par` سواء البعد كان فوق أو تحت، يوجد اسم مستعار مختلف لكل منهم.
+
+سيتم تمرير `par` و `strokes` كحجة الوظائف الخاص بك. أرجع المقطع الصحيح وفقًا لهذا الجدول الذي يسرد strokes حسب الأولوية؛ من الأعلى إلى الأسفل:
+
+<table class='table table-striped'><thead><tr><th>Strokes</th><th>Return</th></tr></thead><tbody><tr><td>1</td><td>"Hole-in-one!"</td></tr><tr><td>&#x3C;= par - 2</td><td>"Eagle"</td></tr><tr><td>par - 1</td><td>"Birdie"</td></tr><tr><td>par</td><td>"Par"</td></tr><tr><td>par + 1</td><td>"Bogey"</td></tr><tr><td>par + 2</td><td>"Double Bogey"</td></tr><tr><td>>= par + 3</td><td>"Go Home!"</td></tr></tbody></table>
+
+يكونان `par` و `strokes` دائما من نوع رَقْم أيحابى. لقد أضفنا القائمة من جميع الأسماء لمساعدتك.
+
+# --hints--
+
+يجب أن ينتج `golfScore(4, 1)` المقطع `Hole-in-one!`
+
+```js
+assert(golfScore(4, 1) === 'Hole-in-one!');
+```
+
+يجب أن ينتج `golfScore(4, 2)` المقطع `Eagle`
+
+```js
+assert(golfScore(4, 2) === 'Eagle');
+```
+
+يجب أن ينتج `golfScore(5, 2)` المقطع `Eagle`
+
+```js
+assert(golfScore(5, 2) === 'Eagle');
+```
+
+يجب أن ينشئ `golfScore(4, 3)` المقطع `Birdie`
+
+```js
+assert(golfScore(4, 3) === 'Birdie');
+```
+
+يجب أن ينشئ `golfScore(4, 4)` المقطع `Par`
+
+```js
+assert(golfScore(4, 4) === 'Par');
+```
+
+يجب أن ينشئ `golfScore(1, 1)` المقطع `Hole-in-one!`
+
+```js
+assert(golfScore(1, 1) === 'Hole-in-one!');
+```
+
+يجب أن ينشئ `golfScore(5, 5)` المقطع `Par`
+
+```js
+assert(golfScore(5, 5) === 'Par');
+```
+
+يجب أن ينشئ `golfScore(4, 5)` المقطع `Bogey`
+
+```js
+assert(golfScore(4, 5) === 'Bogey');
+```
+
+يجب أن ينشئ `golfScore(4, 6)` المقطع `Double Bogey`
+
+```js
+assert(golfScore(4, 6) === 'Double Bogey');
+```
+
+يجب أن ينشئ `golfScore(4, 7)` المقطع `Go Home!`
+
+```js
+assert(golfScore(4, 7) === 'Go Home!');
+```
+
+يجب أن ينشئ `golfScore(5, 9)` المقطع `Go Home!`
+
+```js
+assert(golfScore(5, 9) === 'Go Home!');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const names = ["Hole-in-one!", "Eagle", "Birdie", "Par", "Bogey", "Double Bogey", "Go Home!"];
+
+function golfScore(par, strokes) {
+  // Only change code below this line
+
+
+  return "Change Me";
+  // Only change code above this line
+}
+
+golfScore(5, 4);
+```
+
+# --solutions--
+
+```js
+function golfScore(par, strokes) {
+  if (strokes === 1) {
+    return "Hole-in-one!";
+  }
+
+  if (strokes <= par - 2) {
+    return "Eagle";
+  }
+
+  if (strokes === par - 1) {
+    return "Birdie";
+  }
+
+  if (strokes === par) {
+    return "Par";
+  }
+
+  if (strokes === par + 1) {
+    return "Bogey";
+  }
+
+  if(strokes === par + 2) {
+    return "Double Bogey";
+  }
+
+  return "Go Home!";
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/increment-a-number-with-javascript.md

@@ -0,0 +1,80 @@
+---
+id: 56533eb9ac21ba0edf2244ac
+title: زيادة رَقْم باستخدام JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ca8GLT9'
+forumTopicId: 18201
+dashedName: increment-a-number-with-javascript
+---
+
+# --description--
+
+يمكنك بسهولة <dfn>زيادة</dfn> أو إضافة واحد إلى متغير مع مشغل `+ +`.
+
+```js
+i++;
+```
+
+هو ما يعادل
+
+```js
+i = i + 1;
+```
+
+**ملاحظة:** السطر بِرُمَّته يصبح `i++;`، مما يزيل الحاجة إلى علامة يساوي (equal sign).
+
+# --instructions--
+
+غيّر الكود لاستخدام المشغل `++` على المتغير `myVar`.
+
+# --hints--
+
+يجب أن يساوي `myVar` قيمة `88`.
+
+```js
+assert(myVar === 88);
+```
+
+لا يجب عليك استخدام مشغل التعيين.
+
+```js
+assert(
+  /let\s*myVar\s*=\s*87;\s*\/*.*\s*([+]{2}\s*myVar|myVar\s*[+]{2})/.test(code)
+);
+```
+
+يجب عليك استخدام المشغل `++`.
+
+```js
+assert(/[+]{2}\s*myVar|myVar\s*[+]{2}/.test(code));
+```
+
+لا يجب عليك تعديل الكود فوق التعليق المحدد.
+
+```js
+assert(/let myVar = 87;/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'myVar = ' + z;})(myVar);
+```
+
+## --seed-contents--
+
+```js
+let myVar = 87;
+
+// Only change code below this line
+myVar = myVar + 1;
+```
+
+# --solutions--
+
+```js
+let myVar = 87;
+myVar++;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator.md

@@ -0,0 +1,44 @@
+---
+id: 56533eb9ac21ba0edf2244a9
+title: تهيئة المتغيرات باستخدام مشغل التعيين (Initializing Variables with the Assignment Operator)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWJ4Bfb'
+forumTopicId: 301171
+dashedName: initializing-variables-with-the-assignment-operator
+---
+
+# --description--
+
+من الشائع <dfn>تعيين</dfn> للمتغير قيمة أولية في نفس السطر المعلن عنه.
+
+```js
+var myVar = 0;
+```
+
+ينشئ متغيرًا جديدًا يسمى `myVar` ويعينه قيمة مبدئية تبلغ `0`.
+
+# --instructions--
+
+عرّف متغير `a` باستخدام `var` و عيّن له قيمة `9`.
+
+# --hints--
+
+يجب عليك تهيئة `a` بقيمة `9`.
+
+```js
+assert(/var\s+a\s*=\s*9(\s*;?\s*)$/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+var a = 9;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-if-statements.md

@@ -0,0 +1,114 @@
+---
+id: 56533eb9ac21ba0edf2244db
+title: مقدمة ألى تعبيرات Else/If
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/caeJ2hm'
+forumTopicId: 18206
+dashedName: introducing-else-if-statements
+---
+
+# --description--
+
+إذا كان لديك شروط متعددة تحتاج التعامل معها، يمكنك استخدام `if` بالإضافة مع `else if`.
+
+```js
+if (num > 15) {
+  return "Bigger than 15";
+} else if (num < 5) {
+  return "Smaller than 5";
+} else {
+  return "Between 5 and 15";
+}
+```
+
+# --instructions--
+
+حول المنطق (logic) لاستخدام `else if`.
+
+# --hints--
+
+يجب أن يكون لديك اثنين من تعبيرات `else` في الأقل
+
+```js
+assert(code.match(/else/g).length > 1);
+```
+
+يجب أن يكون لديك اثنين من تعبيرات `if` في الأقل
+
+```js
+assert(code.match(/if/g).length > 1);
+```
+
+يجب أن يكون لديك قوسين منحين (curly braces) لكل `if else` لكتابه الكود بداخلها.
+
+```js
+assert(
+  code.match(
+    /if\s*\((.+)\)\s*\{[\s\S]+\}\s*else\s+if\s*\((.+)\)\s*\{[\s\S]+\}\s*else\s*\{[\s\S]+\s*\}/
+  )
+);
+```
+
+يجب أن تنتج `testElseIf(0)` المقطع `Smaller than 5`
+
+```js
+assert(testElseIf(0) === 'Smaller than 5');
+```
+
+يجب أن تنتج `testElseIf(5)` مقطع `Between 5 and 10`
+
+```js
+assert(testElseIf(5) === 'Between 5 and 10');
+```
+
+يجب أن تنتج `testElseIf(7)` مقطع `Between 5 and 10`
+
+```js
+assert(testElseIf(7) === 'Between 5 and 10');
+```
+
+يجب أن تنتج `testElseIf(10)` مقطع `Between 5 and 10`
+
+```js
+assert(testElseIf(10) === 'Between 5 and 10');
+```
+
+يجب أن تنتج `testElseIf(12)` مقطع `Greater than 10`
+
+```js
+assert(testElseIf(12) === 'Greater than 10');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testElseIf(val) {
+  if (val > 10) {
+    return "Greater than 10";
+  }
+
+  if (val < 5) {
+    return "Smaller than 5";
+  }
+
+  return "Between 5 and 10";
+}
+
+testElseIf(7);
+```
+
+# --solutions--
+
+```js
+function testElseIf(val) {
+  if(val > 10) {
+    return "Greater than 10";
+  } else if(val < 5) {
+    return "Smaller than 5";
+  } else {
+    return "Between 5 and 10";
+  }
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-statements.md

@@ -0,0 +1,106 @@
+---
+id: 56533eb9ac21ba0edf2244da
+title: مقدمة ألى تعبيرات Else
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cek4Efq'
+forumTopicId: 18207
+dashedName: introducing-else-statements
+---
+
+# --description--
+
+عندما يكون شرط العبارة `if` صحيحًا، يتم تنفيذ كتلة التعليمات البرمجية التي تليها. ماذا عن عندما يكون هذا الشرط خطأ؟ عادة لن يحدث شيء. باستخدام عبارة `else`، يمكن تنفيذ كتلة بديلة من التعليمات البرمجية.
+
+```js
+if (num > 10) {
+  return "Bigger than 10";
+} else {
+  return "10 or Less";
+}
+```
+
+# --instructions--
+
+ادمج عبارات `if` في عبارة واحدة `if/else`.
+
+# --hints--
+
+يجب أن يكون لديك عبارة `if` واحدة فقط في المحرر
+
+```js
+assert(code.match(/if/g).length === 1);
+```
+
+يجب عليك استخدام عبارة `else`
+
+```js
+assert(/else/g.test(code));
+```
+
+يجب أن تنتج `testElse(4)` مقطع `5 or Smaller`
+
+```js
+assert(testElse(4) === '5 or Smaller');
+```
+
+يجب أن تنتج `testElse(5)` مقطع `5 or Smaller`
+
+```js
+assert(testElse(5) === '5 or Smaller');
+```
+
+يجب أن تنتج `testElse(6)` مقطع `Bigger than 5`
+
+```js
+assert(testElse(6) === 'Bigger than 5');
+```
+
+يجب أن تنتج `testElse(10)` مقطع `Bigger than 5`
+
+```js
+assert(testElse(10) === 'Bigger than 5');
+```
+
+لا يجب عليك تعديل الكود فوق التعليق المحدد.
+
+```js
+assert(/let result = "";/.test(code) && /return result;/.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function testElse(val) {
+  let result = "";
+  // Only change code below this line
+
+  if (val > 5) {
+    result = "Bigger than 5";
+  }
+
+  if (val <= 5) {
+    result = "5 or Smaller";
+  }
+
+  // Only change code above this line
+  return result;
+}
+
+testElse(4);
+```
+
+# --solutions--
+
+```js
+function testElse(val) {
+  let result = "";
+  if(val > 5) {
+    result = "Bigger than 5";
+  } else {
+    result = "5 or Smaller";
+  }
+  return result;
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-odd-numbers-with-a-for-loop.md

@@ -0,0 +1,69 @@
+---
+id: 56104e9e514f539506016a5c
+title: تكرار الأرقام الفردية باستخدام حلقة For التكرارية (Iterate Odd Numbers With a For Loop)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cm8n7T9'
+forumTopicId: 18212
+dashedName: iterate-odd-numbers-with-a-for-loop
+---
+
+# --description--
+
+لا تتطلب For loops مرور علي عناصر واحد تلو الآخر. بتغيير `final-expression` الخاص بك، يمكننا أن تعد بأرقام زوجية.
+
+سنبدأ عند `i = 0` والحلقة (loop) مادام `i < 10`. أكثر قيمة `i` بمقدار 2 في كل loop باستخدام `i += 2`.
+
+```js
+const ourArray = [];
+
+for (let i = 0; i < 10; i += 2) {
+  ourArray.push(i);
+}
+```
+
+سوف تحتوي `ourArray` على `[0, 2, 4, 6, 8]` الآن. غيّر `initialization` حتى نتمكن من عد بالأرقام الفردية.
+
+# --instructions--
+
+اضف الأرقام الفردية من 1 ألى 9 ألى `myArray` باستخدام حلقة `for`.
+
+# --hints--
+
+يجب أن تستخدم حلقة `for`.
+
+```js
+assert(/for\s*\([^)]+?\)/.test(code));
+```
+
+يجب أن يساوي `myArray` قيمة `[1, 3, 5, 7, 9]`.
+
+```js
+assert.deepEqual(myArray, [1, 3, 5, 7, 9]);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [];
+for (let i = 1; i < 10; i += 2) {
+  myArray.push(i);
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop.md

@@ -0,0 +1,81 @@
+---
+id: 5675e877dbd60be8ad28edc6
+title: التكرار عبر محتويات قائمة باستخدام حلقة for
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/caeR3HB'
+forumTopicId: 18216
+dashedName: iterate-through-an-array-with-a-for-loop
+---
+
+# --description--
+
+من المهام الشائعة في JavaScript، التكرار عبر محتويات القائمة. إحدى الطرق لفعل ذلك هي استخدام حلقة `for`. سينتج هذا الكود كل عنصر من قائمة `arr` إلى وحدة التحكم:
+
+```js
+const arr = [10, 9, 8, 7, 6];
+
+for (let i = 0; i < arr.length; i++) {
+   console.log(arr[i]);
+}
+```
+
+تذكر أن القوائم (arrays) لديها ترتيب (index) قائم على الصفر، مما يعني أن ترتيب الأخير في القائمة (array) هو `length - 1`. يكون شرطك لهذه الحلقة (loop) هو `i < arr.length`، الذي يوقف الحلقة (loop) عندما `i` يساوي `length`. في هذه الحالة يكون آخر تكرار `i === 4`, بمعنى عندما تصبح `i` مساوي `arr.length - 1` وتنتج `6` ألى وحدة التحكم. ثم `i` يزيد إلى `5`، وتنتهي الحلقة (loop) لأن `i < arr.length` يكون `false`.
+
+# --instructions--
+
+عرف وهيئ المتغير `total` ليساوي `0`. استخدم الحلقة (loop) باسم `for` لإضافة قيمة كل عنصر من `myArr` إلى `total`.
+
+# --hints--
+
+يجب تعريف وتهيئة `total` إلى 0.
+
+```js
+assert(code.match(/(var|let|const)\s*?total\s*=\s*0.*?;?/));
+```
+
+يجب أن يساوي `total` قيمة 20.
+
+```js
+assert(total === 20);
+```
+
+يجب عليك استخدام حلقة `for` للتكرار عبر `myArr`.
+
+```js
+assert(/for\s*\(/g.test(code) && /myArr\s*\[/g.test(code));
+```
+
+لا يجب عليك محاولة تعيين القيمة 20 إلى `total` قاصدًا.
+
+```js
+assert(!__helpers.removeWhiteSpace(code).match(/total[=+-]0*[1-9]+/gm));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(){if(typeof total !== 'undefined') { return "total = " + total; } else { return "total is undefined";}})()
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArr = [2, 3, 4, 5, 6];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArr = [2, 3, 4, 5, 6];
+let total = 0;
+
+for (let i = 0; i < myArr.length; i++) {
+  total += myArr[i];
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops.md

@@ -0,0 +1,105 @@
+---
+id: 5a2efd662fb457916e1fe604
+title: التكرار مع الحلَقات Do...While في JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cDqWGcp'
+forumTopicId: 301172
+dashedName: iterate-with-javascript-do---while-loops
+---
+
+# --description--
+
+النوع التالي من الحلَقات (loops) التي سوف تتعلمها يسمى حلقة `do...while`. إنه يسمى حلقة `do...while` لأنه سيقوم أولاً `do` بتطبيق الكود داخل الحلقة لمرة واحدة بغض النظر عن أي شيء، ثم يستمر في تشغيل الحلقة بينما `while` الشرط المحدد يقيم إلى `true`.
+
+```js
+const ourArray = [];
+let i = 0;
+
+do {
+  ourArray.push(i);
+  i++;
+} while (i < 5);
+```
+
+المثال أعلاه يتصرف بطريقة مشابهة للأنواع الأخرى من حلَقات، والحلقة الناتجة عنه ستبدو مثل `[0, 1, 2, 3, 4]`. ومع ذلك، فإن ما يجعل `do...while` يختلف عن الحلَقات الأخرى هو كيف يتصرف عندما يفشل الشرط في الفحص الأول. سوف ترى هذا في الواقع. إليك حلقة `while` عادية, سوف يشغل الكود الحلقة (loop) مادام أن `i < 5`:
+
+```js
+const ourArray = []; 
+let i = 5;
+
+while (i < 5) {
+  ourArray.push(i);
+  i++;
+}
+```
+
+في هذا المثال، نقوم بتهيئة قيمة `ourArray` إلى قائمة (array) فارغة وقيمة `i` إلى 5. عندما تنفيذ حلقة `while`, يتم تقييم الشرط إلى `false` لأن `i` لم يقل عن 5، لذلك نحن لا ننفذ الكود داخل الحلقة. والنتيجة هي أن `ourArray` سينتهي به الأمر إلى عدم إضافة قيم إليه، وسيظل يبدو مثل `[]` عندما يكون الكود في المثال أعلاه قد انتهي من التنفيذ. الآن، ألقي النَّظْرَة على حلقة `do...while`:
+
+```js
+const ourArray = []; 
+let i = 5;
+
+do {
+  ourArray.push(i);
+  i++;
+} while (i < 5);
+```
+
+في هذه الحالة، نقوم بتهيئة قيمة `i` إلى 5، تماما كما فعلنا مع حلقة `while`. عندما نصل إلى السطر التالي، لا يوجد شرط للتقييم، لذا نذهب إلى الكود داخل الأقواس {} وننفذه. سوف نضيف عنصرا واحدا إلى القائمة ثم نزيد `i` قبل أن نصل إلى التحقق من الشرط. عندما نقوم أخيرا بتقييم الشرط `i < 5` في السطر الأخير، نحن نرى أن `i` هو 6 الآن، و بالتالي أخفق في الفحص الشرطي، لذلك الخروج من الحلقة و ينتهي التنفيذ. في نهاية المثال الوارد أعلاه، قيمة `ourArray` هي `[5]`. في الأساس `do...while` تضمن أن الكود داخل الحلقة سوف يعمل مرة واحدة في الأقل. حاول جعل `do...while` تعمل عن طريق أضافه القيم إلى القائمة.
+
+# --instructions--
+
+غيّر `while` في الكود إلى `do...while` حتى تقوم الحلقة بإضافة فقط الرَّقْم `10` إلى `myArray`، و `i` سيكون مساويا ألى `11` عند الانتهاء من تشغيل الكود الخاص بك.
+
+# --hints--
+
+يجب أن تستخدم حلقة `do...while` لهذا التمرين.
+
+```js
+assert(code.match(/do/g));
+```
+
+يجب أن يساوي `myArray` قيمة `[10]`.
+
+```js
+assert.deepEqual(myArray, [10]);
+```
+
+يجب أن يساوي `i` قيمة `11`
+
+```js
+assert.equal(i, 11);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [];
+let i = 10;
+
+// Only change code below this line
+while (i < 5) {
+  myArray.push(i);
+  i++;
+}
+```
+
+# --solutions--
+
+```js
+const myArray = [];
+let i = 10;
+do {
+  myArray.push(i);
+  i++;
+} while (i < 5)
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops.md

@@ -0,0 +1,81 @@
+---
+id: cf1111c1c11feddfaeb5bdef
+title: التكرار مع الحلَقات For في JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9yNVCe'
+forumTopicId: 18219
+dashedName: iterate-with-javascript-for-loops
+---
+
+# --description--
+
+يمكنك تشغيل نفس الكود عدة مرات باستخدام حلقة.
+
+النوع الأكثر شيوعاً من حلقة JavaScript يسمى حلقة `for` لأنه يعمل لعدد محدد من المرات.
+
+تعريف حلَقات For مع ثلاث عبارات اختيارية تفصل بينها الفاصلات المنقوطة (semicolons):
+
+`for (a; b; c)`، حيث ان `a` هي عبارة التهيئة، `b` هي عبارة الشرط، و `c` هي العبارة النهائية.
+
+يتم تنفيذ عبارة التهيئة مرة واحدة فقط قبل بَدْء الحلقة. يستخدم عادة لتحديد وإعداد متغير الحلقة الخاص بك.
+
+يتم تقييم عبارة الشرط في بداية كل حلقة وسوف يستمر مادام أنه يقيّم إلى `true`. عندما يكون الشرط `false` في بداية الحلقة سوف تتوقف الحلقة عن التنفيذ. هذا يعني أن إذا بدأ الشرط كزائف (false)، لن تنفذ الحلقة (loop) الخاصة بك أبدا.
+
+يتم تنفيذ العبارة النهائية في نهاية كل حلقة (loop)، قبل التحقق من الشرط التالي وعادة ما يتم استخدامه لزيادة أو إنقاص عداد الحلقة.
+
+في المثال التالي نقوم بالتهيئة بواسطة `i = 0` ونكرر مادام الشرط `i < 5` هو حقيقي (true). زد `i` بمقدار `1` في كل حلقة (loop) مع `i++` كعبارة نهائية.
+
+```js
+const ourArray = [];
+
+for (let i = 0; i < 5; i++) {
+  ourArray.push(i);
+}
+```
+
+سيحتوي `ourArray` على قيمة `[0, 1, 2, 3, 4]`.
+
+# --instructions--
+
+استخدم حلقة `for` لإضافة القيم من 1 إلى 5 إلى `myArray`.
+
+# --hints--
+
+يجب أن تستخدم حلقة `for`.
+
+```js
+assert(/for\s*\([^)]+?\)/.test(code));
+```
+
+يجب أن يساوي `myArray` قيمة `[1, 2, 3, 4, 5]`.
+
+```js
+assert.deepEqual(myArray, [1, 2, 3, 4, 5]);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if (typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [];
+for (let i = 1; i < 6; i++) {
+  myArray.push(i);
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-while-loops.md

@@ -0,0 +1,75 @@
+---
+id: cf1111c1c11feddfaeb1bdef
+title: التكرار حلَقات While في JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c8QbnCM'
+forumTopicId: 18220
+dashedName: iterate-with-javascript-while-loops
+---
+
+# --description--
+
+يمكنك تشغيل نفس الكود عدة مرات باستخدام حلقة.
+
+النوع الأول من الحلقة التي سنتعلمها تسمى حلقة `while` لأنها تعمل بينما يكون الشرط المحدد صحيحا ويتوقف عندما يصبح الشرط غير صحيح.
+
+```js
+const ourArray = [];
+let i = 0;
+
+while (i < 5) {
+  ourArray.push(i);
+  i++;
+}
+```
+
+في مثال الكود أعلاه، `while` سوف تنفذ 5 مرات و تضيف الأرقام من 0 إلى 4 إلى `ourArray`.
+
+دعونا نحاول جعل حلقة while تعمل عن طريق أضافة القيم إلى قائمة.
+
+# --instructions--
+
+أضف الأرقام 5 إلى 0 (شاملة) بترتيب تنازلي إلى `myArray` باستخدام `while`.
+
+# --hints--
+
+يجب أن تستخدم حلقة `while`.
+
+```js
+assert(code.match(/while/g));
+```
+
+يجب أن يساوي `myArray` قيمة `[5, 4, 3, 2, 1, 0]`.
+
+```js
+assert.deepEqual(myArray, [5, 4, 3, 2, 1, 0]);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [];
+let i = 5;
+while (i >= 0) {
+  myArray.push(i);
+  i--;
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/local-scope-and-functions.md

@@ -0,0 +1,86 @@
+---
+id: 56533eb9ac21ba0edf2244bf
+title: النطاق المحلي والوظائف (Local Scope and Functions)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cd62NhM'
+forumTopicId: 18227
+dashedName: local-scope-and-functions
+---
+
+# --description--
+
+المتغيرات التي يتم تعريفها داخل وظيفة، وكذلك الحجج الوظيفة لديها نطاق و يكون <dfn>محلي</dfn>. وهذا يعني أنها لا تبد مرئية إلا في إطار الوظيفة.
+
+هذه وظيفة `myTest` مع متغير محلي يسمى `loc`.
+
+```js
+function myTest() {
+  const loc = "foo";
+  console.log(loc);
+}
+
+myTest();
+console.log(loc);
+```
+
+استدعاء الوظيفة `myTest()` ستعرض المقطع `foo` في وحدة التحكم. سيؤدي سطر `console.log(loc)` (خارج وظيفة `myTest`) إلى ظهور خطأ، حيث إن `loc` لم يتم تعريفها خارج الوظيفة.
+
+# --instructions--
+
+يحتوي المحرر على اثنين `console.log` لمساعدتك على رؤية ما يحدث. تحقق من وحدة التحكم خلال كتابة الكود لترى كيف يتغير. عرف متغير محلي اسمه `myVar` داخل `myLocalScope` وشغل الاختبارات.
+
+**ملاحظة:** وحدة التحكم ستظل تعرض `ReferenceError: myVar is not defined`، ولكن هذا لن يتسبب في فشل الاختبارات.
+
+# --hints--
+
+لا ينبغي أن يحتوي الكود على متغير عام يدعي `myVar`.
+
+```js
+function declared() {
+  myVar;
+}
+
+assert.throws(declared, ReferenceError);
+```
+
+يجب عليك إضافة متغير محلي يدعي `myVar`.
+
+```js
+assert(
+  /functionmyLocalScope\(\)\{.*(var|let|const)myVar[\s\S]*}/.test(
+    __helpers.removeWhiteSpace(code)
+  )
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function myLocalScope() {
+  // Only change code below this line
+
+  console.log('inside myLocalScope', myVar);
+}
+myLocalScope();
+
+// Run and check the console
+// myVar is not defined outside of myLocalScope
+console.log('outside myLocalScope', myVar);
+```
+
+# --solutions--
+
+```js
+function myLocalScope() {
+  // Only change code below this line
+  let myVar;
+  console.log('inside myLocalScope', myVar);
+}
+myLocalScope();
+
+// Run and check the console
+// myVar is not defined outside of myLocalScope
+console.log('outside myLocalScope', myVar);
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/logical-order-in-if-else-statements.md

@@ -0,0 +1,109 @@
+---
+id: 5690307fddb111c6084545d7
+title: الترتيب المنطقي في تعبيرات If Else
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cwNvMUV'
+forumTopicId: 18228
+dashedName: logical-order-in-if-else-statements
+---
+
+# --description--
+
+الترتيب مهم في عبارات `if` و `else if`.
+
+يتم تنفيذ الوظيفة من الأعلى إلى الأسفل، لذا سترغب في توخي الحذر بشأن العبارة التي تأتي أولاً.
+
+ولنأخذ هاتين الوظيفتين كمثال.
+
+إليك الأول:
+
+```js
+function foo(x) {
+  if (x < 1) {
+    return "Less than one";
+  } else if (x < 2) {
+    return "Less than two";
+  } else {
+    return "Greater than or equal to two";
+  }
+}
+```
+
+أما الثاني فيغير ترتيب العبارات فقط:
+
+```js
+function bar(x) {
+  if (x < 2) {
+    return "Less than two";
+  } else if (x < 1) {
+    return "Less than one";
+  } else {
+    return "Greater than or equal to two";
+  }
+}
+```
+
+بينما تبدو هاتان الوظيفتان متطابقتان تقريباً، إذا مررنا رَقْم إلى كليهما نحصل على نواتج مختلفة.
+
+```js
+foo(0)
+bar(0)
+```
+
+سوف ينتج `foo(0)` المقطع `Less than one`، وسوف ينتج `bar(0)` المقطع `Less than two`.
+
+# --instructions--
+
+غيّر ترتيب المنطق في الوظيفة بحيث تنتج العبارات الصحيحة في جميع الحالات.
+
+# --hints--
+
+يجب أن تنتج `orderMyLogic(4)` المقطع `Less than 5`
+
+```js
+assert(orderMyLogic(4) === 'Less than 5');
+```
+
+يجب أن تنتج `orderMyLogic(6)` المقطع `Less than 10`
+
+```js
+assert(orderMyLogic(6) === 'Less than 10');
+```
+
+يجب أن تنتج `orderMyLogic(11)` المقطع `Greater than or equal to 10`
+
+```js
+assert(orderMyLogic(11) === 'Greater than or equal to 10');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function orderMyLogic(val) {
+  if (val < 10) {
+    return "Less than 10";
+  } else if (val < 5) {
+    return "Less than 5";
+  } else {
+    return "Greater than or equal to 10";
+  }
+}
+
+orderMyLogic(7);
+```
+
+# --solutions--
+
+```js
+function orderMyLogic(val) {
+  if(val < 5) {
+    return "Less than 5";
+  } else if (val < 10) {
+    return "Less than 10";
+  } else {
+    return "Greater than or equal to 10";
+  }
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-pop.md

@@ -0,0 +1,90 @@
+---
+id: 56bbb991ad1ed5201cd392cc
+title: تغيير القوائم (Arrays) باستخدام pop()
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRbVZAB'
+forumTopicId: 18236
+dashedName: manipulate-arrays-with-pop
+---
+
+# --description--
+
+طريقة أخرى لتغيير البيانات في قائمة (Array) هي باستخدام الوظيفة `.pop()`.
+
+تستخدم الوظيفة `.pop()` لإزالة قيمة من نهاية القائمة. يمكننا تخزين هذه القيمة المستخرجة عن طريق تعيينها إلى متغير. بعبارة أخرى، تزيل الوظيفة `.pop()` العنصر الأخير من قائمة وتنتج ذلك العنصر.
+
+أي نوع من البيانات يمكن أن تستخرج من القائمة - الأرقام، المقاطع، حتى القوائم المتداخلة.
+
+```js
+const threeArr = [1, 4, 6];
+const oneDown = threeArr.pop();
+console.log(oneDown);
+console.log(threeArr);
+```
+
+سيعرض أول `console.log` قيمة `6`، وسيعرض الثاني قيمة `[1, 4]`.
+
+# --instructions--
+
+استخدم وظيفة `.pop()` لإزالة العنصر الأخير من `myArray` وعيّن القيمة المستخرجة إلى متغير جديد `removedFromMyArray`.
+
+# --hints--
+
+يجب أن يحتوي `myArray` على `[["John", 23]]` فقط.
+
+```js
+assert(
+  (function (d) {
+    if (d[0][0] == 'John' && d[0][1] === 23 && d[1] == undefined) {
+      return true;
+    } else {
+      return false;
+    }
+  })(myArray)
+);
+```
+
+يجب عليك استخدام `pop()` على `myArray`.
+
+```js
+assert(/removedFromMyArray\s*=\s*myArray\s*.\s*pop\s*(\s*)/.test(code));
+```
+
+يجب أن يحتوي `removedFromMyArray` على `["cat", 2]` فقط.
+
+```js
+assert(
+  (function (d) {
+    if (d[0] == 'cat' && d[1] === 2 && d[2] == undefined) {
+      return true;
+    } else {
+      return false;
+    }
+  })(removedFromMyArray)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if (typeof removedFromMyArray !== 'undefined') (function(y, z){return 'myArray = ' + JSON.stringify(y) + ' & removedFromMyArray = ' + JSON.stringify(z);})(myArray, removedFromMyArray);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [["John", 23], ["cat", 2]];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [["John", 23], ["cat", 2]];
+const removedFromMyArray = myArray.pop();
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-push.md

@@ -0,0 +1,78 @@
+---
+id: 56bbb991ad1ed5201cd392cb
+title: تغيير القوائم (Arrays) باستخدام push()
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cnqmVtJ'
+forumTopicId: 18237
+dashedName: manipulate-arrays-with-push
+---
+
+# --description--
+
+طريقة سهلة لإضافة البيانات إلى نهاية القائمة هي عن طريق وظيفة `push()`.
+
+يأخذ `.push()` واحد أو أكثر من <dfn>الحجج</dfn> و "يدفعها" إلى نهاية القائمة.
+
+على سبيل المثال:
+
+```js
+const arr1 = [1, 2, 3];
+arr1.push(4);
+
+const arr2 = ["Stimpson", "J", "cat"];
+arr2.push(["happy", "joy"]);
+```
+
+لدي `arr1` قيمة `[1, 2, 3, 4]` الآن ولدي `arr2` قيمة `["Stimpson", "J", "cat", ["happy", "joy"]]`.
+
+# --instructions--
+
+اضف `["dog", 3]` إلي نهاية المتغير `myArray`.
+
+# --hints--
+
+يجب أن يساوي `myArray` قيمة `[["John", 23], ["cat", 2], ["dog", 3]]` الآن.
+
+```js
+assert(
+  (function (d) {
+    if (
+      d[2] != undefined &&
+      d[0][0] == 'John' &&
+      d[0][1] === 23 &&
+      d[2][0] == 'dog' &&
+      d[2][1] === 3 &&
+      d[2].length == 2
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })(myArray)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'myArray = ' + JSON.stringify(z);})(myArray);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [["John", 23], ["cat", 2]];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [["John", 23], ["cat", 2]];
+myArray.push(["dog",3]);
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-shift.md

@@ -0,0 +1,88 @@
+---
+id: 56bbb991ad1ed5201cd392cd
+title: تغيير القوائم (Arrays) باستخدام shift()
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRbVETW'
+forumTopicId: 18238
+dashedName: manipulate-arrays-with-shift
+---
+
+# --description--
+
+يزيل `pop()` العنصر الأخير من القائمة دائما. ماذا لو كنت تريد إزالة الأول؟
+
+هنا يأتي دور `.shift()`. يعمل تماما مثل `.pop()`، ولكنه يزيل العنصر الأول بدلا من العنصر الأخير.
+
+مثال:
+
+```js
+const ourArray = ["Stimpson", "J", ["cat"]];
+const removedFromOurArray = ourArray.shift();
+```
+
+سيحتوي `removedFromOurArray` قيمة المقطع `Stimpson`، وسيحتوي `ourArray` على `["J", ["cat"]]`.
+
+# --instructions--
+
+استخدم الوظيفة `.shift()` لإزالة العنصر الأول من `myArray` وعيّن القيمة التي "تم نقلها" إلى متغير جديد `removedFromMyArray`.
+
+# --hints--
+
+يجب أن يساوي `myArray` قيمة `[["dog", 3]]` الآن.
+
+```js
+assert(
+  (function (d) {
+    if (d[0][0] == 'dog' && d[0][1] === 3 && d[1] == undefined) {
+      return true;
+    } else {
+      return false;
+    }
+  })(myArray)
+);
+```
+
+يجب أن يحتوي `removedFromMyArray` على `["John", 23]`.
+
+```js
+assert(
+  (function (d) {
+    if (
+      d[0] == 'John' &&
+      d[1] === 23 &&
+      typeof removedFromMyArray === 'object'
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })(removedFromMyArray)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if (typeof removedFromMyArray !== 'undefined') (function(y, z){return 'myArray = ' + JSON.stringify(y) + ' & removedFromMyArray = ' + JSON.stringify(z);})(myArray, removedFromMyArray);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [["John", 23], ["dog", 3]];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [["John", 23], ["dog", 3]];
+
+// Only change code below this line
+const removedFromMyArray = myArray.shift();
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-unshift.md

@@ -0,0 +1,79 @@
+---
+id: 56bbb991ad1ed5201cd392ce
+title: تغيير القوائم (Arrays) باستخدام unshift()
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ckNDESv'
+forumTopicId: 18239
+dashedName: manipulate-arrays-with-unshift
+---
+
+# --description--
+
+ليس من ممكن استخدام `shift` في عناصر من بداية القائمة فقط، ولكن يمكنك استخدام `unshift` في عناصر في بداية القائمة أيضًا، أي يمكن أن تضيف عناصر ألى بداية القائمة.
+
+يعمل `.unshift()` تماما مثل `.push()`، ولكن بدلا من إضافة العنصر في نهاية القائمة، يضيف `unshift()` العنصر إلى بداية القائمة.
+
+مثال:
+
+```js
+const ourArray = ["Stimpson", "J", "cat"];
+ourArray.shift();
+ourArray.unshift("Happy");
+```
+
+بعد `shift` سيحتوي `ourArray` على قيمة `["J", "cat"]`. بعد `unshift` سيحتوي `ourArray` على قيمة `["Happy", "J", "cat"]`.
+
+# --instructions--
+
+أضف `["Paul", 35]` إلى بداية المتغير `myArray` باستخدام `unshift()`.
+
+# --hints--
+
+يجب أن يساوي `myArray` قيمة `[["Paul", 35], ["dog", 3]]` الآن.
+
+```js
+assert(
+  (function (d) {
+    if (
+      typeof d[0] === 'object' &&
+      d[0][0] == 'Paul' &&
+      d[0][1] === 35 &&
+      d[1][0] != undefined &&
+      d[1][0] == 'dog' &&
+      d[1][1] != undefined &&
+      d[1][1] == 3
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })(myArray)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(y, z){return 'myArray = ' + JSON.stringify(y);})(myArray);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [["John", 23], ["dog", 3]];
+myArray.shift();
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [["John", 23], ["dog", 3]];
+myArray.shift();
+myArray.unshift(["Paul", 35]);
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects.md

@@ -0,0 +1,165 @@
+---
+id: 56533eb9ac21ba0edf2244cb
+title: معالجة الكائنات المعقدة (Manipulating Complex Objects)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9yNMfR'
+forumTopicId: 18208
+dashedName: manipulating-complex-objects
+---
+
+# --description--
+
+في بعض الأحيان قد ترغب في تخزين البيانات في <dfn>هيكل بيانات</dfn> مرن. يكون كائن JavaScript إحدى الطرق للتعامل مع البيانات المرنة. أنها تسمح بتركيبات عشوائية من <dfn>المقاطع</dfn> و <dfn>الأرقام</dfn> و <dfn>الحالات المنطقية</dfn> و <dfn>القوائم</dfn> و <dfn>الوظائف</dfn> و <dfn>الكائنات</dfn>.
+
+إليك مثال لهيكل بيانات معقد:
+
+```js
+const ourMusic = [
+  {
+    "artist": "Daft Punk",
+    "title": "Homework",
+    "release_year": 1997,
+    "formats": [ 
+      "CD", 
+      "Cassette", 
+      "LP"
+    ],
+    "gold": true
+  }
+];
+```
+
+هذه قائمة تحتوي على كائن واحد داخلها. يحتوي الكائن على أجزاء مختلفة من البيانات الوصفية إي <dfn>بيانات وصفية</dfn> حول مجموعة الصور. وهو إلى ذلك, يحتوي على قائمة داخلية تدعي `formats`. إذا كنت ترغب في إضافة المزيد من سجلات الصور، يمكنك فعل ذلك عن طريق إضافة السجلات إلى القائمة العليا. تخزن كائنات البيانات في الخواص التي لها قيمة وهُوِيَّة (key-value). وفي المثال الوارد أعلاه، `"artist": "Daft Punk"` هي خاصية لها هُوِيَّة تدعى `artist` وقيمة `Daft Punk`.
+
+**ملاحظة:** ستحتاج إلى وضع فاصلة بعد كل كائن في القائمة، إلا إذا كان كائن في القائمة أخير.
+
+# --instructions--
+
+أضف السجلات الصور جديد إلى قائمة `myMusic`. أضف مقاطع `artist`, و `title`, و رَقْم `release_year`، و قائمة من المقاطع تدعي `formats`.
+
+# --hints--
+
+يجب أن تكون `myMusic` قائمة
+
+```js
+assert(Array.isArray(myMusic));
+```
+
+يجب أن يحتوي `myMusic` على عنصرين في الأقل
+
+```js
+assert(myMusic.length > 1);
+```
+
+يجب أن تكون العناصر في `myMusic` كائنات
+
+```js
+myMusic.forEach(object => {assert.typeOf(object, 'object')})
+```
+
+الكائن الخاص بك في `myMusic` يجب أن يحتوي على 4 خصائص في الأقل
+
+```js
+myMusic.forEach(object => {assert(Object.keys(object).length > 3); });
+```
+
+يجب أن يحتوي الكائن الخاص بك في `myMusic` على الخاصية `artist` التي من نوع مقطع
+
+```js
+myMusic.forEach(object => {
+  assert.containsAllKeys(object, ['artist']);
+  assert.typeOf(object.artist, 'string')
+})
+```
+
+يجب أن يحتوي الكائن الخاص بك في `myMusic` على الخاصية `title` التي من نوع مقطع
+
+```js
+myMusic.forEach(object => {
+  assert.containsAllKeys(object, ['title']);
+  assert.typeOf(object.title, 'string')
+})
+```
+
+يجب أن يحتوي الكائن الخاص بك في `myMusic` على الخاصية `release_year` التي من نوع رَقْم
+
+```js
+myMusic.forEach(object => {
+  assert.containsAllKeys(object, ['release_year']);
+  assert.typeOf(object.release_year, 'number')
+})
+```
+
+يجب أن يحتوي الكائن الخاص بك في `myMusic` على الخاصية `formats` التي من نوع قائمة
+
+```js
+myMusic.forEach(object => {
+  assert.containsAllKeys(object, ['formats']);
+  assert.typeOf(object.formats, 'array')
+})
+```
+
+يجب أن تكون `formats` قائمة من مقاطع ذات عنصرين في الأقل
+
+```js
+myMusic.forEach(object => {
+  object.formats.forEach(format => {
+    assert.typeOf(format, 'string')
+  });
+  assert.isAtLeast(object.formats.length, 2)
+})
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(x){ if (Array.isArray(x)) { return JSON.stringify(x); } return "myMusic is not an array"})(myMusic);
+```
+
+## --seed-contents--
+
+```js
+const myMusic = [
+  {
+    "artist": "Billy Joel",
+    "title": "Piano Man",
+    "release_year": 1973,
+    "formats": [
+      "CD",
+      "8T",
+      "LP"
+    ],
+    "gold": true
+  }
+];
+```
+
+# --solutions--
+
+```js
+const myMusic = [
+  {
+    "artist": "Billy Joel",
+    "title": "Piano Man",
+    "release_year": 1973,
+    "formats": [
+      "CS",
+      "8T",
+      "LP" ],
+    "gold": true
+  },
+  {
+    "artist": "ABBA",
+    "title": "Ring Ring",
+    "release_year": 1973,
+    "formats": [
+      "CS",
+      "8T",
+      "LP",
+    "CD",
+  ]
+  }
+];
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/modify-array-data-with-indexes.md

@@ -0,0 +1,87 @@
+---
+id: cf1111c1c11feddfaeb8bdef
+title: تعديل بيانات القوائم بالترتيب (Modify Array Data With Indexes)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/czQM4A8'
+forumTopicId: 18241
+dashedName: modify-array-data-with-indexes
+---
+
+# --description--
+
+على عكس المقاطع، عناصر القائمة هي <dfn>قابلة للتغيير</dfn> ويمكن تغييرها بحرية، حتى لو تم تعريف القائمة بواسطة `const`.
+
+**مثال**
+
+```js
+const ourArray = [50, 40, 30];
+ourArray[0] = 15;
+```
+
+يحتوي `ourArray` على قيمة `[15, 40, 30]`.
+
+**ملاحظة:** لا ينبغي أن تكون هناك أي مسافات بين اسم القائمة والأقواس المربعة، مثل `array [0]`. مع أنّ JavaScript قادر على معالجة هذا الأمر بشكل صحيح، إلا أن هذا قد يحير المبرمجين الآخرين الذين يقرؤون الكود الخاص بك.
+
+# --instructions--
+
+عدل البيانات المخزنة في الترتيب `0` من `myArray` إلى قيمة `45`.
+
+# --hints--
+
+يجب أن يساوي `myArray` قيمة `[45, 64, 99]` الآن.
+
+```js
+assert(
+  (function () {
+    if (
+      typeof myArray != 'undefined' &&
+      myArray[0] == 45 &&
+      myArray[1] == 64 &&
+      myArray[2] == 99
+    ) {
+      return true;
+    } else {
+      return false;
+    }
+  })()
+);
+```
+
+يجب عليك استخدام الترتيب الصحيح لتعديل القيمة في `myArray`.
+
+```js
+assert(
+  (function () {
+    if (code.match(/myArray\[0\]\s*=\s*/g)) {
+      return true;
+    } else {
+      return false;
+    }
+  })()
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myArray = [18, 64, 99];
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myArray = [18, 64, 99];
+myArray[0] = 45;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/multiple-identical-options-in-switch-statements.md

@@ -0,0 +1,149 @@
+---
+id: 56533eb9ac21ba0edf2244df
+title: خيرات عدّة متشابهة في تعبيرات Switch
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cdBKWCV'
+forumTopicId: 18242
+dashedName: multiple-identical-options-in-switch-statements
+---
+
+# --description--
+
+إذا تم حذف عبارات `break` من عبارات `switch` لكل `case`، سيتم تنفيذ عبارات `case` التالية حتى تقابلهم عبارة `break`. إذا كان لديك مدخلات متعددة بنفس المخرج، يمكنك تمثيلها في عبارة `switch`, أليك مثال:
+
+```js
+let result = "";
+switch (val) {
+  case 1:
+  case 2:
+  case 3:
+    result = "1, 2, or 3";
+    break;
+  case 4:
+    result = "4 alone";
+}
+```
+
+ستنتج الحالات 1 و 2 و 3 جميعها نفس النتيجة.
+
+# --instructions--
+
+اكتب عبارة switch لتعيين `answer` للنطاقات التالية   
+`1-3` - `Low`  
+`4-6` - `Mid`  
+`7-9` - `High`
+
+**ملاحظة:** ستحتاج إلى `case` لكل رَقْم في النطاق.
+
+# --hints--
+
+يجب أن ينتج `sequentialSizes(1)` مقطع `Low`
+
+```js
+assert(sequentialSizes(1) === 'Low');
+```
+
+يجب أن ينتج `sequentialSizes(2)` مقطع `Low`
+
+```js
+assert(sequentialSizes(2) === 'Low');
+```
+
+يجب أن ينتج `sequentialSizes(3)` مقطع `Low`
+
+```js
+assert(sequentialSizes(3) === 'Low');
+```
+
+يجب أن ينتج `sequentialSizes(4)` مقطع `Mid`
+
+```js
+assert(sequentialSizes(4) === 'Mid');
+```
+
+يجب أن ينتج `sequentialSizes(5)` مقطع `Mid`
+
+```js
+assert(sequentialSizes(5) === 'Mid');
+```
+
+يجب أن ينتج `sequentialSizes(6)` مقطع `Mid`
+
+```js
+assert(sequentialSizes(6) === 'Mid');
+```
+
+يجب أن ينتج `sequentialSizes(7)` مقطع `High`
+
+```js
+assert(sequentialSizes(7) === 'High');
+```
+
+يجب أن ينتج `sequentialSizes(8)` مقطع `High`
+
+```js
+assert(sequentialSizes(8) === 'High');
+```
+
+يجب أن ينتج `sequentialSizes(9)` مقطع `High`
+
+```js
+assert(sequentialSizes(9) === 'High');
+```
+
+يجب ألا تستخدم أي عبارات `if` أو `else`
+
+```js
+assert(!/else/g.test(code) || !/if/g.test(code));
+```
+
+يجب أن يكون لديك تسع `case`
+
+```js
+assert(code.match(/case/g).length === 9);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function sequentialSizes(val) {
+  let answer = "";
+  // Only change code below this line
+
+
+
+  // Only change code above this line
+  return answer;
+}
+
+sequentialSizes(1);
+```
+
+# --solutions--
+
+```js
+function sequentialSizes(val) {
+  let answer = "";
+
+  switch (val) {
+    case 1:
+    case 2:
+    case 3:
+      answer = "Low";
+      break;
+    case 4:
+    case 5:
+    case 6:
+      answer = "Mid";
+      break;
+    case 7:
+    case 8:
+    case 9:
+      answer = "High";
+  }
+
+  return answer;
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-decimals-with-javascript.md

@@ -0,0 +1,52 @@
+---
+id: bd7993c9c69feddfaeb7bdef
+title: اضرب رقمين عشريين بواسطة JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ce2GeHq'
+forumTopicId: 301173
+dashedName: multiply-two-decimals-with-javascript
+---
+
+# --description--
+
+في JavaScript، يمكنك أيضًا إجراء حسابات بأرقام عشرية، تماما مثل الأرقام صحيحة.
+
+لنضرب عددين عشريين معًا لنحصل على حاصل ضربهما.
+
+# --instructions--
+
+غيّر `0.0` بحيث يساوي الناتج `5.0`.
+
+# --hints--
+
+يجب أن يساوي المتغير `product` قيمة `5.0`.
+
+```js
+assert(product === 5.0);
+```
+
+يجب عليك استخدام المشغل `*`
+
+```js
+assert(/\*/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(y){return 'product = '+y;})(product);
+```
+
+## --seed-contents--
+
+```js
+const product = 2.0 * 0.0;
+```
+
+# --solutions--
+
+```js
+const product = 2.0 * 2.5;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-numbers-with-javascript.md

@@ -0,0 +1,60 @@
+---
+id: cf1231c1c11feddfaeb5bdef
+title: ضرب رقمين باستخدام JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cP3y3Aq'
+forumTopicId: 18243
+dashedName: multiply-two-numbers-with-javascript
+---
+
+# --description--
+
+يمكننا أيضًا ضرب رَقْم في آخر.
+
+يستخدم JavaScript رمز `*` لضرب رقمين.
+
+**مثال**
+
+```js
+const myVar = 13 * 13;
+```
+
+لدي `myVar` القيمة `169` الآن.
+
+# --instructions--
+
+غيّر `0` بحيث يساوي الناتج `80`.
+
+# --hints--
+
+يجب أن يساوي المتغير `product` قيمة 80.
+
+```js
+assert(product === 80);
+```
+
+يجب عليك استخدام المشغل `*`.
+
+```js
+assert(/\*/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'product = '+z;})(product);
+```
+
+## --seed-contents--
+
+```js
+const product = 8 * 0;
+```
+
+# --solutions--
+
+```js
+const product = 8 * 10;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/nest-one-array-within-another-array.md

@@ -0,0 +1,51 @@
+---
+id: cf1111c1c11feddfaeb7bdef
+title: أدخال قائمة في قائمة اخري
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/crZQZf8'
+forumTopicId: 18247
+dashedName: nest-one-array-within-another-array
+---
+
+# --description--
+
+يمكنك أيضًا ادخال قوائم داخل القوائم الأخرى، مثل أدناه:
+
+```js
+const teams = [["Bulls", 23], ["White Sox", 45]];
+```
+
+هذا يسمى أيضا <dfn>قوائم متعددة الأبعاد</dfn>.
+
+# --instructions--
+
+أنشئ قوائم متداخلة تسمى `myArray`.
+
+# --hints--
+
+يجب أن تحتوي `myArray` على الأقل علي قائمة واحدة متداخلة داخل قائمة أخرى.
+
+```js
+assert(Array.isArray(myArray) && myArray.some(Array.isArray));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+if(typeof myArray !== "undefined"){(function(){return myArray;})();}
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+const myArray = [];
+```
+
+# --solutions--
+
+```js
+const myArray = [[1, 2, 3]];
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/nesting-for-loops.md

@@ -0,0 +1,92 @@
+---
+id: 56533eb9ac21ba0edf2244e1
+title: الحلَقات For المتداخلة
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cRn6GHM'
+forumTopicId: 18248
+dashedName: nesting-for-loops
+---
+
+# --description--
+
+إذا كان لديك قائمة متعددة الأبعاد، يمكنك استخدام نفس المنطق مثل النقطة السابقة للمرور علي من كل من القائمة وأي قوائم فرعية. إليك مثال:
+
+```js
+const arr = [
+  [1, 2], [3, 4], [5, 6]
+];
+
+for (let i = 0; i < arr.length; i++) {
+  for (let j = 0; j < arr[i].length; j++) {
+    console.log(arr[i][j]);
+  }
+}
+```
+
+هذا يخرج كل عنصر فرعي في `arr` واحد تلو الأخر. لاحظ أنه فيما يتعلق بالحلقة الداخلية، نحن نتحقق من `.length` الخاص إلى `arr[i]`، لما كان `arr[i]` هو نفسه قائمة.
+
+# --instructions--
+
+عدل الوظيفة `multiplyAll` بحيث تظهر ناتج ضرب جميع الأرقام في القائمات الفرعية من `arr`.
+
+# --hints--
+
+يجب أن ينتج `multiplyAll([[1], [2], [3]])` قيمة `6`
+
+```js
+assert(multiplyAll([[1], [2], [3]]) === 6);
+```
+
+يجب أن ينتج `multiplyAll([[1, 2], [3, 4], [5, 6, 7]])` قيمة `5040`
+
+```js
+assert(
+  multiplyAll([
+    [1, 2],
+    [3, 4],
+    [5, 6, 7]
+  ]) === 5040
+);
+```
+
+يجب أن ينتج `multiplyAll([[5, 1], [0.2, 4, 0.5], [3, 9]])` قيمة `54`
+
+```js
+assert(
+  multiplyAll([
+    [5, 1],
+    [0.2, 4, 0.5],
+    [3, 9]
+  ]) === 54
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function multiplyAll(arr) {
+  let product = 1;
+  // Only change code below this line
+
+  // Only change code above this line
+  return product;
+}
+
+multiplyAll([[1, 2], [3, 4], [5, 6, 7]]);
+```
+
+# --solutions--
+
+```js
+function multiplyAll(arr) {
+  let product = 1;
+  for (let i = 0; i < arr.length; i++) {
+    for (let j = 0; j < arr[i].length; j++) {
+      product *= arr[i][j];
+    }
+  }
+  return product;
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/passing-values-to-functions-with-arguments.md

@@ -0,0 +1,120 @@
+---
+id: 56533eb9ac21ba0edf2244bd
+title: تمرير القيم إلى الوظائف باستخدام الوسيطات
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cy8rahW'
+forumTopicId: 18254
+dashedName: passing-values-to-functions-with-arguments
+---
+
+# --description--
+
+<dfn>الحجج</dfn> هي متغيرات تعمل كعناصر ناقلة للقيم الذي يجب أن تكون مدخلة للوظيفة عند استدعائها. عندما يتم تعريف الوظيفة، فإنها تُعرَّف عادة مع واحد أو أكثر من الحجج. القيم الفعلية التي تدخل (أو <dfn>"تمرر"</dfn>) إلى وظيفة عند استدعائها هي معروفة باسم <dfn>الحجج (arguments)</dfn>.
+
+إليك وظيفة ذات حجتين، `param1` و `param2`:
+
+```js
+function testFun(param1, param2) {
+  console.log(param1, param2);
+}
+```
+
+ثم يمكننا استدعاء `testFun` مثل: `testFun("Hello", "World");`. لقد تمريرنا حجج من نوع مقطع, `Hello` و `World`. داخل الحجة، `param1` سيتساوى مع المقطع `Hello` و `param2` سيتساوى مع المقطع `World`. لاحظ أنه يمكنك استدعاء `testFun` مرة أخرى مع حجج مختلفة والمعلمات سوف تأخذ قيمة الحجج الجديدة.
+
+# --instructions--
+
+<ol><li>أنشاء وظيفة تسمى <code>functionWithArgs</code> تقبل حجج وتخرج المجموع الخاص بهم إلى وحدة التحكم.</li><li>استدعي الوظيفة برقمين كحجتين.</li></ol>
+
+# --hints--
+
+يجب أن تكون `functionWithArgs` وظيفة.
+
+```js
+assert(typeof functionWithArgs === 'function');
+```
+
+يجب أن تنتج `functionWithArgs(1,2)` قيمة `3`.
+
+```js
+if (typeof functionWithArgs === 'function') {
+  capture();
+  functionWithArgs(1, 2);
+  uncapture();
+}
+assert(logOutput == 3);
+```
+
+يجب أن تنتج `functionWithArgs(7,9)` قيمة `16`.
+
+```js
+if (typeof functionWithArgs === 'function') {
+  capture();
+  functionWithArgs(7, 9);
+  uncapture();
+}
+assert(logOutput == 16);
+```
+
+يجب عليك استدعاء `functionWithArgs` برقمين بعد تعريفه.
+
+```js
+assert(
+  /functionWithArgs\([-+]?\d*\.?\d*,[-+]?\d*\.?\d*\)/.test(
+    code.replace(/\s/g, '')
+  )
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+var logOutput = "";
+var originalConsole = console
+function capture() {
+    var nativeLog = console.log;
+    console.log = function (message) {
+        if(message) logOutput = JSON.stringify(message).trim();
+        if(nativeLog.apply) {
+          nativeLog.apply(originalConsole, arguments);
+        } else {
+          var nativeMsg = Array.prototype.slice.apply(arguments).join(' ');
+          nativeLog(nativeMsg);
+        }
+    };
+}
+
+function uncapture() {
+  console.log = originalConsole.log;
+}
+
+capture();
+```
+
+## --after-user-code--
+
+```js
+uncapture();
+
+if (typeof functionWithArgs !== "function") { 
+  (function() { return "functionWithArgs is not defined"; })();
+} else {
+  (function() { return logOutput || "console.log never called"; })();
+}
+```
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+function functionWithArgs(a, b) {
+  console.log(a + b);
+}
+functionWithArgs(10, 5);
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/practice-comparing-different-values.md

@@ -0,0 +1,78 @@
+---
+id: 599a789b454f2bbd91a3ff4d
+title: التدريب على مقارنة القيم المختلفة (Practice comparing different values)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cm8PqCa'
+forumTopicId: 301174
+dashedName: practice-comparing-different-values
+---
+
+# --description--
+
+في التحديين الأخيرين، لقد تعلمنا عن مشغل المساواة (`==`) ومشغل المساواة الصارمة (`===`). راجع بسريعة وتتدرب باستخدام هؤلاء المشغلين.
+
+إذا لم تكن القيم الذي يجري مقارنتهم من نفس النوع، يقوم المشغل المعني بالمساواة بإجراء تحويل نوعي، ثم يقوم بتقييم القيم. ومع ذلك، فإن عامل المساواة الصارمة (strict equality operator) سيقارن بين نوع البيانات والقيمة كما هي، دون تحويل نوع إلى آخر.
+
+**على سبيل المثال**
+
+`3 == '3'` يرجع `true` لأن JavaScript تحويل المقطع إلى رَقْم. يرجع `3 === '3'` حالة `false` لأن الأنواع مختلفة ولا يتم إجراء تحويل.
+
+**ملاحظة:** في JavaScript، يمكنك تحديد نوع متغير أو قيمة باستخدام مشغل `typeof` على النحو التالي:
+
+```js
+typeof 3
+typeof '3'
+```
+
+ينتج `typeof 3` المقطع `number`، ويرجع `typeof '3'` المقطع `string`.
+
+# --instructions--
+
+تقوم وظيفة `compareEquality` في المحرر بمقارنة قيمتين باستخدام مشغل المساواة. عدل الوظيفة بحيث تنتج المقطع `Equal` فقط عندما تكون القيم متساوية بصرامة (strictly equal).
+
+# --hints--
+
+يجب أن ينتج `compareEquality(10, "10")` مقطع `Not Equal`
+
+```js
+assert(compareEquality(10, '10') === 'Not Equal');
+```
+
+يجب أن ينتج `compareEquality("20", 20)` مقطع `Not Equal`
+
+```js
+assert(compareEquality('20', 20) === 'Not Equal');
+```
+
+يجب عليك استخدام المشغل `===`
+
+```js
+assert(code.match(/===/g));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function compareEquality(a, b) {
+  if (a == b) { // Change this line
+    return "Equal";
+  }
+  return "Not Equal";
+}
+
+compareEquality(10, "10");
+```
+
+# --solutions--
+
+```js
+function compareEquality(a,b) {
+  if (a === b) {
+    return "Equal";
+  }
+  return "Not Equal";
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/profile-lookup.md

@@ -0,0 +1,144 @@
+---
+id: 5688e62ea601b2482ff8422b
+title: البحث عن الملف الشخصي (Profile Lookup)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cDqW2Cg'
+forumTopicId: 18259
+dashedName: profile-lookup
+---
+
+# --description--
+
+لدينا قائمة من الكائنات التي تمثل أشخاص مختلفين في قوائم جهات الاتصال.
+
+تأخذ وظيفة `lookUpProfile` كائن `name` والخاصية (`prop`) كحجج تم كتابتها مسبقاً لك.
+
+يجب أن تتحقق الوظيفة مما إذا كان `name` هو `firstName` جهة الاتصال الفعلية والخاصية (`prop`) هي خاصية جهة الاتصال تلك.
+
+إذا كان كلاهما true، أنتج "قيمة" تلك الخاصية.
+
+إذا كان `name` لا يتطابق مع أي جهات اتصال، أرجع المقطع `No such contact`.
+
+إذا كان `prop` لا يتوافق مع أي خصائص صالحة لجهة اتصال وجدت أنها تتطابق مع `name` أنتج المقطع `No such property`.
+
+# --hints--
+
+يجب أن ينتج `lookUpProfile("Kristian", "lastName")` مقطع `Vos`
+
+```js
+assert(lookUpProfile('Kristian', 'lastName') === 'Vos');
+```
+
+يجب أن ينتج `lookUpProfile("Sherlock", "likes")` قائمة `["Intriguing Cases", "Violin"]`
+
+```js
+assert.deepEqual(lookUpProfile('Sherlock', 'likes'), [
+  'Intriguing Cases',
+  'Violin'
+]);
+```
+
+يجب أن ينتج `lookUpProfile("Harry", "likes")` قائمة
+
+```js
+assert(typeof lookUpProfile('Harry', 'likes') === 'object');
+```
+
+يجب أن ينتج `lookUpProfile("Bob", "number")` مقطع `No such contact`
+
+```js
+assert(lookUpProfile('Bob', 'number') === 'No such contact');
+```
+
+يجب أن ينتج `lookUpProfile("Bob", "potato")` مقطع `No such contact`
+
+```js
+assert(lookUpProfile('Bob', 'potato') === 'No such contact');
+```
+
+يجب أن ينتج `lookUpProfile("Akira", "address")` مقطع `No such property`
+
+```js
+assert(lookUpProfile('Akira', 'address') === 'No such property');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+const contacts = [
+  {
+    firstName: "Akira",
+    lastName: "Laine",
+    number: "0543236543",
+    likes: ["Pizza", "Coding", "Brownie Points"],
+  },
+  {
+    firstName: "Harry",
+    lastName: "Potter",
+    number: "0994372684",
+    likes: ["Hogwarts", "Magic", "Hagrid"],
+  },
+  {
+    firstName: "Sherlock",
+    lastName: "Holmes",
+    number: "0487345643",
+    likes: ["Intriguing Cases", "Violin"],
+  },
+  {
+    firstName: "Kristian",
+    lastName: "Vos",
+    number: "unknown",
+    likes: ["JavaScript", "Gaming", "Foxes"],
+  },
+];
+
+function lookUpProfile(name, prop) {
+  // Only change code below this line
+
+  // Only change code above this line
+}
+
+lookUpProfile("Akira", "likes");
+```
+
+# --solutions--
+
+```js
+const contacts = [
+  {
+    firstName: "Akira",
+    lastName: "Laine",
+    number: "0543236543",
+    likes: ["Pizza", "Coding", "Brownie Points"],
+  },
+  {
+    firstName: "Harry",
+    lastName: "Potter",
+    number: "0994372684",
+    likes: ["Hogwarts", "Magic", "Hagrid"],
+  },
+  {
+    firstName: "Sherlock",
+    lastName: "Holmes",
+    number: "0487345643",
+    likes: ["Intriguing Cases", "Violin"],
+  },
+  {
+    firstName: "Kristian",
+    lastName: "Vos",
+    number: "unknown",
+    likes: ["JavaScript", "Gaming", "Foxes"],
+  },
+];
+function lookUpProfile(name, prop) {
+  for (let i in contacts) {
+    if (contacts[i].firstName === name) {
+      return contacts[i][prop] || "No such property";
+    }
+  }
+  return "No such contact";
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/quoting-strings-with-single-quotes.md

@@ -0,0 +1,75 @@
+---
+id: 56533eb9ac21ba0edf2244b4
+title: اقتباس مقاطع بعلامات اقتباس منفردة (Quoting Strings with Single Quotes)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cbQmnhM'
+forumTopicId: 18260
+dashedName: quoting-strings-with-single-quotes
+---
+
+# --description--
+
+قيم <dfn>مقطع</dfn> في JavaScript يمكن كتابتها بعلامات اقتباس فردية أو مزدوجة، مادام تبدأ وتنتهي بنفس النوع من العلامات. وخلافا لبعض لغات البرمجة الأخرى، يفعل الاقتباس المنفرد والاقتباس المزدوج الشيء نفسه في JavaScript.
+
+```js
+const doubleQuoteStr = "This is a string"; 
+const singleQuoteStr = 'This is also a string';
+```
+
+السبب في رغبتك في استخدام نوع من الاقتباس فوق الآخر هو إذا كنت ترغب في استخدام كلا النوعين في المقطع. قد يحدث هذا إذا كنت ترغب في حفظ محادثة في المقطع ووضع المحادثة بين علامات الاقتباس. استخدام آخر له هو حفظ علامة `<a>` مع سمات مختلفة في علامات الاقتباس، كل ذلك ضمن مقطع.
+
+```js
+const conversation = 'Finn exclaims to Jake, "Algebraic!"';
+```
+
+ومع ذلك، تصبح هذه مشكلة إذا كنت بحاجة إلى استخدام علامات الاقتباس الخارجية بداخلها. تذكر أن المقطع يحتوي على نفس النوع من علامات الاقتباس في البداية والنهاية. ولكن إذا كان لديك نفس علامات الاقتباس في مكان ما في المنتصف، فإن المقطع سيتوقف مبكراً وسيتسبب بخطأ.
+
+```js
+const goodStr = 'Jake asks Finn, "Hey, let\'s go on an adventure?"'; 
+const badStr = 'Finn responds, "Let's go!"';
+```
+
+هنا `badStr` سوف تسبب بخطأ.
+
+في <dfn>goodStr</dfn> أعلاه، يمكنك استخدام أي من علامات الاقتباس بأمان باستخدام الخط المائل (backslash) الآتية `\` كرمز متحايل (escape character).
+
+**ملاحظة:** يجب عدم الخلط بين الخط المائل (blackslash) الآتية `\` والخط المائل للأمام (forward slash) الآتية `/`. إنهم لا يفعلون الشيء نفسه.
+
+# --instructions--
+
+غيّر المقطع المقدم إلى مقطع مع اقتباسات فردية في البداية والنهاية وبدون رموز متحايلة (escape characters).
+
+الآن، العلامة `<a>` في المقطع تستخدم اقتباسات مزدوجة في كل مكان. سوف تحتاج إلى تغيير الاقتباسات الخارجية إلى اقتباسات فردية حتى تتمكن من إزالة الرموز متحايلة (escape characters).
+
+# --hints--
+
+يجب عليك إزالة جميع الخطوط المائلة (`\`).
+
+```js
+assert(
+  !/\\/g.test(code) &&
+    myStr.match(
+      '\\s*<a href\\s*=\\s*"http://www.example.com"\\s*target\\s*=\\s*"_blank">\\s*Link\\s*</a>\\s*'
+    )
+);
+```
+
+يجب أن يكون لديك علامتا اقتباس مفردتان `'` وأربع علامات اقتباس مزدوجة `"`.
+
+```js
+assert(code.match(/"/g).length === 4 && code.match(/'/g).length === 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+const myStr = "<a href=\"http://www.example.com\" target=\"_blank\">Link</a>";
+```
+
+# --solutions--
+
+```js
+const myStr = '<a href="http://www.example.com" target="_blank">Link</a>';
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/record-collection.md

@@ -0,0 +1,181 @@
+---
+id: 56533eb9ac21ba0edf2244cf
+title: مجموعة السجلات (Record Collection)
+challengeType: 1
+forumTopicId: 18261
+dashedName: record-collection
+---
+
+# --description--
+
+لديك object literal يمثل جزءا من مجموعة سجلات موسيقية الخاصة بك. يحتوي كل سجل على رقم معرف فريد يعدّ الهُوِيَّة والعديد من الخصائص الأخرى. ليست كل السجلات لديها معلومات كاملة.
+
+أنت تبدأ بالوظيفة `updateRecords` التي تأخذ object literal يدعي `records`، يحتوي على مجموعة ألبومات موسيقية. و `id`, و `prop` (مثل `artist` أو `tracks`)، و `value`. أكمل الوظيفة باستخدام القواعد أدناه لتعديل الكائن الممرر إلى الوظيفة.
+
+-   الوظيفة الخاص بك يجب أن يرجع دائما كائن مجموعة السجلات بِرُمَّته.
+-   إذا كان `prop` ليس `tracks` و `value` ليس مقطع فارغ، حديث أو تعيين `prop` السجلات إلى `value`.
+-   إذا كان `prop` هو `tracks` ولكن السجلات ليس لديه خاصية `tracks`، أنشئ قائمة فارغة واضف إليها `value`.
+-   إذا كان `prop` هو `tracks` و `value` ليس مقطع فارغ، أضف مقطع `value` إلي أخر سجل موجودة داخل قائمة `tracks`.
+-   إذا كان `value` هو مقطع فارغ، قم بحذف خاصية `prop` من السجلات.
+
+**ملاحظة:** يتم استخدام نسخة من `recordCollection` للاختبارات.
+
+# --hints--
+
+بعد `updateRecords(recordCollection, 5439, "artist", "ABBA")`, يجب أن يكون `artist` مقطع الآتي `ABBA`
+
+```js
+assert(
+  updateRecords(_recordCollection, 5439, 'artist', 'ABBA')[5439]['artist'] ===
+    'ABBA'
+);
+```
+
+بعد `updateRecords(recordCollection, 5439, "tracks", "Take a Chance on Me")`, يجب أن يحتوي `tracks` مقطع `Take a Chance on Me` كآخر عنصر والعنصر الوحيد.
+
+```js
+assert(
+  updateRecords(_recordCollection, 5439, 'tracks', 'Take a Chance on Me') &&
+  _recordCollection[5439]['tracks'].length === 1 &&
+  _recordCollection[5439]['tracks'].pop() === 'Take a Chance on Me'
+);
+```
+
+بعد `updateRecords(recordCollection, 2548, "artist", "")`, لا ينبغي تعيين `artist`
+
+```js
+updateRecords(_recordCollection, 2548, 'artist', '');
+assert(!_recordCollection[2548].hasOwnProperty('artist'));
+```
+
+بعد `updateRecords(recordCollection, 1245, "tracks", "Addicted to Love")`, يجب أن يحتوي `tracks` مقطع `Addicted to Love` كآخر عنصر.
+
+```js
+assert(
+  updateRecords(_recordCollection, 1245, 'tracks', 'Addicted to Love')[1245][
+    'tracks'
+  ].pop() === 'Addicted to Love'
+);
+```
+
+بعد `updateRecords(recordCollection, 2468, "tracks", "Free")`, يجب أن يحتوي `tracks` المقطع `1999` كأول عنصر.
+
+```js
+assert(
+  updateRecords(_recordCollection, 2468, 'tracks', 'Free')[2468][
+    'tracks'
+  ][0] === '1999'
+);
+```
+
+بعد `updateRecords(recordCollection, 2548, "tracks", "")`, لا ينبغي تعيين `tracks`
+
+```js
+updateRecords(_recordCollection, 2548, 'tracks', '');
+assert(!_recordCollection[2548].hasOwnProperty('tracks'));
+```
+
+بعد `updateRecords(recordCollection, 1245, "albumTitle", "Riptide")`, يجب أن يحتوي `albumTitle` مقطع `Riptide` الأتي
+
+```js
+assert(
+  updateRecords(_recordCollection, 1245, 'albumTitle', 'Riptide')[1245][
+    'albumTitle'
+  ] === 'Riptide'
+);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+const _recordCollection = {
+  2548: {
+    albumTitle: 'Slippery When Wet',
+    artist: 'Bon Jovi',
+    tracks: ['Let It Rock', 'You Give Love a Bad Name']
+  },
+  2468: {
+    albumTitle: '1999',
+    artist: 'Prince',
+    tracks: ['1999', 'Little Red Corvette']
+  },
+  1245: {
+    artist: 'Robert Palmer',
+    tracks: []
+  },
+  5439: {
+    albumTitle: 'ABBA Gold'
+  }
+};
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const recordCollection = {
+  2548: {
+    albumTitle: 'Slippery When Wet',
+    artist: 'Bon Jovi',
+    tracks: ['Let It Rock', 'You Give Love a Bad Name']
+  },
+  2468: {
+    albumTitle: '1999',
+    artist: 'Prince',
+    tracks: ['1999', 'Little Red Corvette']
+  },
+  1245: {
+    artist: 'Robert Palmer',
+    tracks: []
+  },
+  5439: {
+    albumTitle: 'ABBA Gold'
+  }
+};
+
+// Only change code below this line
+function updateRecords(records, id, prop, value) {
+  return records;
+}
+
+updateRecords(recordCollection, 5439, 'artist', 'ABBA');
+```
+
+# --solutions--
+
+```js
+const recordCollection = {
+  2548: {
+    albumTitle: 'Slippery When Wet',
+    artist: 'Bon Jovi',
+    tracks: ['Let It Rock', 'You Give Love a Bad Name']
+  },
+  2468: {
+    albumTitle: '1999',
+    artist: 'Prince',
+    tracks: ['1999', 'Little Red Corvette']
+  },
+  1245: {
+    artist: 'Robert Palmer',
+    tracks: []
+  },
+  5439: {
+    albumTitle: 'ABBA Gold'
+  }
+};
+
+// Only change code below this line
+function updateRecords(records, id, prop, value) {
+  if (value === '') delete records[id][prop];
+  else if (prop === 'tracks') {
+    records[id][prop] = records[id][prop] || [];
+    records[id][prop].push(value);
+  } else {
+    records[id][prop] = value;
+  }
+
+  return records;
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion.md

@@ -0,0 +1,105 @@
+---
+id: 5cfa3679138e7d9595b9d9d4
+title: استبدال الحلقات باستخدام التكرار (Replace Loops using Recursion)
+challengeType: 1
+videoUrl: >-
+  https://www.freecodecamp.org/news/how-recursion-works-explained-with-flowcharts-and-a-video-de61f40cb7f9/
+forumTopicId: 301175
+dashedName: replace-loops-using-recursion
+---
+
+# --description--
+
+التكرار معناه أنه يمكن استخدام الوظيفة بداخل نفسه. للمساعدة في فهم هذا، ابدأ بالتفكير في المهمة التالية: أضرب أول عناصر `n` من قائمة ليصبح لديك ناتج ضرب هذه العناصر. باستخدام حلقة `for`، يمكنك القيام بما يلي:
+
+```js
+  function multiply(arr, n) {
+    let product = 1;
+    for (let i = 0; i < n; i++) {
+      product *= arr[i];
+    }
+    return product;
+  }
+```
+
+لكن، لاحظ أن `multiply(arr, n) == multiply(arr, n - 1) * arr[n - 1]`. وهذا يعني أنه يمكنك إعادة كتابة `multiply` بداخل نفسه ولا تحتاج أبدا إلى استخدام حلقة.
+
+```js
+  function multiply(arr, n) {
+    if (n <= 0) {
+      return 1;
+    } else {
+      return multiply(arr, n - 1) * arr[n - 1];
+    }
+  }
+```
+
+النسخة المتكررة (recursive) من `multiply` توضح تفاصيل ذلك. في <dfn>حالة أصلية</dfn>، حيث `n <= 0`، فإنه ينتج 1. بالنسبة للقيم الذين أكبر من `n`، فإنه يستدعي نفسه، ولكن مع `n - 1`. يتم تقييم هذا الاستدعاء بنفس الطريقة، فيقوم باستدعاء `multiply` مرة أخرى حتى `n <= 0`. في هذه المرحلة، جميع الـ functions يمكن إرجاعها (can return) و `multiply` الأصلية ترجع (returns) الإجابة.
+
+**ملاحظة:** الـ Recursive functions يجب أن يكون لها base case عندما يتم ارجاعها دون استدعاء الـ function مره أخرى (في هذا المثال ، عندما يكون `n <= 0`) ، وإلا فلن يتمكنوا أبدا من إنهاء التنفيذ.
+
+# --instructions--
+
+اكتب الـ recursive function الآتية `sum(arr, n)`، والتي سترجع مجموع العناصر الأولى `n` من الـ array الآتية `arr`.
+
+# --hints--
+
+`sum([1], 0)` يجب أن يساوي 0.
+
+```js
+assert.equal(sum([1], 0), 0);
+```
+
+`sum([2, 3, 4], 1)` يجب أن يساوي 2.
+
+```js
+assert.equal(sum([2, 3, 4], 1), 2);
+```
+
+`sum([2, 3, 4, 5], 3)` يجب أن يساوي 9.
+
+```js
+assert.equal(sum([2, 3, 4, 5], 3), 9);
+```
+
+لا ينبغي أن يعتمد الكود الخاص بك على أي نوع من الـ loops سواء (`for` أو `while` أو functions مثل `forEach` او `map` او `filter` أو `reduce`).
+
+```js
+assert(
+  !code.match(/for|while|forEach|map|filter|reduce/g)
+);
+```
+
+يجب عليك استخدام الـ recursion لحل هذه المشكلة.
+
+```js
+assert(
+  sum.toString().match(/sum\(.*\)/g).length > 1
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function sum(arr, n) {
+  // Only change code below this line
+
+  // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function sum(arr, n) {
+  // Only change code below this line
+  if(n <= 0) {
+    return 0;
+  } else {
+    return sum(arr, n - 1) + arr[n - 1];
+  }
+  // Only change code above this line
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch.md

@@ -0,0 +1,157 @@
+---
+id: 56533eb9ac21ba0edf2244e0
+title: استبدال If Else Chains بـ Switch
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c3JE8fy'
+forumTopicId: 18266
+dashedName: replacing-if-else-chains-with-switch
+---
+
+# --description--
+
+إذا كان لديك العديد من الخيارات للاختيار منها، `switch` يمكن أن يكون أسهل في الكتابة من الكثير من `if`/`else if`. ما يلي:
+
+```js
+if (val === 1) {
+  answer = "a";
+} else if (val === 2) {
+  answer = "b";
+} else {
+  answer = "c";
+}
+```
+
+يمكن استبداله بما يلي:
+
+```js
+switch (val) {
+  case 1:
+    answer = "a";
+    break;
+  case 2:
+    answer = "b";
+    break;
+  default:
+    answer = "c";
+}
+```
+
+# --instructions--
+
+قم بتغيير سلسلة `if`/`else if` إلى `switch`.
+
+# --hints--
+
+لا يجب عليك استخدام أي `else` في أي مكان في المحرر
+
+```js
+assert(!/else/g.test(code));
+```
+
+لا يجب عليك استخدام أي `if` في أي مكان في المحرر
+
+```js
+assert(!/if/g.test(code));
+```
+
+يجب أن يكون لديك على الأقل ٤ عبارات `break`
+
+```js
+assert(code.match(/break/g).length >= 4);
+```
+
+`chainToSwitch("bob")` يجب أن تساوي الـ string الآتي `Marley`
+
+```js
+assert(chainToSwitch('bob') === 'Marley');
+```
+
+`chainToSwitch(42)` يجب أن تساوي الـ string الآتي `The Answer`
+
+```js
+assert(chainToSwitch(42) === 'The Answer');
+```
+
+`chainToSwitch(1)` يجب أن تساوي الـ string الآتي `There is no #1`
+
+```js
+assert(chainToSwitch(1) === 'There is no #1');
+```
+
+`chainToSwitch(99)` يجب أن تساوي الـ string الآتي `Missed me by this much!`
+
+```js
+assert(chainToSwitch(99) === 'Missed me by this much!');
+```
+
+`chainToSwitch(7)` يجب أن تساوي الـ string الآتي `Ate Nine`
+
+```js
+assert(chainToSwitch(7) === 'Ate Nine');
+```
+
+`chainToSwitch("John")` يجب أن يكون `""` (string فارغ)
+
+```js
+assert(chainToSwitch('John') === '');
+```
+
+`chainToSwitch(156)` يجب أن يكون `""` (string فارغ)
+
+```js
+assert(chainToSwitch(156) === '');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function chainToSwitch(val) {
+  let answer = "";
+  // Only change code below this line
+
+  if (val === "bob") {
+    answer = "Marley";
+  } else if (val === 42) {
+    answer = "The Answer";
+  } else if (val === 1) {
+    answer = "There is no #1";
+  } else if (val === 99) {
+    answer = "Missed me by this much!";
+  } else if (val === 7) {
+    answer = "Ate Nine";
+  }
+
+  // Only change code above this line
+  return answer;
+}
+
+chainToSwitch(7);
+```
+
+# --solutions--
+
+```js
+function chainToSwitch(val) {
+  let answer = "";
+
+  switch (val) {
+    case "bob":
+      answer = "Marley";
+      break;
+    case 42:
+      answer = "The Answer";
+      break;
+    case 1:
+      answer = "There is no #1";
+      break;
+    case 99:
+      answer = "Missed me by this much!";
+      break;
+    case 7:
+      answer = "Ate Nine";
+  }
+  return answer;
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/return-a-value-from-a-function-with-return.md

@@ -0,0 +1,73 @@
+---
+id: 56533eb9ac21ba0edf2244c2
+title: إرجاع قيمة من وظيفة (Return a Value from a Function with Return)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cy87wue'
+forumTopicId: 18271
+dashedName: return-a-value-from-a-function-with-return
+---
+
+# --description--
+
+يمكننا نقل القيم إلى وظيفة باستخدام <dfn>حجج</dfn>. يمكنك استخدام `return` لإرسال قيمة إلى خارج الوظيفة.
+
+**مثال**
+
+```js
+function plusThree(num) {
+  return num + 3;
+}
+
+const answer = plusThree(5);
+```
+
+لدي `answer` القيمة `8` الآن.
+
+يأخذ `plusThree` من <dfn>الحجج</dfn> ما يقابل `num` وينتج قيمة تساوي `num + 3`.
+
+# --instructions--
+
+أنشئ وظيفة `timesFive` التي تقبل حجة واحد، وتضربه في `5`، وترجع القيمة الجديدة.
+
+# --hints--
+
+يجب أن تكون `timesFive` وظيفة
+
+```js
+assert(typeof timesFive === 'function');
+```
+
+يجب أن ينتج `timesFive(5)` قيمة `25`
+
+```js
+assert(timesFive(5) === 25);
+```
+
+يجب أن ينتج `timesFive(2)` قيمة `10`
+
+```js
+assert(timesFive(2) === 10);
+```
+
+يجب أن ينتج `timesFive(0)` قيمة `0`
+
+```js
+assert(timesFive(0) === 0);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+
+```
+
+# --solutions--
+
+```js
+function timesFive(num) {
+  return num * 5;
+}
+timesFive(10);
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.md

@@ -0,0 +1,106 @@
+---
+id: 56533eb9ac21ba0edf2244c4
+title: نمط الإنشاء المبكر للوظائف (Return Early Pattern for Functions)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cQe39Sq'
+forumTopicId: 18272
+dashedName: return-early-pattern-for-functions
+---
+
+# --description--
+
+عندما يتم الوصول إلى `return`، يتوقف تنفيذ الوظيفة الحالي ويعود التحكم إلى مكان الاستدعاء.
+
+**مثال**
+
+```js
+function myFun() {
+  console.log("Hello");
+  return "World";
+  console.log("byebye")
+}
+myFun();
+```
+
+سيتم عرض مقطع `Hello` في وحدة التحكم، وإنشاء مقطع `World`. لن يعرض مقطع `byebye` في وحدة التحكم أبدا، لأن الوظيفة تنتج عند `return`.
+
+# --instructions--
+
+عدّل الوظيفة `abTest` بحيث إذا كان `a` أو `b` أقل من `0` ستنتج الوظيفة قيمة `undefined` فوراً.
+
+**تلميح**  
+تذكر أن <a href="https://www.freecodecamp.org/learn/javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables" target="_blank" rel="noopener noreferrer nofollow">تكون <code>undefined</code> كلمة</a> وليست مقتطع.
+
+# --hints--
+
+يجب أن ينتج `abTest(2, 2)` رَقْم
+
+```js
+assert(typeof abTest(2, 2) === 'number');
+```
+
+يجب أن ينتج `abTest(2, 2)` رَقْم `8`
+
+```js
+assert(abTest(2, 2) === 8);
+```
+
+يجب أن ينتج `abTest(-2, 2)` قيمة `undefined`
+
+```js
+assert(abTest(-2, 2) === undefined);
+```
+
+يجب أن ينتج `abTest(2, -2)` قيمة `undefined`
+
+```js
+assert(abTest(2, -2) === undefined);
+```
+
+يجب أن ينتج `abTest(2, 8)` رَقْم `18`
+
+```js
+assert(abTest(2, 8) === 18);
+```
+
+يجب أن ينتج `abTest(3, 3)` رَقْم `12`
+
+```js
+assert(abTest(3, 3) === 12);
+```
+
+يجب أن ينتج `abTest(0, 0)` رَقْم `0`
+
+```js
+assert(abTest(0, 0) === 0);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+function abTest(a, b) {
+  // Only change code below this line
+
+
+
+  // Only change code above this line
+
+  return Math.round(Math.pow(Math.sqrt(a) + Math.sqrt(b), 2));
+}
+
+abTest(2,2);
+```
+
+# --solutions--
+
+```js
+function abTest(a, b) {
+  if(a < 0 || b < 0) {
+    return undefined;
+  }
+  return Math.round(Math.pow(Math.sqrt(a) + Math.sqrt(b), 2));
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/returning-boolean-values-from-functions.md

@@ -0,0 +1,82 @@
+---
+id: 5679ceb97cbaa8c51670a16b
+title: عودة القيم المنطقية من الوظيفة (Returning Boolean Values from Functions)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cp62qAQ'
+forumTopicId: 18273
+dashedName: returning-boolean-values-from-functions
+---
+
+# --description--
+
+قد تتذكر من <a href="/learn/javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator" target="_blank" rel="noopener noreferrer nofollow">المقارنات باستخدام عملية المساواة (==)</a> أن جميع مشغلي المقارنات يرجعون حالة منطقية (boolean) سواء `true` أو `false`.
+
+في بعض الأحيان يستخدم الناس `if/else` لإجراء المقارنة، مثلا:
+
+```js
+function isEqual(a, b) {
+  if (a === b) {
+    return true;
+  } else {
+    return false;
+  }
+}
+```
+
+لكن هناك طريقة أفضل لفعل ذلك. نظرًا لأن `===` يرجع `true` أو `false`، يمكنك إعادة نتيجة المقارنة:
+
+```js
+function isEqual(a, b) {
+  return a === b;
+}
+```
+
+# --instructions--
+
+أصلح الوظيفة `isLess` لإزالة تعبيرات `if/else`.
+
+# --hints--
+
+يجب أن يرجع `isLess(10, 15)` حالة `true`
+
+```js
+assert(isLess(10, 15) === true);
+```
+
+يجب أن يرجع `isLess(15, 10)` حالة `false`
+
+```js
+assert(isLess(15, 10) === false);
+```
+
+يجب ألا تستخدم أي عبارات `if` أو `else`
+
+```js
+assert(!/if|else/g.test(code));
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function isLess(a, b) {
+  // Only change code below this line
+  if (a < b) {
+    return true;
+  } else {
+    return false;
+  }
+  // Only change code above this line
+}
+
+isLess(10, 15);
+```
+
+# --solutions--
+
+```js
+function isLess(a, b) {
+  return a < b;
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/selecting-from-many-options-with-switch-statements.md

@@ -0,0 +1,114 @@
+---
+id: 56533eb9ac21ba0edf2244dd
+title: الاختيار من بين العديد من الخيارات باستخدام عبارات Switch
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c4mv4fm'
+forumTopicId: 18277
+dashedName: selecting-from-many-options-with-switch-statements
+---
+
+# --description--
+
+إذا كان لديك العديد من الخيارات للاختيار من بينهما، استخدم عبارة <dfn>switch</dfn>. تختبر عبارة `switch` قيمة ويمكن أن تحتوي على العديد من عبارات <dfn>case</dfn> التي تحدد القيم المختلفة الممكنة. يتم تنفيذ العبارات من أول قيمة `case` متطابقة حتى يتم العثور على `break`.
+
+فيما يلي مثال على عبارة `switch`:
+
+```js
+switch (lowercaseLetter) {
+  case "a":
+    console.log("A");
+    break;
+  case "b":
+    console.log("B");
+    break;
+}
+```
+
+يتم اختبار قيم `case` مساواة تامة strict equality (`===`). كلمة `break` تخبر JavaScript بالتوقف عن تنفيذ العبارات. إذا تم حذف كلمة `break`, سيتم تنفيذ العبارة التالية.
+
+# --instructions--
+
+اكتب عبارة switch تختبر `val` وتعين `answer` للشروط التالية:  
+`1` - `alpha`  
+`2` - `beta`  
+`3` - `gamma`  
+`4` - `delta`
+
+# --hints--
+
+`caseInSwitch(1)` يجب أن يكون له قيمة السلسلة (string) النصية `alpha`
+
+```js
+assert(caseInSwitch(1) === 'alpha');
+```
+
+`caseInSwitch(2)` يجب أن يكون له قيمة السلسلة (string) النصية `beta`
+
+```js
+assert(caseInSwitch(2) === 'beta');
+```
+
+`caseInSwitch(3)` يجب أن يكون له قيمة السلسلة (string) النصية `gamma`
+
+```js
+assert(caseInSwitch(3) === 'gamma');
+```
+
+`caseInSwitch(4)` يجب أن يكون له قيمة السلسلة (string) النصية `delta`
+
+```js
+assert(caseInSwitch(4) === 'delta');
+```
+
+يجب ألا تستخدم أي عبارات `if` أو `else`
+
+```js
+assert(!/else/g.test(code) || !/if/g.test(code));
+```
+
+يجب أن يكون لديك على الأقل ٣ عبارات `break`
+
+```js
+assert(code.match(/break/g).length > 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function caseInSwitch(val) {
+  let answer = "";
+  // Only change code below this line
+
+
+
+  // Only change code above this line
+  return answer;
+}
+
+caseInSwitch(1);
+```
+
+# --solutions--
+
+```js
+function caseInSwitch(val) {
+  let answer = "";
+
+  switch (val) {
+    case 1:
+      answer = "alpha";
+      break;
+    case 2:
+      answer = "beta";
+      break;
+    case 3:
+      answer = "gamma";
+      break;
+    case 4:
+      answer = "delta";
+  }
+  return answer;
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/shopping-list.md

@@ -0,0 +1,97 @@
+---
+id: 56533eb9ac21ba0edf2244bc
+title: قائمة التسوق (Shopping List)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9MEKHZ'
+forumTopicId: 18280
+dashedName: shopping-list
+---
+
+# --description--
+
+قم إنشاء قائمة تسوق في المتغير `myList`. وينبغي أن تكون القائمة multi-dimensional array (مصفوفة متعددة الأبعاد) تحتوي على عدة sub-arrays (مصفوفات فرعية).
+
+يجب أن يحتوي العنصر الأول في كل sub-array على string يحمل اسم الصنف. أما العنصر الثاني فيجب أن يكون رقماً يمثل الكمية مثل.
+
+```js
+["Chocolate Bar", 15]
+```
+
+وينبغي أن يكون في القائمة خمسة sub-arrays على الأقل.
+
+# --hints--
+
+`myList` يجب أن تكون array.
+
+```js
+assert(isArray);
+```
+
+العناصر الأولى في كل الـ sub-arrays الخاصة بك يجب أن تكون كلها strings.
+
+```js
+assert(hasString);
+```
+
+العناصر الثانية في كل الـ sub-arrays الخاصة بك يجب أن تكون كلها numbers.
+
+```js
+assert(hasNumber);
+```
+
+يجب أن يكون لديك 5 عناصر على الأقل في قائمتك.
+
+```js
+assert(count > 4);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+var count = 0;
+var isArray = false;
+var hasString = false;
+var hasNumber = false;
+(function(list){
+  if(Array.isArray(myList)) {
+    isArray = true;
+    if(myList.length > 0) {
+      hasString = true;
+      hasNumber = true;
+      for (var elem of myList) {
+        if(!elem || !elem[0] || typeof elem[0] !== 'string') {
+          hasString = false;
+        }
+        if(!elem || typeof elem[1] !== 'number') {
+          hasNumber = false;
+        }
+      }
+    }
+    count = myList.length;
+    return JSON.stringify(myList);
+  } else {
+    return "myList is not an array";
+  }
+
+})(myList);
+```
+
+## --seed-contents--
+
+```js
+const myList = [];
+```
+
+# --solutions--
+
+```js
+const myList = [
+  ["Candy", 10],
+  ["Potatoes", 12],
+  ["Eggs", 12],
+  ["Catfood", 1],
+  ["Toads", 9]
+];
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.md

@@ -0,0 +1,118 @@
+---
+id: 56533eb9ac21ba0edf2244c6
+title: قف في الصف (Stand in Line)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ca8Q8tP'
+forumTopicId: 18307
+dashedName: stand-in-line
+---
+
+# --description--
+
+في علوم الحاسب <dfn>الصف</dfn> هو <dfn>هيكل بيانات</dfn> مجرد، حيث يتم حفظ العناصر بالترتيب. يمكن إضافة عناصر جديدة في الجزء الخلفي من الصف ويتم إزالة العناصر القديمة من مقدمة الصف.
+
+# --instructions--
+
+اكتب الوظيفة `nextInLine` و التي تأخذ القائمة الآتية (`arr`) ورَقْم (`item`) كحجج.
+
+أضف الرَقْم إلى نهاية القائمة، ثم أزل العنصر الأول من القائمة.
+
+يجب أن تقوم وظيفة `nextInLine` بإرجاع العنصر الذي تمت إزالته.
+
+# --hints--
+
+يجب أن ينتج `nextInLine([], 5)` رَقْم.
+
+```js
+assert.isNumber(nextInLine([], 5));
+```
+
+يجب أن ينتج `nextInLine([], 1)` رَقْم `1`
+
+```js
+assert(nextInLine([], 1) === 1);
+```
+
+يجب أن ينتج `nextInLine([2], 1)` رَقْم `2`
+
+```js
+assert(nextInLine([2], 1) === 2);
+```
+
+يجب أن ينتج `nextInLine([5,6,7,8,9], 1)` رَقْم `5`
+
+```js
+assert(nextInLine([5, 6, 7, 8, 9], 1) === 5);
+```
+
+بعد `nextInLine(testArr, 10)`, يجب أن يتكون `testArr[4]` من `10`
+
+```js
+nextInLine(testArr, 10);
+assert(testArr[4] === 10);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+var logOutput = [];
+var originalConsole = console
+function capture() {
+    var nativeLog = console.log;
+    console.log = function (message) {
+        logOutput.push(message);
+        if(nativeLog.apply) {
+          nativeLog.apply(originalConsole, arguments);
+        } else {
+          var nativeMsg = Array.prototype.slice.apply(arguments).join(' ');
+          nativeLog(nativeMsg);
+        }
+    };
+}
+
+function uncapture() {
+  console.log = originalConsole.log;
+}
+
+capture();
+```
+
+## --after-user-code--
+
+```js
+uncapture();
+testArr = [1,2,3,4,5];
+(function() { return logOutput.join("\n");})();
+```
+
+## --seed-contents--
+
+```js
+function nextInLine(arr, item) {
+  // Only change code below this line
+
+  return item;
+  // Only change code above this line
+}
+
+// Setup
+let testArr = [1, 2, 3, 4, 5];
+
+// Display code
+console.log("Before: " + JSON.stringify(testArr));
+console.log(nextInLine(testArr, 6));
+console.log("After: " + JSON.stringify(testArr));
+```
+
+# --solutions--
+
+```js
+let testArr = [1, 2, 3, 4, 5];
+
+function nextInLine(arr, item) {
+    arr.push(item);
+    return arr.shift();
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/store-multiple-values-in-one-variable-using-javascript-arrays.md

@@ -0,0 +1,63 @@
+---
+id: bd7993c9c69feddfaeb8bdef
+title: تخزين قيم متعددة في متغير واحد باستخدام مصفوفات جافا سكريبت (Store Multiple Values in one Variable using JavaScript Arrays)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/crZQWAm'
+forumTopicId: 18309
+dashedName: store-multiple-values-in-one-variable-using-javascript-arrays
+---
+
+# --description--
+
+مع متغير جافا سكريبت الـ `array`، يمكننا تخزين عدة قطع من البيانات في مكان واحد.
+
+تبدأ تعريف الـ array بأقواس مربعه (square bracke) وتنهيها بأقواس مربعه، ووضع فاصلة بين كل إدخال، مثال:
+
+```js
+const sandwich = ["peanut butter", "jelly", "bread"];
+```
+
+# --instructions--
+
+قم بتعديل الـ array الجديدة `myArray` بحيث تحتوي على string ورقم في نفس الوقت (بهذا الترتيب).
+
+# --hints--
+
+`myArray` يجب أن يكون array.
+
+```js
+assert(typeof myArray == 'object');
+```
+
+العنصر الأول في `myArray` يجب أن يكون string.
+
+```js
+assert(typeof myArray[0] !== 'undefined' && typeof myArray[0] == 'string');
+```
+
+العنصر الثاني في `myArray` يجب أن يكون رقما.
+
+```js
+assert(typeof myArray[1] !== 'undefined' && typeof myArray[1] == 'number');
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myArray);
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+const myArray = [];
+```
+
+# --solutions--
+
+```js
+const myArray = ["The Answer", 42];
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator.md

@@ -0,0 +1,77 @@
+---
+id: 56533eb9ac21ba0edf2244a8
+title: تخزين القيم مع مشغل التعيين (Storing Values with the Assignment Operator)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cEanysE'
+forumTopicId: 18310
+dashedName: storing-values-with-the-assignment-operator
+---
+
+# --description--
+
+في JavaScript، يمكنك تخزين قيمة في متغير باستخدام مشغل <dfn>تعيين</dfn> يبدو (`=`).
+
+```js
+myVariable = 5;
+```
+
+هذا يعين `Number` بقيمة `5` إلى `myVariable`.
+
+إذا كانت هناك أي حسابات إلى يمين مشغل `=`، يتم أداء هذه حسابات قبل تعيين القيمة إلى المتغير الموجود على يسار المشغل.
+
+```js
+var myVar;
+myVar = 5;
+```
+
+أولا، هذا الكود ينشئ متغير يسمى `myVar`. ثم، الكود يعين `5` إلى `myVar`. الآن، إذا ظهر `myVar` مرة أخرى في الكود، فإن البرنامَج سيعامله كما لو أنه `5`.
+
+# --instructions--
+
+عيين قيمة `7` إلى المتغير `a`.
+
+# --hints--
+
+لا يجب عليك تعديل الكود فوق التعليق المحدد.
+
+```js
+assert(/var a;/.test(code));
+```
+
+يجب أن يحتوي `a` قيمة 7.
+
+```js
+assert(typeof a === 'number' && a === 7);
+```
+
+# --seed--
+
+## --before-user-code--
+
+```js
+if (typeof a != 'undefined') {
+  a = undefined;
+}
+```
+
+## --after-user-code--
+
+```js
+(function(a){return "a = " + a;})(a);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+var a;
+
+// Only change code below this line
+```
+
+# --solutions--
+
+```js
+var a;
+a = 7;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/subtract-one-number-from-another-with-javascript.md

@@ -0,0 +1,59 @@
+---
+id: cf1111c1c11feddfaeb4bdef
+title: طرح رقم من الآخر باستخدام JavaScript
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cP3yQtk'
+forumTopicId: 18314
+dashedName: subtract-one-number-from-another-with-javascript
+---
+
+# --description--
+
+يمكننا أيضا أن نطرح رقما من الآخر.
+
+يستخدم JavaScript رمز `-` للطرح.
+
+**مثال**
+
+```js
+const myVar = 12 - 6;
+```
+
+لدي `myVar` قيمة `6` الآن.
+# --instructions--
+
+غيّر `0` بحيث يكون الفرق `12`.
+
+# --hints--
+
+يجب أن يساوي `difference` قيمة 12.
+
+```js
+assert(difference === 12);
+```
+
+يجب عليك طرح رَقَم واحد فقط من 45.
+
+```js
+assert(/difference=45-33;?/.test(__helpers.removeWhiteSpace(code)));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return 'difference = '+z;})(difference);
+```
+
+## --seed-contents--
+
+```js
+const difference = 45 - 0;
+```
+
+# --solutions--
+
+```js
+const difference = 45 - 33;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/testing-objects-for-properties.md

@@ -0,0 +1,98 @@
+---
+id: 567af2437cbaa8c51670a16c
+title: اختبار الكائنات للخصائص (Testing Objects for Properties)
+challengeType: 1
+forumTopicId: 18324
+dashedName: testing-objects-for-properties
+---
+
+# --description--
+
+في بعض الأحيان يكون من المفيد التحقق مما إذا كانت خاصية كائن (object property) معين موجودة أم لا. يمكننا استخدام وظيفة `.hasOwnProperty(propname)` لتحديد ما إذا كان لهذا الكائن اسم خاصية معين. يرجع `.hasOwnProperty()` حالة `true` أو `false` إذا تم العثور على الخاصية أو لا.
+
+**مثال**
+
+```js
+const myObj = {
+  top: "hat",
+  bottom: "pants"
+};
+
+myObj.hasOwnProperty("top");
+myObj.hasOwnProperty("middle");
+```
+
+يرجع أول `hasOwnProperty` حالة `true`، في حين أن يرجع الثاني `false`.
+
+# --instructions--
+
+عدّل الوظيفة `checkObj` لاختبار ما إذا كان كائن تم تمريره إلى الوظيفة (`obj`) يحتوي على خاصية محددة (`checkProp`). إذا تم العثور على الخاصية، قم إرجاع قيمة تلك الخاصية. إذا لم يكن الأمر كذلك، قم إرجاع `"Not Found"`.
+
+# --hints--
+
+يجب أن ينتج `checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "gift")` مقطع `pony`.
+
+```js
+assert(
+  checkObj({ gift: 'pony', pet: 'kitten', bed: 'sleigh' }, 'gift') === 'pony'
+);
+```
+
+يجب أن ينتج `checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "pet")` مقطع `kitten`.
+
+```js
+assert(
+  checkObj({ gift: 'pony', pet: 'kitten', bed: 'sleigh' }, 'pet') === 'kitten'
+);
+```
+
+يجب أن ينتج `checkObj({gift: "pony", pet: "kitten", bed: "sleigh"}, "house")` مقطع `Not Found`.
+
+```js
+assert(
+  checkObj({ gift: 'pony', pet: 'kitten', bed: 'sleigh' }, 'house') ===
+    'Not Found'
+);
+```
+
+يجب أن ينتج `checkObj({city: "Seattle"}, "city")` مقطع `Seattle`.
+
+```js
+assert(checkObj({ city: 'Seattle' }, 'city') === 'Seattle');
+```
+
+يجب أن ينتج `checkObj({city: "Seattle"}, "district")` مقطع`Not Found`.
+
+```js
+assert(checkObj({ city: 'Seattle' }, 'district') === 'Not Found');
+```
+
+يجب أن ينتج `checkObj({pet: "kitten", bed: "sleigh"}, "gift")` مقطع `Not Found`.
+
+```js
+assert(checkObj({ pet: 'kitten', bed: 'sleigh' }, 'gift') === 'Not Found');
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+function checkObj(obj, checkProp) {
+  // Only change code below this line
+  return "Change Me!";
+  // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function checkObj(obj, checkProp) {
+  if(obj.hasOwnProperty(checkProp)) {
+    return obj[checkProp];
+  } else {
+    return "Not Found";
+  }
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/understand-string-immutability.md

@@ -0,0 +1,70 @@
+---
+id: 56533eb9ac21ba0edf2244ba
+title: فهم عدم قابلية المقطع على التغيير (Understand String Immutability)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cWPVaUR'
+forumTopicId: 18331
+dashedName: understand-string-immutability
+---
+
+# --description--
+
+في JavaScript، قيم `String` هي قيم <dfn>قابلة للتغيير</dfn>، مما يعني أنه لا يمكن تغييرها بمجرد إنشائها.
+
+على سبيل المثال الكود التالي سيحدث خطأ لأن الحرف `B` في المقطع `Bob` لا يمكن تغييره إلى الحرف `J`:
+
+```js
+let myStr = "Bob";
+myStr[0] = "J";
+```
+
+لاحظ أن هذا *لا* يعني أنه لا يمكن إعادة تعيين `myStr`. الطريقة الوحيدة لتغيير `myStr` هي تعيينه بمقطع جديدة، هكذا:
+
+```js
+let myStr = "Bob";
+myStr = "Job";
+```
+
+# --instructions--
+
+صحّ تعيين `myStr` بحيث يحتوي على قيمة المقطع `Hello World` باستخدام النهج الموضح في المثال أعلاه.
+
+# --hints--
+
+يجب أن يكون لدي `myStr` قيمة المقطع الآتي `Hello World`.
+
+```js
+assert(myStr === 'Hello World');
+```
+
+لا يجب عليك تعديل الكود فوق التعليق المحدد.
+
+```js
+assert(/myStr = "Jello World"/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return "myStr = " + v;})(myStr);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+let myStr = "Jello World";
+
+// Only change code below this line
+myStr[0] = "H"; // Change this line
+// Only change code above this line
+```
+
+# --solutions--
+
+```js
+let myStr = "Jello World";
+myStr = "Hello World";
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.md

@@ -0,0 +1,60 @@
+---
+id: bd7123c9c441eddfaeb5bdef
+title: فهم الحالات المنطقية (Understanding Boolean Values)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9Me8t4'
+forumTopicId: 301176
+dashedName: understanding-boolean-values
+---
+
+# --description--
+
+نوع آخر من البيانات هو <dfn>حالة المنطقية</dfn>. يمكن أن يكون للحالات المنطقية حالة واحدة فقط من حالتين: `true` أو `false`. إنها في الأساس كمفاتيح تشغيل صغيرة لإيقاف وبدء التشغيل، حيث إن `true` يبدأ التشغيل و `false` يوقفه. وهاتان الحالتان تستبعد إحداهما الأخرى.
+
+**ملاحظة:** القيم الحالة المنطقية لا تكتب أبدا باستخدام علامات الاقتباس. المقطعين `"true"` و `"false"` ليست حالتي منطقية وليس لها معنى خاص في JavaScript.
+
+# --instructions--
+
+عدّل الوظيفة `welcomeToBooleans` بحيث ترجع `true` بدلاً من `false` عند النقر على زر التشغيل.
+
+# --hints--
+
+يجب أن تقوم الوظيفة `welcomeToBooleans()` بإرجاع حالة منطقية (`true`, أو `false`).
+
+```js
+assert(typeof welcomeToBooleans() === 'boolean');
+```
+
+يجب أن يرجع `welcomeToBooleans()` حالة `true`.
+
+```js
+assert(welcomeToBooleans() === true);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+welcomeToBooleans();
+```
+
+## --seed-contents--
+
+```js
+function welcomeToBooleans() {
+  // Only change code below this line
+
+  return false; // Change this line
+
+  // Only change code above this line
+}
+```
+
+# --solutions--
+
+```js
+function welcomeToBooleans() {
+  return true; // Change this line
+}
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-case-sensitivity-in-variables.md

@@ -0,0 +1,100 @@
+---
+id: 56533eb9ac21ba0edf2244ab
+title: فهم حساسية الحالة الحروف في المتغيرات (Understanding Case Sensitivity in Variables)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cd6GDcD'
+forumTopicId: 18334
+dashedName: understanding-case-sensitivity-in-variables
+---
+
+# --description--
+
+في JavaScript جميع المتغيرات وأسماء الوظائف حساسة لحالة الأحرف أي case sensitive. هذا يعني أن الكتابة بالأحرف الكبيرة (capitalization) شيئ مؤثر.
+
+لا يكون `MYVAR` مثل `MyVar` أو `myvar`. من الممكن أن يكون لديك متغيرات مميزة متعددة بنفس الاسم ولكن بحالات مختلف. يوصى بشدة، من أجل الوضوح، *عدم* استخدام مِيزة اللغة هذه.
+
+**أفضل ممارسة**
+
+كتابة أسماء المتغيرات في JavaScript باستخدام <dfn>camelCase</dfn>. في <dfn>camelCase</dfn>، تحتوي أسماء المتغيرات المتعددة الكلمات على الكلمة الأولى بالأحرف الصغيرة ويتم كتابة الحرف الأول من كل كلمة لاحقة بحروف كبيرة.
+
+**على سبيل المثال:**
+
+```js
+var someVariable;
+var anotherVariableName;
+var thisVariableNameIsSoLong;
+```
+
+# --instructions--
+
+عدّل التعريفات والتخصيصات الحالية بحيث تستخدم أسماؤها <dfn>camelCase</dfn>.
+
+لا تنشئ أي متغيرات جديدة.
+
+# --hints--
+
+يجب أن يتم تعريف `studlyCapVar` وأن تكون قيمتها `10`.
+
+```js
+assert(typeof studlyCapVar !== 'undefined' && studlyCapVar === 10);
+```
+
+يجب أن يتم تعريف`properCamelCase` وأن تكون له قيمة `A String` بنوع مقطع.
+
+```js
+assert(
+  typeof properCamelCase !== 'undefined' && properCamelCase === 'A String'
+);
+```
+
+يجب أن يتم تعريف `titleCaseOver` وأن تكون قيمتها `9000`.
+
+```js
+assert(typeof titleCaseOver !== 'undefined' && titleCaseOver === 9000);
+```
+
+يجب أن يستخدم `studlyCapVar` حالة camelCase في كل من أقسام التعريف والتخصيص.
+
+```js
+assert(code.match(/studlyCapVar/g).length === 2);
+```
+
+يجب أن يستخدم `properCamelCase` حالة camelCase في كل من أقسام التعريف والتخصيص.
+
+```js
+assert(code.match(/properCamelCase/g).length === 2);
+```
+
+يجب أن يستخدم `titleCaseOver` حالة camelCase في كل من أقسام التعريف و التخصيص.
+
+```js
+assert(code.match(/titleCaseOver/g).length === 2);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Variable declarations
+var StUdLyCapVaR;
+var properCamelCase;
+var TitleCaseOver;
+
+// Variable assignments
+STUDLYCAPVAR = 10;
+PRoperCAmelCAse = "A String";
+tITLEcASEoVER = 9000;
+```
+
+# --solutions--
+
+```js
+var studlyCapVar;
+var properCamelCase;
+var titleCaseOver;
+
+studlyCapVar = 10;
+properCamelCase = "A String";
+titleCaseOver = 9000;
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.md

@@ -0,0 +1,96 @@
+---
+id: 598e8944f009e646fc236146
+title: فهم القيم غير المحددة المرتجعة من الوظيفة (Understanding Undefined Value returned from a Function)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ce2p7cL'
+forumTopicId: 301177
+dashedName: understanding-undefined-value-returned-from-a-function
+---
+
+# --description--
+
+يمكن أن يتضمن الوظيفة عبارة `return` ولكن ليس عليه أن يفعل ذلك. في حالة أن الوظيفة لا يحتوي على عبارة `return` عندما يتم استدعائه، تتم معالجة الكود الداخلي في الوظيفة ولكن القيمة التي يتم إرجاعها هي `undefined`.
+
+**مثال**
+
+```js
+let sum = 0;
+
+function addSum(num) {
+  sum = sum + num;
+}
+
+addSum(3);
+```
+
+تكون `addSum` وظيفة دون `return`. سيغير وظيفة المتغير `sum` العالمي الآتي, ولكن تكون القيمة المرتجعة للوظيفة `undefined`.
+
+# --instructions--
+
+أنشئ وظيفة `addFive` دون أي حجج. تضيف الوظيفة 5 إلى متغير `sum` ولكن تكون قيمته المرتجعة `undefined`.
+
+# --hints--
+
+يجب أن تكون `addFive` وظيفة.
+
+```js
+assert(typeof addFive === 'function');
+```
+
+بمجرد تشغيل كلتا الوظيفتين، يجب أن يكون `sum` يساوي `8`.
+
+```js
+assert(sum === 8);
+```
+
+يجب أن تنتج `addFive` القيمة المرتجعة `undefined`.
+
+```js
+assert(addFive() === undefined);
+```
+
+داخل وظيفة `addFive`، يجب عليك إضافة `5` إلى متغير `sum`.
+
+```js
+assert(
+  __helpers.removeWhiteSpace(addFive.toString()).match(/sum=sum\+5|sum\+=5/)
+);
+```
+
+# --seed--
+
+## --seed-contents--
+
+```js
+// Setup
+let sum = 0;
+
+function addThree() {
+  sum = sum + 3;
+}
+
+// Only change code below this line
+
+
+// Only change code above this line
+
+addThree();
+addFive();
+```
+
+# --solutions--
+
+```js
+let sum = 0;
+
+function addThree() {
+  sum = sum + 3;
+}
+
+function addFive() {
+  sum = sum + 5;
+}
+
+addThree();
+addFive();
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.md

@@ -0,0 +1,79 @@
+---
+id: 56533eb9ac21ba0edf2244aa
+title: فهم المتغيرات غير المهيأة (Understanding Uninitialized Variables)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/cBa2JAL'
+forumTopicId: 18335
+dashedName: understanding-uninitialized-variables
+---
+
+# --description--
+
+عند تعريف متغيرات JavaScript، يكون لها قيمة أولية وهي `undefined`. إذا قمت بعملية رياضية على متغير `undefined` ستكون نتيجتك `NaN` مما يعني <dfn>"Not a Number"</dfn> إي "ليس رقما". إذا ربط مقطع مع متغير `undefined`، فستحصل على <dfn>مقطع</dfn> بقيمة `undefined`.
+
+# --instructions--
+
+قم بتهيئة المتغيرات الثلاثة `a`, و `b`, و `c` بالقيم `5`, و `10`, و `"I am a"` على التوالي، حتى لا يكونوا `undefined`.
+
+# --hints--
+
+يجب أن يتم تعريف `a` وأن تكون قيمتها `6`.
+
+```js
+assert(typeof a === 'number' && a === 6);
+```
+
+يجب أن يتم تعريف `b` وأن تكون قيمتها `15`.
+
+```js
+assert(typeof b === 'number' && b === 15);
+```
+
+يجب ألّا يحتوي `c` على `undefined` ويجب أن يكون لديه مقطع بقيمة `I am a String!`
+
+```js
+assert(!/undefined/.test(c) && c === 'I am a String!');
+```
+
+لا يجب عليك تعديل الكود فوق التعليق المحدد.
+
+```js
+assert(
+  /a = a \+ 1;/.test(code) &&
+    /b = b \+ 5;/.test(code) &&
+    /c = c \+ " String!";/.test(code)
+);
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = '" + c + "'"; })(a,b,c);
+```
+
+## --seed-contents--
+
+```js
+// Only change code below this line
+var a;
+var b;
+var c;
+// Only change code above this line
+
+a = a + 1;
+b = b + 5;
+c = c + " String!";
+```
+
+# --solutions--
+
+```js
+var a = 5;
+var b = 10;
+var c = "I am a";
+a = a + 1;
+b = b + 5;
+c = c + " String!";
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/updating-object-properties.md

@@ -0,0 +1,78 @@
+---
+id: 56bbb991ad1ed5201cd392d1
+title: تحديث خصائص الكائن (Updating Object Properties)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/c9yEJT4'
+forumTopicId: 18336
+dashedName: updating-object-properties
+---
+
+# --description--
+
+بعد إنشاء كائن JavaScript، يمكنك تحديث خصائصه في أي وقت كما يمكنك تحديث أي متغير آخر. يمكنك استخدام أي من تدوين النِّقَاط أو تدوين الأقواس المعكوفان (dot or bracket notation).
+
+على سبيل المثال، دعونا ننظر إلى `ourDog`:
+
+```js
+const ourDog = {
+  "name": "Camper",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["everything!"]
+};
+```
+
+بما أنه كلب سعيد، دعونا نغير اسمه إلى مقطع `Happy Camper`. إليك كيف, تحدث الاسم: `ourDog.name = "Happy Camper";` أو `ourDog["name"] = "Happy Camper";`، الآن عندما نقيّم `ourDog.name`، بدلا من الحصول علي `Camper`، سوف نحصل علي اسمه الجديد `Happy Camper`.
+
+# --instructions--
+
+حدث خاصية اسم الكائن `myDog`. غيّر اسمه من `Coder` إلى `Happy Coder`. يمكنك استخدام أي من تدوين النِّقَاط أو تدوين الأقواس المعكوفان (dot or bracket notation).
+
+# --hints--
+
+يجب عليك تحديث خاصية `name` في `myDog` لتساوي مقطع `Happy Coder`.
+
+```js
+assert(/happy coder/gi.test(myDog.name));
+```
+
+لا يجب عليك تعديل تعريف `myDog`.
+
+```js
+assert(/"name": "Coder"/.test(code));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(z){return z;})(myDog);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+const myDog = {
+  "name": "Coder",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["freeCodeCamp Campers"]
+};
+
+// Only change code below this line
+
+```
+
+# --solutions--
+
+```js
+const myDog = {
+  "name": "Coder",
+  "legs": 4,
+  "tails": 1,
+  "friends": ["freeCodeCamp Campers"]
+};
+myDog.name = "Happy Coder";
+```

curriculum/challenges/arabic/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-first-character-in-a-string.md

@@ -0,0 +1,74 @@
+---
+id: bd7123c9c549eddfaeb5bdef
+title: استخدم رمز الاقواس للعثور على اول حرف في مقطع (Use Bracket Notation to Find the First Character in a String)
+challengeType: 1
+videoUrl: 'https://scrimba.com/c/ca8JwhW'
+forumTopicId: 18341
+dashedName: use-bracket-notation-to-find-the-first-character-in-a-string
+---
+
+# --description--
+
+<dfn>القوسان المعكوفان</dfn> هي طريقة للحصول على رمز في ترتيب معين داخل المقطع.
+
+معظم لغات البرمجة الحديثة، مثل JavaScript، لا تبدأ في العد من 1 كما يفعل البشر. إنهم يبدؤون عند الصفر. يشار إلى هذا بالترتيب <dfn>مبني على الصفر</dfn>.
+
+على سبيل المثال، رمز ترتيب 0 في كلمة `Charles` هو `C`. إذن إذا `const firstName = "Charles"`، يمكنك الحصول على قيمة الرمز الأول من المقطع باستخدام `firstName[0]`.
+
+مثال:
+
+```js
+const firstName = "Charles";
+const firstLetter = firstName[0];
+```
+
+سيكون إلى `firstLetter` قيمة تساوي المقطع `C`.
+
+# --instructions--
+
+استخدم رمز الأقواس للعثور على الرمز الأول في متغير `lastName` وتعيينه إلى `firstLetterOfLastName`.
+
+**تلميح:** حاول النظر إلى المثال أعلاه إذا كنت عالق.
+
+# --hints--
+
+يجب أن يحتوي متغير `firstLetterOfLastName` قيمة `L`.
+
+```js
+assert(firstLetterOfLastName === 'L');
+```
+
+يجب عليك استخدام رمز الأقواس المعكوفان.
+
+```js
+assert(code.match(/firstLetterOfLastName\s*=\s*lastName\s*\[\s*\d\s*\]/));
+```
+
+# --seed--
+
+## --after-user-code--
+
+```js
+(function(v){return v;})(firstLetterOfLastName);
+```
+
+## --seed-contents--
+
+```js
+// Setup
+let firstLetterOfLastName = "";
+const lastName = "Lovelace";
+
+// Only change code below this line
+firstLetterOfLastName = lastName; // Change this line
+```
+
+# --solutions--
+
+```js
+let firstLetterOfLastName = "";
+const lastName = "Lovelace";
+
+// Only change code below this line
+firstLetterOfLastName = lastName[0];
+```