chore: sync content to repo (#10064)

Co-authored-by: nilbuild <4921183+nilbuild@users.noreply.github.com>

Author: github-actions[bot]

src/data/roadmaps/javascript/content/@RonBj1htt6jnBt3W7zoTA.md

@@ -1,11 +1,7 @@
-# Value Comparison Operators
-
-In javascript, the `==` operator does the type conversion of the operands before comparison, whereas the `===` operator compares the values and the data types of the operands. The `Object.is()` method determines whether two values are the same value: `Object.is(value1, value2)`.
-
-`Object.is()` is not equivalent to the `==` operator. The `==` operator applies various coercions to both sides (if they are not the same type) before testing for equality (resulting in such behavior as `"" == false` being `true`), but `Object.is()` doesn't coerce either value.
-
-`Object.is()` is also not equivalent to the `===` operator. The only difference between `Object.is()` and `===` is in their treatment of signed zeros and `NaN` values. The `===` operator (and the `==` operator) treats the number values `-0` and `+0` as equal but treats `NaN` as not equal to each other.
+# ==
+ 
+The `==` operator compares two values for equality after performing type coercion if the types differ. For example, `"5" == 5` returns `true` because the string is converted to a number before comparison. This can produce surprising results and is generally avoided in favor of `===`.
 
 Visit the following resources to learn more:
 
-- [@article@Equality comparisons and sameness - MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness#same-value_equality_using_object.is)
+- [@article@Equality comparisons and sameness - MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness#same-value_equality_using_object.is)

src/data/roadmaps/javascript/content/@lJwcc6JoUIQoiQ6FkV2KW.md

@@ -1,19 +1,7 @@
-# Strict Equality Operator (===)
+# ===
+ 
+The `===` operator compares two values for equality without type coercion. Both the value and the type must match for the comparison to return `true`. It is the recommended equality operator for most cases because it produces predictable results.
 
-In JavaScript, the strict equality operator `===` compares both the value and the type of two operands. This means that it will only return true if both the value and the type are identical.
+Visit the following resources to learn more:
 
-```sh
-"5" === "5"   // true
-```
-
-In this case, both the value and the type are the same, so the result is true.
-
-```sh
-"5" === 5   // false
-```
-
-Here, although the values might appear similar, the types are different (string and number), so the result is false. The strict equality operator does not perform type coercion; both the value and the type must be identical.
-
-Learn more from the following resources:
-
-- [@article@Strict equality - MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)
+- [@article@Strict equality - MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality)

src/data/roadmaps/javascript/content/all-about-variables@kvActjpU4FUJdrmuFoFEe.md

@@ -1,9 +1,8 @@
-# Javascript Variables
-
-Most of the time, a JavaScript application needs to work with information. To store and represent this information in the JavaScript codebase, we use variables. A variable is a container for a value.
+# All about Variables
+ 
+Variables are named containers for storing data values in a program. In JavaScript, variables are declared using `var`, `let`, or `const`, each with different scoping and reassignment rules. Choosing the right declaration keyword affects how the variable behaves throughout the code.
 
 Visit the following resources to learn more:
 
 - [@article@JavaScript Variables](https://javascript.info/variables)
-- [@article@Storing the information you need — Variables](https://developer.mozilla.org/en-US/docs/Learn/JavaScript/First_steps/Variables)
-- [@feed@Explore top posts about JavaScript](https://app.daily.dev/tags/javascript?ref=roadmapsh)
+- [@article@Storing the information you need — Variables](https://developer.mozilla.org/en-US/docs/Learn/JavaScript/First_steps/Variables)

src/data/roadmaps/javascript/content/apply@-BtF34cEzI6J8sZCDRlRE.md

@@ -4,4 +4,4 @@ The apply() method of Function instances calls this function with a given this v
 
 Visit the following resources to learn more:
 
-- [@article@apply() - MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply)
+- [@article@apply() - MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply)

src/data/roadmaps/javascript/content/arguments-object@QLC7bW-qHskLH2HOA-Sko.md

@@ -4,4 +4,4 @@ The arguments object is an Array-like object accessible inside functions that co
 
 Visit the following resources to learn more:
 
-- [@article@The arguments object - MDN Docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments)
+- [@article@The arguments object - MDN Docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments)

src/data/roadmaps/javascript/content/arithmetic-operators@0PK1NwlgkNe2Vf-We4uLH.md

@@ -1,19 +1,8 @@
-# Arithmetic operators
-
-The Arithmetic operators perform addition, subtraction, multiplication, division, exponentiation, and remainder operations.
-
-Arithmetic operators in JavaScript are as follows:
-
-- `+` (Addition)
-- `-` (Subtraction)
-- `*` (Multiplication)
-- `**` (Exponentiation)
-- `/` (Division)
-- `%` (Modulus i.e. Remainder)
-- `++` (Increment)
-- `--` (Decrement)
+# Arithmetic Operators
+ 
+Arithmetic operators perform mathematical operations on numbers. They include `+` (addition), `-` (subtraction), `*` (multiplication), `/` (division), `%` (remainder), and `**` (exponentiation). The `+` operator is also used for string concatenation, which can cause issues when operands are mixed types.
 
 Visit the following resources to learn more:
 
 - [@article@Arithmetic Operators - MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators#arithmetic_operators)
-- [@article@Arithmetic Operators - JavaScript.info](https://javascript.info/operators#maths)
+- [@article@Arithmetic Operators - JavaScript.info](https://javascript.info/operators#maths)

src/data/roadmaps/javascript/content/arrays@NZedBxG9B9TRVOf2QE2yL.md

@@ -1,9 +1,9 @@
 # Arrays
-
-Arrays are objects that store a collection of items and can be assigned to a variable. They have their methods that can perform operations on the array.
+ 
+Arrays are ordered, indexed collections that can hold values of any type. JavaScript arrays are dynamic, meaning they can grow and shrink, and provide a rich set of built-in methods like `map()`, `filter()`, `reduce()`, `push()`, and `pop()`. They are one of the most used data structures in JavaScript.
 
 Visit the following resources to learn more:
 
 - [@article@Working with Arrays in JavaScript](https://javascript.info/array)
 - [@article@JavaScript Arrays](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
-- [@video@JavaScript Arrays](https://www.youtube.com/watch?v=oigfaZ5ApsM)
+- [@video@JavaScript Arrays](https://www.youtube.com/watch?v=oigfaZ5ApsM)

src/data/roadmaps/javascript/content/arrow-functions@fr0NChxMXLpJizyMhXcXS.md

@@ -1,15 +1,7 @@
 # Arrow Functions
-
-Arrow Function is a new way of creating functions with the '=>' operator with a shorter syntax.
-
-## Example
-
-```js
-const sayHello = () => {
-    console.log(`Hello from Arrow Function !`);
-}
-```
+ 
+Arrow functions are a concise syntax for writing function expressions introduced in ES6. They use `=>` instead of the `function` keyword and do not have their own `this`, `arguments`, or `super` bindings. They are commonly used for callbacks and short expressions, but are not suitable as object methods or constructors.
 
 Visit the following resources to learn more:
 
-- [@article@MDN - Arrow Function Expressions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions)
+- [@article@MDN - Arrow Function Expressions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions)

src/data/roadmaps/javascript/content/assignment-operators@IvBtUzIGnkgGXrJjqmjf4.md

@@ -5,4 +5,4 @@ An assignment operator assigns a value to its left operand based on the value of
 Visit the following resources to learn more:
 
 - [@article@Assignment Operators](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#assignment_operators)
-- [@article@Basic Operators](https://javascript.info/operators#assignment)
+- [@article@Basic Operators](https://javascript.info/operators#assignment)

src/data/roadmaps/javascript/content/asyncawait@Dn872mgexmxoLtbkIgIgz.md

@@ -1,10 +1,9 @@
 # Async/Await
 
-`async/await` is a special syntax to work with promises in a more comfortable fashion.
-We use `async` keyword to declare a async function that return a Promise, and the `await` keyword makes a function wait for a Promise.
+`async/await` is a special syntax to work with promises in a more comfortable fashion. We use `async` keyword to declare a async function that return a Promise, and the `await` keyword makes a function wait for a Promise.
 
 Visit the following resources to learn more:
 
 - [@article@Async/await](https://javascript.info/async-await)
 - [@article@async function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function)
-- [@article@JavaScript Promises - Chaining](https://www.codeguage.com/courses/advanced-js/promises-chaining)
+- [@article@JavaScript Promises - Chaining](https://www.codeguage.com/courses/advanced-js/promises-chaining)