From 9822843811fcafe6930749901759359126726b44 Mon Sep 17 00:00:00 2001
From: harshitalamba11 <lambaharshita1@gmail.com>
Date: Mon, 29 Dec 2025 00:15:54 +0530
Subject: [PATCH 1/4] Added Arrays in cn

---
 cn/arrays/README.md   | 69 +++++++++++++++++++++++++++++++++++++++++++
 cn/arrays/for-each.md | 45 ++++++++++++++++++++++++++++
 cn/arrays/indices.md  | 33 +++++++++++++++++++++
 cn/arrays/join.md     | 37 +++++++++++++++++++++++
 cn/arrays/length.md   | 40 +++++++++++++++++++++++++
 cn/arrays/map.md      | 44 +++++++++++++++++++++++++++
 cn/arrays/pop.md      | 35 ++++++++++++++++++++++
 cn/arrays/push.md     | 37 +++++++++++++++++++++++
 cn/arrays/reverse.md  | 37 +++++++++++++++++++++++
 cn/arrays/shift.md    | 33 +++++++++++++++++++++
 cn/arrays/slice.md    | 45 ++++++++++++++++++++++++++++
 cn/arrays/sort.md     | 46 +++++++++++++++++++++++++++++
 cn/arrays/spread.md   | 29 ++++++++++++++++++
 cn/arrays/unshift.md  | 26 ++++++++++++++++
 14 files changed, 556 insertions(+)
 create mode 100644 cn/arrays/README.md
 create mode 100644 cn/arrays/for-each.md
 create mode 100644 cn/arrays/indices.md
 create mode 100644 cn/arrays/join.md
 create mode 100644 cn/arrays/length.md
 create mode 100644 cn/arrays/map.md
 create mode 100644 cn/arrays/pop.md
 create mode 100644 cn/arrays/push.md
 create mode 100644 cn/arrays/reverse.md
 create mode 100644 cn/arrays/shift.md
 create mode 100644 cn/arrays/slice.md
 create mode 100644 cn/arrays/sort.md
 create mode 100644 cn/arrays/spread.md
 create mode 100644 cn/arrays/unshift.md

diff --git a/cn/arrays/README.md b/cn/arrays/README.md
new file mode 100644
index 00000000..931fcc23
--- /dev/null
+++ b/cn/arrays/README.md
@@ -0,0 +1,69 @@
+章节：6
+页码：47
+描述：数组是数据的列表，是编程中的基础部分。我们可以在数组中存储多种类型的数据。
+
+第6章
+数组（Arrays）
+
+数组是编程中的基础部分。数组是一种数据列表。我们可以在一个变量中存储大量数据，这使我们的代码更易读、更易理解，也更方便对相关数据进行操作。
+
+数组中的数据称为 元素。
+
+下面是一个简单的数组示例：
+
+// 1, 1, 2, 3, 5 和 8 是数组中的元素
+let numbers = [1, 1, 2, 3, 5, 8];
+
+
+数组可以使用数组字面量或 new 关键字轻松创建：
+
+const cars = ["Saab", "Volvo", "BMW"]; // 使用数组字面量
+const cars = new Array("Saab", "Volvo", "BMW"); // 使用 new 关键字
+
+
+可以通过索引访问数组的值。数组的第一个元素索引总是 0，因为数组索引从 0 开始。索引也可以用于修改数组元素：
+
+const cars = ["Saab", "Volvo", "BMW"];
+console.log(cars[0]); 
+// 结果: Saab
+
+cars[0] = "Opel"; // 修改数组的第一个元素
+console.log(cars);
+// 结果: ['Opel', 'Volvo', 'BMW']
+
+
+{% hint style="working" %}
+数组是一种特殊的对象类型。数组中也可以包含 对象
+。
+{% endhint %}
+
+数组的 length 属性返回元素的数量。数组支持的方法如下表所示：
+
+| 方法名称              | 描述                                                                             |
+| ----------------- | ------------------------------------------------------------------------------ |
+| `at()`            | 返回指定索引的元素或 `undefined`                                                         |
+| `concat()`        | 返回两个或多个数组的组合                                                                   |
+| `every()`         | 如果回调函数对数组中每个元素都返回 `true`，则返回 `true`                                            |
+| `filter()`        | 返回一个新数组，包含回调函数返回 `true` 的元素                                                    |
+| `find()`          | 返回第一个使回调函数返回 `true` 的元素                                                        |
+| `findIndex()`     | 返回第一个使回调函数返回 `true` 的元素索引                                                      |
+| `findLast()`      | 返回最后一个使回调函数返回 `true` 的元素                                                       |
+| `findLastIndex()` | 返回最后一个使回调函数返回 `true` 的元素索引                                                     |
+| `flat()`          | 返回一个新数组，将所有子数组元素递归展开到指定深度                                                      |
+| `flatMap()`       | 先运行 `map()`，再运行深度为 1 的 `flat()`                                                |
+| `forEach()`       | 对数组中的每个元素执行回调函数，返回 `undefined`                                                 |
+| `indexOf()`       | 返回搜索元素第一次出现的索引                                                                 |
+| `join()`          | 将数组中的所有元素连接成一个字符串                                                              |
+| `lastIndexOf()`   | 返回搜索元素最后一次出现的索引                                                                |
+| `map()`           | 执行回调函数后返回一个新数组                                                                 |
+| `pop()`           | 删除数组的最后一个元素并返回该元素                                                              |
+| `push()`          | 在数组末尾添加一个或多个元素，并返回数组的新长度                                                       |
+| `reduce()`        | 使用 `callback(accumulator, currentValue, currentIndex, array)` 对数组进行归约操作，返回最终结果 |
+| `reduceRight()`   | 与 `reduce()` 类似，但从数组末尾开始                                                       |
+| `reverse()`       | 原地翻转数组元素，并返回数组的引用                                                              |
+| `shift()`         | 删除数组的第一个元素并返回该元素                                                               |
+| `slice()`         | 提取数组的一部分并返回新数组                                                                 |
+| `some()`          | 如果回调函数对数组中至少一个元素返回 `true`，则返回 `true`                                           |
+| `sort()`          | 原地对数组元素进行排序，并返回数组的引用                                                           |
+| `splice()`        | 从数组中删除元素（可选择性替换），并返回删除的元素                                                      |
+| `unshift()`       | 在数组开头添加一个或多个元素，并返回数组的新长度                                                       |
diff --git a/cn/arrays/for-each.md b/cn/arrays/for-each.md
new file mode 100644
index 00000000..0adb688f
--- /dev/null
+++ b/cn/arrays/for-each.md
@@ -0,0 +1,45 @@
+章节：6
+页码：46
+描述：forEach 方法会对数组中的每一个数组元素执行一次所提供的函数。
+
+
+# 对每一个元素
+
+`forEach` 方法会对数组中的每一个元素执行一次所提供的函数。以下是使用 `forEach` 的语法：
+
+```javascript
+array.forEach(function(element, index, array) {
+  // element：当前正在处理的数组元素
+  // index：当前正在处理的数组元素的索引
+  // array：调用 forEach 方法的原数组
+});
+```
+
+例如，假设你有一个数字数组，并希望在控制台中输出每个数字的两倍，可以使用 `forEach` 如下所示：
+
+```typescript
+let 数字 = [1, 2, 3, 4, 5];
+数字.forEach(function(数值) {
+  console.log(数值 * 2);
+});
+```
+
+你也可以使用箭头函数语法来定义传递给 `forEach` 的函数：
+
+```typescript
+数字.forEach((数值) => {
+  console.log(数值 * 2);
+});
+```
+
+或者：
+
+```typescript
+数字.forEach(数值 => console.log(数值 * 2));
+```
+
+`forEach` 方法不会改变原始数组。它只是遍历数组中的元素，并对每一个元素执行所提供的函数。
+
+{% hint style="working" %}
+`forEach()` 方法不会对空数组执行回调函数。
+{% endhint %}
diff --git a/cn/arrays/indices.md b/cn/arrays/indices.md
new file mode 100644
index 00000000..d616ad46
--- /dev/null
+++ b/cn/arrays/indices.md
@@ -0,0 +1,33 @@
+章节：6
+页码：58
+描述：数组是元素的集合，每个元素都被分配了一个称为索引的数字位置。索引是从零开始的，这意味着数组的第一个元素索引为 0，第二个元素索引为 1，依此类推。
+
+# 索引
+
+现在你已经有了一个数据元素数组，那么如果你想访问其中的某一个特定元素，该怎么办呢？这正是**索引（index）**的作用。索引指的是数组中的一个位置。索引在逻辑上是依次递增的，但需要注意的是，在大多数编程语言中，数组的第一个索引都是 `0`。方括号 `[]` 用于表示你正在引用数组中的某个索引位置。
+
+```javascript
+// 这是一个字符串数组
+let fruits = ["apple", "banana", "pineapple", "strawberry"];
+
+// 我们将变量 banana 设置为 fruits 数组中第二个元素的值。
+// 请记住，索引从 0 开始，因此 1 表示第二个元素。
+// 结果：banana = "banana"
+let banana = fruits[1];
+```
+
+你也可以使用数组索引来设置或修改数组中某个元素的值：
+
+```javascript
+let array = ['a', 'b', 'c', 'd', 'e'];
+//  索引：     0    1    2    3    4
+array[4] = 'f';
+console.log(array); // 结果：['a', 'b', 'c', 'd', 'f']
+
+
+请注意，如果你尝试使用超出数组范围的索引来访问或设置元素（即索引小于 `0`，或大于等于数组的长度），将会得到 `undefined` 值。
+
+```javascript
+console.log(array[5]); // 输出：undefined
+array[5] = 'g';
+console.log(array); // 结果：['a', 'b', 'c', 'd', 'f', undefined, 'g']
diff --git a/cn/arrays/join.md b/cn/arrays/join.md
new file mode 100644
index 00000000..365e9456
--- /dev/null
+++ b/cn/arrays/join.md
@@ -0,0 +1,37 @@
+章节：6
+页码：53
+描述：join 方法会将数组转换为一个字符串，并把所有元素连接在一起，而不会修改原始数组。
+
+
+# 连接（Join）
+
+`join` 方法会将数组转换为一个字符串，并将所有元素连接在一起。它**不会改变原始数组**。以下是使用 `join` 的语法：
+
+```c
+array.join([separator]);
+```
+
+`separator` 参数是可选的，用于指定在结果字符串中分隔各个元素所使用的字符。如果省略该参数，数组元素将使用逗号（`,`）进行分隔。
+
+例如：
+
+```javascript
+let array = ["one", "two", "three", "four"]; 
+
+console.log(array.join(" ")); 
+
+// 结果：one two three four
+```
+
+{% hint style="working" %}
+可以指定任意分隔符，但默认分隔符是逗号 `(,)`。
+{% endhint %}
+
+在上述示例中，使用了空格作为分隔符。你还可以使用 `join` 将**类数组对象**（例如 `arguments` 对象或 `NodeList` 对象）转换为字符串，方法是先使用 `Array.prototype.slice()` 将其转换为真正的数组：
+
+```javascript
+function printArguments() {
+  console.log(Array.prototype.slice.call(arguments).join(', '));
+}
+
+printArguments('a', 'b', 'c'); // 结果："a, b, c"
diff --git a/cn/arrays/length.md b/cn/arrays/length.md
new file mode 100644
index 00000000..384220f3
--- /dev/null
+++ b/cn/arrays/length.md
@@ -0,0 +1,40 @@
+章节：6
+页码：54
+描述：数组有一个叫做 length 的属性，用来测量数组的长度。
+
+长度（Length）
+
+数组有一个属性叫做 length，它的意思非常直白，就是数组的长度。
+
+let array = [1, 2, 3];
+
+let l = array.length;
+
+// 结果: l = 3
+
+
+length 属性也可以用来设置数组的元素数量。例如：
+
+let fruits = ["香蕉", "橙子", "苹果", "芒果"];
+fruits.length = 2;
+
+console.log(fruits);
+// 结果: ['香蕉', '橙子']
+
+
+你还可以使用 length 属性来获取数组的最后一个元素。例如：
+
+console.log(fruits[fruits.length - 1]); // 结果: 橙子
+
+
+你也可以使用 length 属性向数组末尾添加元素。例如：
+
+fruits[fruits.length] = "菠萝";
+console.log(fruits); // 结果: ['香蕉', '橙子', '菠萝']
+
+
+{% hint style="info" %}
+当数组的元素被添加或删除时，length 属性会自动更新。
+{% endhint %}
+
+值得注意的是，length 属性不是一个方法，所以在访问它时不需要使用括号。它只是数组对象的一个属性，你可以像访问其他对象属性一样访问它。
\ No newline at end of file
diff --git a/cn/arrays/map.md b/cn/arrays/map.md
new file mode 100644
index 00000000..5e4bd3a0
--- /dev/null
+++ b/cn/arrays/map.md
@@ -0,0 +1,44 @@
+章节：6
+页码：49
+描述：map 方法遍历数组，并使用回调函数修改数组元素。这个回调函数会被应用到数组的每一个元素。
+
+Map
+
+Array.prototype.map() 方法会遍历数组，并使用回调函数修改数组的元素。回调函数会应用到数组的每个元素上。
+
+map 的语法如下：
+
+let newArray = oldArray.map(function(element, index, array) {
+  // element: 当前正在处理的数组元素
+  // index: 当前正在处理元素的索引
+  // array: 调用 map 的数组
+  // 返回值将被添加到 newArray 中
+});
+
+
+例如，假设你有一个数字数组，并且想创建一个新数组，其元素是原数组中每个数字的两倍。你可以使用 map 来实现，如下所示：
+
+const numbers = [2, 4, 6, 8];
+
+const doubledNumbers = numbers.map(number => number * 2);
+
+console.log(doubledNumbers);
+
+// 结果: [4, 8, 12, 16]
+
+
+你也可以使用箭头函数语法来定义传递给 map 的函数：
+
+let doubledNumbers = numbers.map((number) => {
+  return number * 2;
+});
+
+
+或者更简洁地写成：
+
+let doubledNumbers = numbers.map(number => number * 2);
+
+
+{% hint style="info" %}
+map() 方法不会对空元素执行函数，并且不会改变原数组。
+{% endhint %}
\ No newline at end of file
diff --git a/cn/arrays/pop.md b/cn/arrays/pop.md
new file mode 100644
index 00000000..228d7c89
--- /dev/null
+++ b/cn/arrays/pop.md
@@ -0,0 +1,35 @@
+章节：6
+页码：52
+描述：pop 方法移除数组的最后一个元素，并返回该元素。此方法会改变数组的长度。
+
+Pop
+
+pop 方法会移除数组的最后一个元素，并返回该元素。此方法会改变数组的长度。
+
+pop 的语法如下：
+
+array.pop();
+
+
+例如：
+
+let arr = ["一", "二", "三", "四", "五"]; 
+arr.pop(); 
+
+console.log(arr); 
+
+// 结果: ['一', '二', '三', '四']
+
+
+你也可以结合循环使用 pop 方法来移除数组中的所有元素。示例：
+
+while (array.length > 0) {
+  array.pop();
+}
+
+console.log(array); // 结果: []
+
+
+{% hint style="working" %}
+pop 方法只适用于数组，而不适用于类似数组的对象，例如 arguments 对象或 NodeList 对象。如果你需要从这些类型的对象中移除元素，需要先使用 Array.prototype.slice() 方法将它们转换为数组。
+{% endhint %}
\ No newline at end of file
diff --git a/cn/arrays/push.md b/cn/arrays/push.md
new file mode 100644
index 00000000..f91c96d5
--- /dev/null
+++ b/cn/arrays/push.md
@@ -0,0 +1,37 @@
+章节：6
+页码：55
+描述：push 方法向数组添加元素，使最后一个索引成为新添加的元素。此方法会改变数组长度，并返回新的长度。
+
+Push
+
+可以向数组末尾添加元素，使最后一个索引成为新添加的元素。它会改变数组的长度，并返回新的长度。
+
+push 的语法如下：
+
+array.push(element1[, ...[, elementN]]);
+
+
+其中 element1, ..., elementN 参数表示要添加到数组末尾的元素。
+
+例如：
+
+let array = [1, 2, 3]; 
+array.push(4); 
+
+console.log(array); 
+
+// 结果: array = [1, 2, 3, 4]
+
+
+你也可以将 push 用于类数组对象（例如 arguments 对象或 NodeList 对象），但需要先使用 Array.prototype.slice() 方法将其转换为数组：
+
+function printArguments() {
+  let args = Array.prototype.slice.call(arguments);
+  args.push('d', 'e', 'f');
+  console.log(args);
+}
+
+printArguments('a', 'b', 'c'); // 结果: ["a", "b", "c", "d", "e", "f"]
+
+
+注意：push 方法会修改原数组，并不会创建新的数组。
\ No newline at end of file
diff --git a/cn/arrays/reverse.md b/cn/arrays/reverse.md
new file mode 100644
index 00000000..3fce9afb
--- /dev/null
+++ b/cn/arrays/reverse.md
@@ -0,0 +1,37 @@
+章节：6
+页码：59
+描述：要在数组开头添加元素，可以使用 reverse 方法。它会修改原数组，并返回数组的新长度。
+
+Reverse
+
+reverse 方法可以用于任何类型的数组，包括字符串数组、数字数组以及对象数组。例如：
+
+let users = [{
+  name: "约翰·史密斯",
+  age: 30
+}, {
+  name: "简·多",
+  age: 25
+}];
+
+users.reverse();
+
+console.log(users);
+
+// 结果: 
+[{
+  name: "简·多",
+  age: 25
+}, {
+  name: "约翰·史密斯",
+  age: 30
+}];
+
+
+reverse 方法会原地调换调用数组对象的元素，修改原数组，并返回对数组的引用。
+
+以下是 reverse 用于数组的示例：
+
+const numbers = [1, 2, 3];
+const newLength = numbers.reverse();
+console.log(numbers); // [3, 2, 1]
\ No newline at end of file
diff --git a/cn/arrays/shift.md b/cn/arrays/shift.md
new file mode 100644
index 00000000..95956b3a
--- /dev/null
+++ b/cn/arrays/shift.md
@@ -0,0 +1,33 @@
+章节：6
+页码：51
+描述：shift 方法删除数组的第一个元素，并将所有索引左移。它会修改原数组。
+
+Shift
+
+shift 方法会删除数组的第一个元素，并将所有元素的索引左移。它会改变原数组。
+
+shift 的语法如下：
+
+array.shift();
+
+
+例如：
+
+let array = [1, 2, 3]; 
+array.shift(); 
+
+// 结果: array = [2, 3]
+
+
+你也可以结合循环使用 shift 方法来移除数组中的所有元素。示例：
+
+while (array.length > 0) {
+  array.shift();
+}
+
+console.log(array); // 结果: []
+
+
+{% hint style="working" %}
+shift 方法只适用于数组，而不适用于类似数组的对象，例如 arguments 对象或 NodeList 对象。如果你需要从这些类型的对象中移除元素，需要先使用 Array.prototype.slice() 方法将其转换为数组。
+{% endhint %}
\ No newline at end of file
diff --git a/cn/arrays/slice.md b/cn/arrays/slice.md
new file mode 100644
index 00000000..78af24cb
--- /dev/null
+++ b/cn/arrays/slice.md
@@ -0,0 +1,45 @@
+章节：6
+页码：60
+描述：JavaScript 的 arr.slice() 方法返回一个包含原数组部分元素的新数组，原数组保持不变。
+
+Slice
+
+slice 方法接受两个参数：begin 和 end。
+
+begin：定义要提取的起始索引。如果省略该参数，默认从索引 0 开始。
+
+end：定义要提取的结束索引（不包括该索引）。如果省略该参数，默认提取到数组末尾。如果 end 大于数组长度，则 end 自动取数组长度。
+
+function func() {
+  // 原数组
+  let arr = [23, 56, 87, 32, 75, 13];
+  // 提取的新数组
+  let new_arr = arr.slice();
+  console.log(arr);
+  console.log(new_arr);
+}
+func();
+
+// 结果: 
+[23, 56, 87, 32, 75, 13]
+[23, 56, 87, 32, 75, 13]
+
+
+slice() 方法会将对象的引用复制到新数组（例如嵌套数组或对象）。因此，如果引用对象被修改，这些修改会在返回的新数组中可见。
+
+let human = {
+  name: "David",
+  age: 23,
+};
+
+let arr = [human, "Nepal", "Manager"];
+let new_arr = arr.slice();
+
+// 原始对象
+console.log(arr[0]); // { name: 'David', age: 23 }
+
+// 修改新数组中的对象
+new_arr[0].name = "Levy";
+
+// 修改在原数组中也可见
+console.log(arr[0]); // { name: 'Levy', age: 23 }
\ No newline at end of file
diff --git a/cn/arrays/sort.md b/cn/arrays/sort.md
new file mode 100644
index 00000000..246f1c63
--- /dev/null
+++ b/cn/arrays/sort.md
@@ -0,0 +1,46 @@
+章节：6
+页码：57
+描述：sort 方法按特定顺序对数组的元素进行排序。默认情况下，它会将元素作为字符串排序，并根据 UTF-16 编码值升序排列。
+
+Sort
+
+sort 方法可以按特定顺序（升序或降序）对数组元素进行排序。默认情况下，sort 方法会将元素作为字符串排序，并根据 UTF-16 编码值升序排列。
+
+sort 的语法如下：
+
+array.sort([compareFunction]);
+
+
+compareFunction 参数是可选的，用于定义排序顺序的函数。如果省略，元素将按字符串表示的升序排列。
+
+例如：
+
+let city = ["California", "Barcelona", "Paris", "Kathmandu"];
+let sortedCity = city.sort(); 
+
+console.log(sortedCity);
+
+// 结果: ['Barcelona', 'California', 'Kathmandu', 'Paris']
+
+
+{% hint style="info" %}
+数字排序时可能会出现错误。例如，"35" 会被认为比 "100" 大，因为字符串比较按字符顺序比较，"3" 大于 "1"。
+{% endhint %}
+
+为了解决数字排序问题，可以使用比较函数。比较函数根据参数返回 负值、零 或 正值 来定义排序顺序：
+
+返回负值：表示 a 应该排在 b 前面
+
+返回正值：表示 a 应该排在 b 后面
+
+返回 0：表示 a 和 b 相等，顺序无关紧要
+
+const points = [40, 100, 1, 5, 25, 10];
+points.sort((a, b) => a - b);
+
+// 结果: [1, 5, 10, 25, 40, 100]
+
+
+{% hint style="working" %}
+sort() 方法会覆盖原数组。
+{% endhint %}
\ No newline at end of file
diff --git a/cn/arrays/spread.md b/cn/arrays/spread.md
new file mode 100644
index 00000000..565dd5cf
--- /dev/null
+++ b/cn/arrays/spread.md
@@ -0,0 +1,29 @@
+章节：6
+页码：50
+描述：Spread 操作符允许快速操作数组或对象。它提供了简洁的语法来复制、合并或提取数组元素，以及复制对象属性。
+
+Spread
+
+可以使用 Spread 操作符 (...) 将一个数组或对象快速复制到另一个数组或对象中。它允许在函数调用或数组字面量中展开可迭代对象（如数组），或在对象字面量中展开键值对。
+
+示例：
+
+let arr = [1, 2, 3, 4, 5]; 
+
+console.log(...arr); 
+// 结果: 1 2 3 4 5
+
+let arr1;
+arr1 = [...arr]; // 将 arr 复制到 arr1 
+
+console.log(arr1); // 结果: [1, 2, 3, 4, 5]
+
+arr1 = [6, 7];
+arr = [...arr, ...arr1];
+
+console.log(arr); // 结果: [1, 2, 3, 4, 5, 6, 7]
+
+
+{% hint style="working" %}
+Spread 操作符仅在支持该特性的现代浏览器中有效。如果需要兼容旧浏览器，需要使用 Babel 等转译器将 Spread 语法转换为等效的 ES5 代码。
+{% endhint %}
\ No newline at end of file
diff --git a/cn/arrays/unshift.md b/cn/arrays/unshift.md
new file mode 100644
index 00000000..972b7f6a
--- /dev/null
+++ b/cn/arrays/unshift.md
@@ -0,0 +1,26 @@
+章节：6
+页码：48
+描述：要在数组开头添加元素，可以使用 unshift 方法。它会修改原数组，并返回数组的新长度。
+
+Unshift
+
+unshift 方法会将一个或多个新元素依次添加到数组的开头。它会修改原数组，并返回数组的新长度。例如：
+
+let array = [0, 5, 10];
+array.unshift(-5);  // 返回 4
+
+// 结果: array = [-5, 0, 5, 10]
+
+
+{% hint style="working" %}
+unshift() 方法会覆盖原数组。
+{% endhint %}
+
+unshift 方法可以接受一个或多个参数，这些参数表示要添加到数组开头的元素。它会按照参数顺序添加元素，因此第一个参数会成为数组的第一个元素。
+
+示例，向数组添加多个元素：
+
+const numbers = [1, 2, 3];
+const newLength = numbers.unshift(-1, 0);
+console.log(numbers);    // [-1, 0, 1, 2, 3]
+console.log(newLength);  // 5
\ No newline at end of file

From 54438fb8da1e8731812376df7ed7d564a94cda86 Mon Sep 17 00:00:00 2001
From: harshitalamba11 <lambaharshita1@gmail.com>
Date: Mon, 29 Dec 2025 01:17:34 +0530
Subject: [PATCH 2/4] resolved issued 01

---
 cn/arrays/reverse.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cn/arrays/reverse.md b/cn/arrays/reverse.md
index 3fce9afb..858b872d 100644
--- a/cn/arrays/reverse.md
+++ b/cn/arrays/reverse.md
@@ -33,5 +33,5 @@ reverse 方法会原地调换调用数组对象的元素，修改原数组，并
 以下是 reverse 用于数组的示例：
 
 const numbers = [1, 2, 3];
-const newLength = numbers.reverse();
-console.log(numbers); // [3, 2, 1]
\ No newline at end of file
+const reversedArray = numbers.reverse();
+console.log(reversedArray); // [3, 2, 1]
\ No newline at end of file

From 40a8fdd20f52798c4b2e84d3cd9141b765f978df Mon Sep 17 00:00:00 2001
From: harshitalamba11 <lambaharshita1@gmail.com>
Date: Mon, 29 Dec 2025 01:41:13 +0530
Subject: [PATCH 3/4] Resolved all issued

---
 cn/arrays/for-each.md |  6 +++---
 cn/arrays/indices.md  |  5 +++--
 cn/arrays/join.md     |  5 +++--
 cn/arrays/reverse.md  | 15 +++++++++------
 4 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/cn/arrays/for-each.md b/cn/arrays/for-each.md
index 0adb688f..183a06a5 100644
--- a/cn/arrays/for-each.md
+++ b/cn/arrays/for-each.md
@@ -17,7 +17,7 @@ array.forEach(function(element, index, array) {
 
 例如，假设你有一个数字数组，并希望在控制台中输出每个数字的两倍，可以使用 `forEach` 如下所示：
 
-```typescript
+```javascript
 let 数字 = [1, 2, 3, 4, 5];
 数字.forEach(function(数值) {
   console.log(数值 * 2);
@@ -26,7 +26,7 @@ let 数字 = [1, 2, 3, 4, 5];
 
 你也可以使用箭头函数语法来定义传递给 `forEach` 的函数：
 
-```typescript
+```javascript
 数字.forEach((数值) => {
   console.log(数值 * 2);
 });
@@ -34,7 +34,7 @@ let 数字 = [1, 2, 3, 4, 5];
 
 或者：
 
-```typescript
+```javascript
 数字.forEach(数值 => console.log(数值 * 2));
 ```
 
diff --git a/cn/arrays/indices.md b/cn/arrays/indices.md
index d616ad46..eab14e1b 100644
--- a/cn/arrays/indices.md
+++ b/cn/arrays/indices.md
@@ -23,11 +23,12 @@ let array = ['a', 'b', 'c', 'd', 'e'];
 //  索引：     0    1    2    3    4
 array[4] = 'f';
 console.log(array); // 结果：['a', 'b', 'c', 'd', 'f']
-
+```
 
 请注意，如果你尝试使用超出数组范围的索引来访问或设置元素（即索引小于 `0`，或大于等于数组的长度），将会得到 `undefined` 值。
 
 ```javascript
 console.log(array[5]); // 输出：undefined
 array[5] = 'g';
-console.log(array); // 结果：['a', 'b', 'c', 'd', 'f', undefined, 'g']
+console.log(array); // 结果：['a', 'b', 'c', 'd', 'f', 'g']
+```
\ No newline at end of file
diff --git a/cn/arrays/join.md b/cn/arrays/join.md
index 365e9456..292621b2 100644
--- a/cn/arrays/join.md
+++ b/cn/arrays/join.md
@@ -7,7 +7,7 @@
 
 `join` 方法会将数组转换为一个字符串，并将所有元素连接在一起。它**不会改变原始数组**。以下是使用 `join` 的语法：
 
-```c
+```javascript
 array.join([separator]);
 ```
 
@@ -34,4 +34,5 @@ function printArguments() {
   console.log(Array.prototype.slice.call(arguments).join(', '));
 }
 
-printArguments('a', 'b', 'c'); // 结果："a, b, c"
+printArguments('a', 'b', 'c'); // 结果：a, b, c
+```
\ No newline at end of file
diff --git a/cn/arrays/reverse.md b/cn/arrays/reverse.md
index 858b872d..8869f733 100644
--- a/cn/arrays/reverse.md
+++ b/cn/arrays/reverse.md
@@ -1,11 +1,12 @@
 章节：6
 页码：59
-描述：要在数组开头添加元素，可以使用 reverse 方法。它会修改原数组，并返回数组的新长度。
+描述：reverse 方法用于反转数组中元素的顺序。它会修改原数组，并返回对该数组的引用。
 
 Reverse
 
-reverse 方法可以用于任何类型的数组，包括字符串数组、数字数组以及对象数组。例如：
+reverse 方法可以用于任何类型的数组，包括字符串数组、数字数组以及对象数组。该方法会原地反转数组，也就是说，它会直接修改原数组。
 
+```javascript
 let users = [{
   name: "约翰·史密斯",
   age: 30
@@ -18,7 +19,7 @@ users.reverse();
 
 console.log(users);
 
-// 结果: 
+// 结果:
 [{
   name: "简·多",
   age: 25
@@ -26,12 +27,14 @@ console.log(users);
   name: "约翰·史密斯",
   age: 30
 }];
-
+```
 
 reverse 方法会原地调换调用数组对象的元素，修改原数组，并返回对数组的引用。
 
-以下是 reverse 用于数组的示例：
+以下是 reverse 用于数字数组的示例：
 
+```javascript
 const numbers = [1, 2, 3];
 const reversedArray = numbers.reverse();
-console.log(reversedArray); // [3, 2, 1]
\ No newline at end of file
+console.log(reversedArray); // [3, 2, 1]
+```
\ No newline at end of file

From 2612ce2d09313f5a7e11de9e6db3fadde1e7bac7 Mon Sep 17 00:00:00 2001
From: harshitalamba11 <lambaharshita1@gmail.com>
Date: Mon, 29 Dec 2025 16:35:32 +0530
Subject: [PATCH 4/4] Formatted the files

---
 cn/arrays/README.md  | 49 +++++++++++++++++++++++++++++++-------
 cn/arrays/length.md  | 44 +++++++++++++++++++---------------
 cn/arrays/map.md     | 56 ++++++++++++++++++++++++--------------------
 cn/arrays/pop.md     | 44 ++++++++++++++++++++--------------
 cn/arrays/push.md    | 51 ++++++++++++++++++++++++++--------------
 cn/arrays/reverse.md | 44 ++++++++++++++++------------------
 cn/arrays/shift.md   | 40 ++++++++++++++++++++-----------
 cn/arrays/slice.md   | 42 +++++++++++++++++++++++----------
 cn/arrays/sort.md    | 47 +++++++++++++++++++++----------------
 cn/arrays/spread.md  | 32 +++++++++++++++----------
 cn/arrays/unshift.md | 50 ++++++++++++++++++++++++++-------------
 11 files changed, 309 insertions(+), 190 deletions(-)

diff --git a/cn/arrays/README.md b/cn/arrays/README.md
index 931fcc23..b5782a9b 100644
--- a/cn/arrays/README.md
+++ b/cn/arrays/README.md
@@ -1,28 +1,34 @@
+---
 章节：6
 页码：47
 描述：数组是数据的列表，是编程中的基础部分。我们可以在数组中存储多种类型的数据。
+---
 
-第6章
-数组（Arrays）
+# 第6章
+# 数组（Arrays）
 
 数组是编程中的基础部分。数组是一种数据列表。我们可以在一个变量中存储大量数据，这使我们的代码更易读、更易理解，也更方便对相关数据进行操作。
 
-数组中的数据称为 元素。
+数组中的数据称为 `元素`。
 
 下面是一个简单的数组示例：
 
+```javascript
 // 1, 1, 2, 3, 5 和 8 是数组中的元素
 let numbers = [1, 1, 2, 3, 5, 8];
+```
 
+数组可以使用数组字面量或 `new` 关键字轻松创建：
 
-数组可以使用数组字面量或 new 关键字轻松创建：
-
+```javascript
 const cars = ["Saab", "Volvo", "BMW"]; // 使用数组字面量
 const cars = new Array("Saab", "Volvo", "BMW"); // 使用 new 关键字
+```
 
+可以通过索引访问数组的值。数组的第一个元素索引总是 `0`，因为数组索引从 `0` 开始。
+索引也可以用于修改数组元素：
 
-可以通过索引访问数组的值。数组的第一个元素索引总是 0，因为数组索引从 0 开始。索引也可以用于修改数组元素：
-
+```javascript
 const cars = ["Saab", "Volvo", "BMW"];
 console.log(cars[0]); 
 // 结果: Saab
@@ -30,40 +36,65 @@ console.log(cars[0]);
 cars[0] = "Opel"; // 修改数组的第一个元素
 console.log(cars);
 // 结果: ['Opel', 'Volvo', 'BMW']
-
+```
 
 {% hint style="working" %}
 数组是一种特殊的对象类型。数组中也可以包含 对象
 。
 {% endhint %}
 
-数组的 length 属性返回元素的数量。数组支持的方法如下表所示：
+数组的 `length` 属性返回元素的数量。数组支持的方法如下表所示：
 
 | 方法名称              | 描述                                                                             |
 | ----------------- | ------------------------------------------------------------------------------ |
 | `at()`            | 返回指定索引的元素或 `undefined`                                                         |
+
 | `concat()`        | 返回两个或多个数组的组合                                                                   |
+
 | `every()`         | 如果回调函数对数组中每个元素都返回 `true`，则返回 `true`                                            |
+
 | `filter()`        | 返回一个新数组，包含回调函数返回 `true` 的元素                                                    |
+
 | `find()`          | 返回第一个使回调函数返回 `true` 的元素                                                        |
+
 | `findIndex()`     | 返回第一个使回调函数返回 `true` 的元素索引                                                      |
+
 | `findLast()`      | 返回最后一个使回调函数返回 `true` 的元素                                                       |
+
 | `findLastIndex()` | 返回最后一个使回调函数返回 `true` 的元素索引                                                     |
+
 | `flat()`          | 返回一个新数组，将所有子数组元素递归展开到指定深度                                                      |
+
 | `flatMap()`       | 先运行 `map()`，再运行深度为 1 的 `flat()`                                                |
+
 | `forEach()`       | 对数组中的每个元素执行回调函数，返回 `undefined`                                                 |
+
 | `indexOf()`       | 返回搜索元素第一次出现的索引                                                                 |
+
 | `join()`          | 将数组中的所有元素连接成一个字符串                                                              |
+
 | `lastIndexOf()`   | 返回搜索元素最后一次出现的索引                                                                |
+
 | `map()`           | 执行回调函数后返回一个新数组                                                                 |
+
 | `pop()`           | 删除数组的最后一个元素并返回该元素                                                              |
+
 | `push()`          | 在数组末尾添加一个或多个元素，并返回数组的新长度                                                       |
+
 | `reduce()`        | 使用 `callback(accumulator, currentValue, currentIndex, array)` 对数组进行归约操作，返回最终结果 |
+
 | `reduceRight()`   | 与 `reduce()` 类似，但从数组末尾开始                                                       |
+
 | `reverse()`       | 原地翻转数组元素，并返回数组的引用                                                              |
+
 | `shift()`         | 删除数组的第一个元素并返回该元素                                                               |
+
 | `slice()`         | 提取数组的一部分并返回新数组                                                                 |
+
 | `some()`          | 如果回调函数对数组中至少一个元素返回 `true`，则返回 `true`                                           |
+
 | `sort()`          | 原地对数组元素进行排序，并返回数组的引用                                                           |
+
 | `splice()`        | 从数组中删除元素（可选择性替换），并返回删除的元素                                                      |
+
 | `unshift()`       | 在数组开头添加一个或多个元素，并返回数组的新长度                                                       |
diff --git a/cn/arrays/length.md b/cn/arrays/length.md
index 384220f3..1f345704 100644
--- a/cn/arrays/length.md
+++ b/cn/arrays/length.md
@@ -1,40 +1,46 @@
-章节：6
-页码：54
-描述：数组有一个叫做 length 的属性，用来测量数组的长度。
+---
+章节: 6
+页码: 44
+描述: 数组有一个名为 length 的属性，用于测量数组的长度（元素数量）。
+---
 
-长度（Length）
+# 长度（Length）
 
-数组有一个属性叫做 length，它的意思非常直白，就是数组的长度。
+数组有一个名为 `length` 的属性，它的含义正如其名——表示数组的长度。
 
+```javascript
 let array = [1, 2, 3];
 
 let l = array.length;
 
-// 结果: l = 3
+// 结果：l = 3
+```
 
+length 属性也可以用来设置数组中元素的数量。例如：
 
-length 属性也可以用来设置数组的元素数量。例如：
-
-let fruits = ["香蕉", "橙子", "苹果", "芒果"];
+```javascript
+let fruits = ["Banana", "Orange", "Apple", "Mango"];
 fruits.length = 2;
 
 console.log(fruits);
-// 结果: ['香蕉', '橙子']
-
+// 结果：['Banana', 'Orange']
+```
 
-你还可以使用 length 属性来获取数组的最后一个元素。例如：
-
-console.log(fruits[fruits.length - 1]); // 结果: 橙子
+你还可以将 length 作为索引来获取数组中的最后一个元素。例如：
 
+```javascript
+console.log(fruits[fruits.length - 1]); // 结果：Orange
+```
 
 你也可以使用 length 属性向数组末尾添加元素。例如：
 
-fruits[fruits.length] = "菠萝";
-console.log(fruits); // 结果: ['香蕉', '橙子', '菠萝']
-
+```javascript
+fruits[fruits.length] = "Pineapple";
+console.log(fruits); // 结果：['Banana', 'Orange', 'Pineapple']
+```
 
 {% hint style="info" %}
-当数组的元素被添加或删除时，length 属性会自动更新。
+当数组中的元素被添加或删除时，`length` 属性会自动更新。
 {% endhint %}
 
-值得注意的是，length 属性不是一个方法，所以在访问它时不需要使用括号。它只是数组对象的一个属性，你可以像访问其他对象属性一样访问它。
\ No newline at end of file
+还需要注意的是，`length` 是一个属性，而不是方法，因此在访问它时不需要使用括号。它只是数组对象的一个属性，你可以像访问其他对象属性一样访问它。
\ No newline at end of file
diff --git a/cn/arrays/map.md b/cn/arrays/map.md
index 5e4bd3a0..9d75742c 100644
--- a/cn/arrays/map.md
+++ b/cn/arrays/map.md
@@ -1,44 +1,48 @@
-章节：6
-页码：49
-描述：map 方法遍历数组，并使用回调函数修改数组元素。这个回调函数会被应用到数组的每一个元素。
-
-Map
-
-Array.prototype.map() 方法会遍历数组，并使用回调函数修改数组的元素。回调函数会应用到数组的每个元素上。
-
-map 的语法如下：
-
-let newArray = oldArray.map(function(element, index, array) {
-  // element: 当前正在处理的数组元素
-  // index: 当前正在处理元素的索引
-  // array: 调用 map 的数组
-  // 返回值将被添加到 newArray 中
+---
+章节: 6
+页码: 49
+描述: map 方法会遍历数组，并使用回调函数处理数组中的每一个元素，从而生成一个新的数组。
+---
+
+# Map
+
+`Array.prototype.map()` 方法会遍历数组，并对数组中的每一个元素执行一次回调函数。
+回调函数的返回值会组成一个新的数组，而原数组不会被修改。
+
+```javascript
+let newArray = oldArray.map(function (element, index, array) {
+  // element：当前正在处理的数组元素
+  // index：当前元素的索引
+  // array：调用 map 方法的原数组
+  // return 的值会被添加到 newArray 中
 });
+```
 
+例如，假设你有一个数字数组，并希望创建一个新数组，使其元素是原数组中每个数字的两倍：
 
-例如，假设你有一个数字数组，并且想创建一个新数组，其元素是原数组中每个数字的两倍。你可以使用 map 来实现，如下所示：
-
+```javascript
 const numbers = [2, 4, 6, 8];
 
 const doubledNumbers = numbers.map(number => number * 2);
 
 console.log(doubledNumbers);
+// 结果：[4, 8, 12, 16]
+```
 
-// 结果: [4, 8, 12, 16]
+你也可以使用完整的箭头函数写法：
 
-
-你也可以使用箭头函数语法来定义传递给 map 的函数：
-
-let doubledNumbers = numbers.map((number) => {
+```javascript
+const doubledNumbers = numbers.map((number) => {
   return number * 2;
 });
-
+```
 
 或者更简洁地写成：
 
-let doubledNumbers = numbers.map(number => number * 2);
-
+```javascript
+const doubledNumbers = numbers.map(number => number * 2);
+```
 
 {% hint style="info" %}
-map() 方法不会对空元素执行函数，并且不会改变原数组。
+`map()` 方法不会对空元素执行回调函数，并且不会改变原数组，它始终返回一个新数组。
 {% endhint %}
\ No newline at end of file
diff --git a/cn/arrays/pop.md b/cn/arrays/pop.md
index 228d7c89..f0723431 100644
--- a/cn/arrays/pop.md
+++ b/cn/arrays/pop.md
@@ -1,35 +1,43 @@
-章节：6
-页码：52
-描述：pop 方法移除数组的最后一个元素，并返回该元素。此方法会改变数组的长度。
+---
+章节: 6
+页码: 52
+描述: pop 方法会移除数组的最后一个元素，并返回该元素。该方法会改变数组的长度。
+---
 
-Pop
+# Pop
 
-pop 方法会移除数组的最后一个元素，并返回该元素。此方法会改变数组的长度。
-
-pop 的语法如下：
+`pop()` 方法会移除数组的最后一个元素，并返回该元素。  
+此方法会**直接修改原数组**，并改变数组的长度。
 
+`语法`:
+```javascript
 array.pop();
+```
 
+`示例`:
+```javascript
+let arr = ["一", "二", "三", "四", "五"];
 
-例如：
-
-let arr = ["一", "二", "三", "四", "五"]; 
-arr.pop(); 
+arr.pop();
 
-console.log(arr); 
+console.log(arr);
+// 结果：['一', '二', '三', '四']
+```
 
-// 结果: ['一', '二', '三', '四']
+你也可以结合循环使用 `pop()` 方法来移除数组中的所有元素：
 
-
-你也可以结合循环使用 pop 方法来移除数组中的所有元素。示例：
+```javascript
+let array = ["a", "b", "c"];
 
 while (array.length > 0) {
   array.pop();
 }
 
-console.log(array); // 结果: []
-
+console.log(array);
+// 结果：[]
+```
 
 {% hint style="working" %}
-pop 方法只适用于数组，而不适用于类似数组的对象，例如 arguments 对象或 NodeList 对象。如果你需要从这些类型的对象中移除元素，需要先使用 Array.prototype.slice() 方法将它们转换为数组。
+`pop()` 方法只适用于数组，而不适用于类数组对象（如 arguments 或 NodeList）。
+如果需要操作这些对象，可以先使用 `Array.prototype.slice()` 将它们转换为真正的数组。
 {% endhint %}
\ No newline at end of file
diff --git a/cn/arrays/push.md b/cn/arrays/push.md
index f91c96d5..09421b2f 100644
--- a/cn/arrays/push.md
+++ b/cn/arrays/push.md
@@ -1,37 +1,52 @@
-章节：6
-页码：55
-描述：push 方法向数组添加元素，使最后一个索引成为新添加的元素。此方法会改变数组长度，并返回新的长度。
+---
+章节: 6
+页码: 55
+描述: push 方法用于向数组末尾添加一个或多个元素，并返回数组的新长度。
+---
 
-Push
+# Push
 
-可以向数组末尾添加元素，使最后一个索引成为新添加的元素。它会改变数组的长度，并返回新的长度。
-
-push 的语法如下：
+`push()` 方法用于向数组的**末尾**添加一个或多个元素。
+该方法会**修改原数组**，并返回数组的**新长度**。
 
+## 语法`
+```javascript
 array.push(element1[, ...[, elementN]]);
+```
 
+其中 element1, ..., elementN 表示要添加到数组末尾的一个或多个元素。
 
-其中 element1, ..., elementN 参数表示要添加到数组末尾的元素。
-
-例如：
+## 示例
+```javascript
+let array = [1, 2, 3];
 
-let array = [1, 2, 3]; 
-array.push(4); 
+array.push(4);
 
-console.log(array); 
+console.log(array);
+// 结果：[1, 2, 3, 4]
+```
 
-// 结果: array = [1, 2, 3, 4]
+你也可以一次性向数组中添加多个元素：
 
+```javascript
+array.push(5, 6);
+console.log(array);
+// 结果：[1, 2, 3, 4, 5, 6]
+```
 
-你也可以将 push 用于类数组对象（例如 arguments 对象或 NodeList 对象），但需要先使用 Array.prototype.slice() 方法将其转换为数组：
+你也可以将 `push()` 用于类数组对象（如 arguments），但需要先将其转换为真正的数组：
 
+```javascript
 function printArguments() {
   let args = Array.prototype.slice.call(arguments);
   args.push('d', 'e', 'f');
   console.log(args);
 }
 
-printArguments('a', 'b', 'c'); // 结果: ["a", "b", "c", "d", "e", "f"]
-
+printArguments('a', 'b', 'c');
+// 结果：["a", "b", "c", "d", "e", "f"]
+```
 
-注意：push 方法会修改原数组，并不会创建新的数组。
\ No newline at end of file
+{% hint style="info" %}
+`push()` 方法会修改原数组，而不会创建一个新的数组。
+{% endhint %}
\ No newline at end of file
diff --git a/cn/arrays/reverse.md b/cn/arrays/reverse.md
index 8869f733..b53225d9 100644
--- a/cn/arrays/reverse.md
+++ b/cn/arrays/reverse.md
@@ -1,38 +1,34 @@
-章节：6
-页码：59
-描述：reverse 方法用于反转数组中元素的顺序。它会修改原数组，并返回对该数组的引用。
+---
+章节: 6
+页码: 59
+描述: reverse 方法用于反转数组中元素的顺序。它会修改原数组，并返回对该数组的引用。
+---
 
-Reverse
+# Reverse
 
-reverse 方法可以用于任何类型的数组，包括字符串数组、数字数组以及对象数组。该方法会原地反转数组，也就是说，它会直接修改原数组。
+`reverse()` 方法可以用于任何类型的数组，包括字符串数组、数字数组以及对象数组。  
+该方法会**原地反转数组**，也就是说，它会直接修改原数组。
+
+## 示例：对象数组
 
 ```javascript
-let users = [{
-  name: "约翰·史密斯",
-  age: 30
-}, {
-  name: "简·多",
-  age: 25
-}];
+let users = [
+  { name: "约翰·史密斯", age: 30 },
+  { name: "简·多", age: 25 }
+];
 
 users.reverse();
 
 console.log(users);
-
-// 结果:
-[{
-  name: "简·多",
-  age: 25
-}, {
-  name: "约翰·史密斯",
-  age: 30
-}];
+// 结果: [
+//   { name: "简·多", age: 25 },
+//   { name: "约翰·史密斯", age: 30 }
+// ]
 ```
 
-reverse 方法会原地调换调用数组对象的元素，修改原数组，并返回对数组的引用。
-
-以下是 reverse 用于数字数组的示例：
+`reverse()` 方法会原地调换调用数组对象的元素，修改原数组，并返回对数组的引用。
 
+示例：数字数组
 ```javascript
 const numbers = [1, 2, 3];
 const reversedArray = numbers.reverse();
diff --git a/cn/arrays/shift.md b/cn/arrays/shift.md
index 95956b3a..718cdf86 100644
--- a/cn/arrays/shift.md
+++ b/cn/arrays/shift.md
@@ -1,33 +1,45 @@
-章节：6
-页码：51
-描述：shift 方法删除数组的第一个元素，并将所有索引左移。它会修改原数组。
+---
+章节: 6
+页码: 51
+描述: shift 方法用于删除数组的第一个元素，并将剩余元素的索引依次左移。它会修改原数组。
+---
 
-Shift
+# Shift
 
-shift 方法会删除数组的第一个元素，并将所有元素的索引左移。它会改变原数组。
+`shift()` 方法会删除数组的**第一个元素**，并将所有元素的索引左移。  
+此方法会**直接修改原数组**，并返回被删除的元素。
 
-shift 的语法如下：
+## 语法
 
+```javascript
 array.shift();
+```
 
+示例:
 
-例如：
+```javascript
+let array = [1, 2, 3];
 
-let array = [1, 2, 3]; 
-array.shift(); 
+array.shift();
 
-// 结果: array = [2, 3]
+console.log(array);
+// 结果：[2, 3]
+```
 
+你也可以结合循环使用 `shift()` 方法来移除数组中的所有元素：
 
-你也可以结合循环使用 shift 方法来移除数组中的所有元素。示例：
+```javascript
+let array = [1, 2, 3];
 
 while (array.length > 0) {
   array.shift();
 }
 
-console.log(array); // 结果: []
-
+console.log(array);
+// 结果：[]
+```
 
 {% hint style="working" %}
-shift 方法只适用于数组，而不适用于类似数组的对象，例如 arguments 对象或 NodeList 对象。如果你需要从这些类型的对象中移除元素，需要先使用 Array.prototype.slice() 方法将其转换为数组。
+`shift()` 方法只适用于数组，而不适用于类数组对象（如 arguments 或 NodeList）。
+如果需要操作这些对象，可以先使用 `Array.prototype.slice()` 将它们转换为真正的数组。
 {% endhint %}
\ No newline at end of file
diff --git a/cn/arrays/slice.md b/cn/arrays/slice.md
index 78af24cb..c7aae2aa 100644
--- a/cn/arrays/slice.md
+++ b/cn/arrays/slice.md
@@ -1,32 +1,47 @@
-章节：6
-页码：60
-描述：JavaScript 的 arr.slice() 方法返回一个包含原数组部分元素的新数组，原数组保持不变。
+---
+章节: 6
+页码: 60
+描述: JavaScript 的 `arr.slice()` 方法返回一个包含原数组部分元素的新数组，原数组保持不变。
+---
 
-Slice
+# Slice
 
-slice 方法接受两个参数：begin 和 end。
+`slice()` 方法用于从数组中提取一部分元素，并返回一个新的数组，原数组不会被修改。
 
-begin：定义要提取的起始索引。如果省略该参数，默认从索引 0 开始。
+## 语法
 
-end：定义要提取的结束索引（不包括该索引）。如果省略该参数，默认提取到数组末尾。如果 end 大于数组长度，则 end 自动取数组长度。
+```javascript
+arr.slice([begin[, end]])
+```
 
+`begin`：定义要提取的起始索引。如果省略，默认从索引 0 开始。
+
+`end`：定义要提取的结束索引（不包括该索引）。如果省略，默认提取到数组末尾。如果 `end` 大于数组长度，则自动取数组长度。
+
+## 示例 1：复制整个数组
+```javascript
 function func() {
   // 原数组
   let arr = [23, 56, 87, 32, 75, 13];
+
   // 提取的新数组
   let new_arr = arr.slice();
+
   console.log(arr);
   console.log(new_arr);
 }
-func();
 
-// 结果: 
-[23, 56, 87, 32, 75, 13]
-[23, 56, 87, 32, 75, 13]
+func();
+// 结果:
+// [23, 56, 87, 32, 75, 13]
+// [23, 56, 87, 32, 75, 13]
+```
 
+## 示例 2：引用对象
 
-slice() 方法会将对象的引用复制到新数组（例如嵌套数组或对象）。因此，如果引用对象被修改，这些修改会在返回的新数组中可见。
+`slice()` 方法会复制对象引用到新数组（例如嵌套数组或对象）。如果修改引用对象，这些修改会在新数组中可见。
 
+```javascript
 let human = {
   name: "David",
   age: 23,
@@ -42,4 +57,5 @@ console.log(arr[0]); // { name: 'David', age: 23 }
 new_arr[0].name = "Levy";
 
 // 修改在原数组中也可见
-console.log(arr[0]); // { name: 'Levy', age: 23 }
\ No newline at end of file
+console.log(arr[0]); // { name: 'Levy', age: 23 }
+```
\ No newline at end of file
diff --git a/cn/arrays/sort.md b/cn/arrays/sort.md
index 246f1c63..a59d2dbb 100644
--- a/cn/arrays/sort.md
+++ b/cn/arrays/sort.md
@@ -1,46 +1,53 @@
-章节：6
-页码：57
-描述：sort 方法按特定顺序对数组的元素进行排序。默认情况下，它会将元素作为字符串排序，并根据 UTF-16 编码值升序排列。
+---
+章节: 6
+页码: 57
+描述: `sort()` 方法按特定顺序对数组元素进行排序。默认情况下，它会将元素作为字符串进行升序排序。
+---
 
-Sort
+# Sort
 
-sort 方法可以按特定顺序（升序或降序）对数组元素进行排序。默认情况下，sort 方法会将元素作为字符串排序，并根据 UTF-16 编码值升序排列。
+`sort()` 方法可以按特定顺序（升序或降序）对数组元素进行排序。  
+默认情况下，`sort()` 会将元素作为字符串排序，并根据 UTF-16 编码值进行升序排列。
 
-sort 的语法如下：
+## 语法
 
-array.sort([compareFunction]);
+```javascript
+array.sort([compareFunction])
+```
 
+`compareFunction（可选）` ：用于定义排序顺序的函数。如果省略，元素将按字符串表示的升序排列。
 
-compareFunction 参数是可选的，用于定义排序顺序的函数。如果省略，元素将按字符串表示的升序排列。
-
-例如：
+## 示例 1：按字符串排序
 
+```javascript
 let city = ["California", "Barcelona", "Paris", "Kathmandu"];
-let sortedCity = city.sort(); 
+let sortedCity = city.sort();
 
 console.log(sortedCity);
-
 // 结果: ['Barcelona', 'California', 'Kathmandu', 'Paris']
-
+```
 
 {% hint style="info" %}
-数字排序时可能会出现错误。例如，"35" 会被认为比 "100" 大，因为字符串比较按字符顺序比较，"3" 大于 "1"。
+数字排序时可能会出现问题。例如，字符串 "35" 会被认为比 "100" 大，因为默认字符串比较按字符顺序进行，"3" 大于 "1"。
 {% endhint %}
 
-为了解决数字排序问题，可以使用比较函数。比较函数根据参数返回 负值、零 或 正值 来定义排序顺序：
+## 示例 2：使用比较函数进行数字排序
+为了解决数字排序问题，可以提供一个比较函数。比较函数返回负值、零或正值来定义排序顺序：
 
-返回负值：表示 a 应该排在 b 前面
+返回负值：`a` 排在 `b` 前面
 
-返回正值：表示 a 应该排在 b 后面
+返回正值：`a` 排在 `b` 后面
 
-返回 0：表示 a 和 b 相等，顺序无关紧要
+返回 0：`a` 和 `b` 相等，顺序不重要
 
+```javascript
 const points = [40, 100, 1, 5, 25, 10];
 points.sort((a, b) => a - b);
 
+console.log(points);
 // 结果: [1, 5, 10, 25, 40, 100]
-
+```
 
 {% hint style="working" %}
-sort() 方法会覆盖原数组。
+`sort()` 方法会修改原数组。
 {% endhint %}
\ No newline at end of file
diff --git a/cn/arrays/spread.md b/cn/arrays/spread.md
index 565dd5cf..a25a7191 100644
--- a/cn/arrays/spread.md
+++ b/cn/arrays/spread.md
@@ -1,29 +1,35 @@
-章节：6
-页码：50
-描述：Spread 操作符允许快速操作数组或对象。它提供了简洁的语法来复制、合并或提取数组元素，以及复制对象属性。
+---
+章节: 6
+页码: 50
+描述: Spread 操作符允许快速操作数组或对象。它提供了简洁的语法来复制、合并或提取数组元素，以及复制对象属性。
+---
 
-Spread
+# Spread
 
-可以使用 Spread 操作符 (...) 将一个数组或对象快速复制到另一个数组或对象中。它允许在函数调用或数组字面量中展开可迭代对象（如数组），或在对象字面量中展开键值对。
+可以使用 `Spread` 操作符 (`...`) 将一个数组或对象快速复制到另一个数组或对象中。
+它允许在函数调用或数组字面量中展开可迭代对象（如数组），或在对象字面量中展开键值对。
 
-示例：
+## 示例
 
-let arr = [1, 2, 3, 4, 5]; 
+```javascript
+let arr = [1, 2, 3, 4, 5];
 
-console.log(...arr); 
+console.log(...arr);
 // 结果: 1 2 3 4 5
 
 let arr1;
-arr1 = [...arr]; // 将 arr 复制到 arr1 
+arr1 = [...arr]; // 将 arr 复制到 arr1
 
-console.log(arr1); // 结果: [1, 2, 3, 4, 5]
+console.log(arr1); 
+// 结果: [1, 2, 3, 4, 5]
 
 arr1 = [6, 7];
 arr = [...arr, ...arr1];
 
-console.log(arr); // 结果: [1, 2, 3, 4, 5, 6, 7]
-
+console.log(arr); 
+// 结果: [1, 2, 3, 4, 5, 6, 7]
+```
 
 {% hint style="working" %}
-Spread 操作符仅在支持该特性的现代浏览器中有效。如果需要兼容旧浏览器，需要使用 Babel 等转译器将 Spread 语法转换为等效的 ES5 代码。
+`Spread` 操作符仅在支持该特性的现代浏览器中有效。如果需要兼容旧浏览器，需要使用 Babel 等转译器将 `Spread` 语法转换为等效的 ES5 代码。
 {% endhint %}
\ No newline at end of file
diff --git a/cn/arrays/unshift.md b/cn/arrays/unshift.md
index 972b7f6a..09ab7e7f 100644
--- a/cn/arrays/unshift.md
+++ b/cn/arrays/unshift.md
@@ -1,26 +1,44 @@
-章节：6
-页码：48
-描述：要在数组开头添加元素，可以使用 unshift 方法。它会修改原数组，并返回数组的新长度。
+---
+章节: 6
+页码: 48
+描述: unshift 方法可以向数组开头添加一个或多个元素，并返回数组的新长度。
+---
 
-Unshift
+# Unshift
 
-unshift 方法会将一个或多个新元素依次添加到数组的开头。它会修改原数组，并返回数组的新长度。例如：
+`unshift()` 方法会将一个或多个新元素添加到数组的**开头**。  
+它会**修改原数组**，并返回数组的**新长度**。
 
-let array = [0, 5, 10];
-array.unshift(-5);  // 返回 4
-
-// 结果: array = [-5, 0, 5, 10]
+## 语法
 
+```javascript
+array.unshift(element1[, element2[, ...[, elementN]]])
+```
 
-{% hint style="working" %}
-unshift() 方法会覆盖原数组。
-{% endhint %}
+`element1, ..., elementN` 表示要添加到数组开头的一个或多个元素。
 
-unshift 方法可以接受一个或多个参数，这些参数表示要添加到数组开头的元素。它会按照参数顺序添加元素，因此第一个参数会成为数组的第一个元素。
+## 示例 1：向数组开头添加单个元素
+```javascript
+let array = [0, 5, 10];
+let newLength = array.unshift(-5);  // 返回 4
 
-示例，向数组添加多个元素：
+console.log(array);
+// 结果: [-5, 0, 5, 10]
+console.log(newLength); 
+// 结果: 4
+```
 
+## 示例 2：向数组开头添加多个元素
+```javascript
 const numbers = [1, 2, 3];
 const newLength = numbers.unshift(-1, 0);
-console.log(numbers);    // [-1, 0, 1, 2, 3]
-console.log(newLength);  // 5
\ No newline at end of file
+
+console.log(numbers);    
+// 结果: [-1, 0, 1, 2, 3]
+console.log(newLength);  
+// 结果: 5
+```
+
+{% hint style="working" %}
+`unshift()` 方法会修改原数组，不会创建新数组。
+{% endhint %}
\ No newline at end of file