diff --git a/04-JavaScript基础/04-基本数据类型：String 和 Boolean.md b/04-JavaScript基础/04-基本数据类型：String 和 Boolean.md
index 66c6511..ac418ab 100644
--- a/04-JavaScript基础/04-基本数据类型：String 和 Boolean.md
+++ b/04-JavaScript基础/04-基本数据类型：String 和 Boolean.md
@@ -164,6 +164,23 @@ console.log(str6);
千古壹号[object Object]
```
+
+## 字符串的不可变性
+
+字符串里面的值不可被改变。虽然看上去可以改变内容，但其实是地址变了，内存中新开辟了一个内存空间。
+
+代码举例：
+
+```js
+var str = 'hello';
+
+str = 'qianguyihao';
+```
+
+比如上面的代码，当重新给变量 str 赋值时，常量`hello`不会被修改，依然保存在内存中；str 会改为指向`qianguyihao`。
+
+
+
## 模板字面量（模板字符串）
ES6中引入了**模板字面量**，让我们省去了字符串拼接的烦恼。
diff --git a/04-JavaScript基础/15-内置对象：Date.md b/04-JavaScript基础/15-内置对象：Date.md
index 4751c84..220c4da 100644
--- a/04-JavaScript基础/15-内置对象：Date.md
+++ b/04-JavaScript基础/15-内置对象：Date.md
@@ -405,7 +405,9 @@ console.log(Date.now()); // 打印结果举例：1589448165370
## Moment.js
-Moment.js是一个轻量级的JavaScript时间库，我们可以利用它很方便地进行时间操作，提升开发效率。
+Moment.js 是一个轻量级的JavaScript时间库，我们可以利用它很方便地进行时间操作，提升开发效率。
+
+- 中文官网：
使用举例：
@@ -438,7 +440,7 @@ Moment.js是一个轻量级的JavaScript时间库，我们可以利用它很方
## 我的公众号
-想学习**代码之外的技能**？不妨关注我的微信公众号：**千古壹号**（id：`qianguyihao`）。
+想学习**代码之外的技能**？不妨关注我的微信公众号：**千古壹号**。
扫一扫，你将发现另一个全新的世界，而这将是一场美丽的意外：
diff --git a/04-JavaScript基础/16-字符串的深入学习.md b/04-JavaScript基础/16-字符串的深入学习.md
deleted file mode 100644
index 37e5e09..0000000
--- a/04-JavaScript基础/16-字符串的深入学习.md
+++ /dev/null
@@ -1,16 +0,0 @@
-
-## 字符串的不可变性
-
-字符串里面的值不可被改变。虽然看上去可以改变内容，但其实是地址变了，内存中新开辟了一个内存空间。
-
-代码举例：
-
-```js
-var str = 'hello';
-
-str = 'qianguyihao';
-```
-
-比如上面的代码，当重新给变量 str 赋值时，常量`hello`不会被修改，依然保存在内存中；str 会改为指向`qianguyihao`。
-
-
diff --git a/04-JavaScript基础/16-数组简介.md b/04-JavaScript基础/16-数组简介.md
new file mode 100644
index 0000000..9f28930
--- /dev/null
+++ b/04-JavaScript基础/16-数组简介.md
@@ -0,0 +1,274 @@
+> 之前学习的数据类型，只能存储一个值（字符串也为一个值）。如果我们想存储多个值，就可以使用数组。
+
+## 数组简介
+
+数组（Array）是属于**内置对象**，我们可以在[MDN](https://developer.mozilla.org/zh-CN/)网站上查询各种方法。
+
+数组和普通对象的功能类似，也是用来存储一些值的。不同的是：
+
+- 普通对象是使用字符串作为属性名的，而数组是使用数字作为**索引**来操作元素。索引：从 0 开始的整数就是索引。
+
+数组的存储性能比普通对象要好。在实际开发中我们经常使用数组来存储一些数据（尤其是**列表数据**），使用频率非常高。
+
+
+
+比如说，上面这个页面的列表数据，它的结构就是一个大数组。
+
+数组中的元素可以是任意的数据类型，也可以是对象，也可以是函数，也可以是数组。数组的元素中，如果存放的是数组，我们就称这种数组为二维数组。
+
+接下来，我们讲一讲数组的基本操作。
+
+## 创建数组对象
+
+### 方式一：使用字面量创建数组
+
+举例：
+
+```javascript
+var arr1 = []; // 创建一个空的数组
+
+var arr2 = [1, 2, 3]; // 创建带初始值的数组
+```
+
+方式一最简单，也用得最多。
+
+### 方式二：使用构造函数创建数组
+
+语法：
+
+```
+let arr = new Array(参数);
+
+let arr = Array(参数);
+```
+
+如果**参数为空**，则表示创建一个空数组；如果参数是**一个数值**时，表示数组的长度；如果有多个参数时，表示数组中的元素。
+
+来举个例子：
+
+```javascript
+// 方式一
+var arr1 = [11, 12, 13];
+
+// 方式二
+var arr2 = new Array(); // 参数为空
+var arr3 = new Array(4); // 参数为一个数值
+var arr4 = new Array(15, 16, 17); // 参数为多个数值
+
+console.log(typeof arr1); // 打印结果：object
+
+console.log('arr1 = ' + JSON.stringify(arr1));
+console.log('arr2 = ' + JSON.stringify(arr2));
+console.log('arr3 = ' + JSON.stringify(arr3));
+console.log('arr4 = ' + JSON.stringify(arr4));
+```
+
+打印结果：
+
+```javascript
+object;
+
+arr1 = [11, 12, 13];
+arr2 = [];
+arr3 = [null, null, null, null];
+arr4 = [15, 16, 17];
+```
+
+从上方打印结果的第一行里，可以看出，数组的类型其实也是属于**对象**。
+
+### 数组中的元素的类型
+
+数组中可以存放**任意类型**的数据，例如字符串、数字、布尔值、对象等。
+
+比如：
+
+```javascript
+const arr = ['qianguyihao', 28, true, { name: 'qianguyihao' }];
+```
+
+我们甚至还可以存放**多维数组**（数组里面放数组）。比如：
+
+```js
+const arr2 = [
+ [11, 12, 13],
+ [21, 22, 23],
+];
+```
+
+## 数组的基本操作
+
+### 数组的索引
+
+**索引** (下标) ：用来访问数组元素的序号，代表的是数组中的元素在数组中的位置（下标从 0 开始算起）。
+
+数组可以通过索引来访问、设置、修改对应的数组元素。我们继续看看。
+
+### 向数组中添加元素
+
+语法：
+
+```javascript
+数组[索引] = 值;
+```
+
+代码举例：
+
+```javascript
+var arr = [];
+
+// 向数组中添加元素
+arr[0] = 10;
+arr[1] = 20;
+arr[2] = 30;
+arr[3] = 40;
+arr[5] = 50;
+
+console.log(JSON.stringify(arr));
+```
+
+打印结果：
+
+```
+[10,20,30,40,null,50]
+```
+
+### 获取数组中的元素
+
+语法：
+
+```javascript
+数组[索引];
+```
+
+如果读取不存在的索引（比如元素没那么多），系统不会报错，而是返回 undefined。
+
+代码举例：
+
+```javascript
+var arr = [21, 22, 23];
+
+console.log(arr[0]); // 打印结果：21
+console.log(arr[5]); // 打印结果：undefined
+```
+
+### 获取数组的长度
+
+可以使用`length`属性来获取数组的长度(即“元素的个数”)。
+
+数组的长度是元素个数，不要跟索引号混淆。
+
+语法：
+
+```javascript
+数组的长度 = 数组名.length；
+```
+
+代码举例：
+
+```javascript
+var arr = [21, 22, 23];
+
+console.log(arr.length); // 打印结果：3
+```
+
+补充：
+
+对于连续的数组，使用 length 可以获取到数组的长度（元素的个数）；对于非连续的数组，使用 length 会获取到数组的最大的索引+1。因此，尽量不要创建非连续的数组。
+
+### 修改数组的长度（修改 length）
+
+- 如果修改的 length 大于原长度，则多出部分会空出来，置为 null。
+
+- 如果修改的 length 小于原长度，则多出的元素会被删除，数组将从后面删除元素。
+
+- （特例：伪数组 arguments 的长度可以修改，但是不能修改里面的元素，后面单独讲。）
+
+代码举例：
+
+```javascript
+var arr1 = [11, 12, 13];
+var arr2 = [21, 22, 23];
+
+// 修改数组 arr1 的 length
+arr1.length = 1;
+console.log(JSON.stringify(arr1));
+
+// 修改数组 arr2 的 length
+arr2.length = 5;
+console.log(JSON.stringify(arr2));
+```
+
+打印结果：
+
+```javascript
+[11][(21, 22, 23, null, null)];
+```
+
+### 遍历数组
+
+**遍历**: 就是把数组中的每个元素从头到尾都访问一次。
+
+最简单的做法是通过 for 循环，遍历数组中的每一项。举例：
+
+```javascript
+var arr = [10, 20, 30, 40, 50];
+
+for (var i = 0; i < arr.length; i++) {
+ console.log(arr[i]); // 打印出数组中的每一项
+}
+```
+
+下一篇文章，会学习数组的各种方法，到时候，会有更多的做法去遍历数组。
+
+## 案例
+
+### 例 1：翻转数组
+
+代码实现：
+
+```javascript
+var arr = [10, 20, 30, 40, 50]; // 原始数组
+var newArr = []; // 翻转后的数组
+for (var i = 0; i < arr.length; i++) {
+ newArr[i] = arr[arr.length - i - 1];
+}
+console.log(JSON.stringify(newArr));
+```
+
+打印结果：
+
+```
+ [50,40,30,20,10]
+```
+
+### 例 2：冒泡排序
+
+代码实现：
+
+```javascript
+var arr = [20, 10, 50, 30, 40];
+for (var i = 0; i < arr.length - 1; i++) {
+ for (var j = 0; j < arr.length - i - 1; j++) {
+ if (arr[j] > arr[j + 1]) {
+ var temp = arr[j];
+ arr[j] = arr[j + 1];
+ arr[j + 1] = temp;
+ }
+ }
+}
+console.log(JSON.stringify(arr));
+```
+
+打印结果：
+
+```
+ [10,20,30,40,50]
+```
+
+## 我的公众号
+
+想学习**代码之外的技能**？不妨关注我的微信公众号：**千古壹号**（id：`qianguyihao`）。
+
+扫一扫，你将发现另一个全新的世界，而这将是一场美丽的意外：
+
+
diff --git a/04-JavaScript基础/17-数组简介.md b/04-JavaScript基础/17-数组简介.md
deleted file mode 100644
index faf02d3..0000000
--- a/04-JavaScript基础/17-数组简介.md
+++ /dev/null
@@ -1,264 +0,0 @@
-
-
-> 之前学习的数据类型，只能存储一个值（字符串为一个值）。如果我们想存储多个值，就可以使用数组。
-
-## 数组简介
-
-数组（Array）是属于**内置对象**，我们可以在[MDN](https://developer.mozilla.org/zh-CN/)网站上查询各种方法。
-
-数组和普通对象的功能类似，也是用来存储一些值的。不同的是：
-
-- 普通对象是使用字符串作为属性名的，而数组是使用数字来作为**索引**来操作元素。索引：从0开始的整数就是索引。
-
-数组的存储性能比普通对象要好。在实际开发中我们经常使用数组来存储一些数据，使用频率非常高。
-
-数组中的元素可以是任意的数据类型，也可以是对象，也可以是函数，也可以是数组。数组的元素中，如果存放的是数组，我们就称这种数组为二维数组。
-
-接下来，我们讲一讲数组的基本操作。
-
-
-## 创建数组对象
-
-### 方式一：使用数组字面量创建数组
-
-举例：
-
-```javascript
-var arr1 = []; // 创建一个空的数组
-
-var arr2 = [1,2,3]; // 创建带初始值的数组
-```
-
-方式一最简单，也用得最多。
-
-### 方式二：使用构造函数创建数组
-
-语法：
-
-```
-var arr = new Array(参数);
-```
-
-如果**参数为空**，则表示创建一个空数组；如果参数是**一个数值**时，表示数组的长度；参数位置是**多个数值**时，表示数组中的元素。
-
-来举个例子：
-
-```javascript
- // 方式一
- var arr1 = [11, 12, 13];
-
- // 方式二
- var arr2 = new Array(); // 参数为空
- var arr3 = new Array(4); // 参数为一个数值
- var arr4 = new Array(15, 16, 17); // 参数为多个数值
-
- console.log(typeof arr1); // 打印结果：object
-
- console.log("arr1 = " + JSON.stringify(arr1));
- console.log("arr2 = " + JSON.stringify(arr2));
- console.log("arr3 = " + JSON.stringify(arr3));
- console.log("arr4 = " + JSON.stringify(arr4));
-```
-
-打印结果：
-
-```javascript
- object
-
- arr1 = [11,12,13]
- arr2 = []
- arr3 = [null,null,null,null]
- arr4 = [15,16,17]
-```
-
-从上方打印结果的第一行里，可以看出，数组的类型其实也是属于**对象**。
-
-### 数组中的元素的类型
-
-数组中可以存放**任意类型**的数据，例如字符串、数字、布尔值、对象等。
-
-比如：
-
-```javascript
-var arr = ['qianguyihao', 28, true, {name: 'qianguyihao'}];
-```
-
-## 数组的基本操作
-
-### 数组的索引
-
-**索引** (下标) ：用来访问数组元素的序号，代表的是数组中的元素在数组中的位置（下标从 0 开始算起）。
-
-数组可以通过索引来访问、设置、修改对应的数组元素。我们继续看看。
-
-### 向数组中添加元素
-
-语法：
-
-```javascript
-数组[索引] = 值
-```
-
-代码举例：
-
-```javascript
-var arr = [];
-
-// 向数组中添加元素
-arr[0] = 10;
-arr[1] = 20;
-arr[2] = 30;
-arr[3] = 40;
-arr[5] = 50;
-
-console.log(JSON.stringify(arr));
-```
-
-打印结果：
-
-```
-[10,20,30,40,null,50]
-```
-
-### 获取数组中的元素
-
-语法：
-
-```javascript
- 数组[索引]
-```
-
-如果读取不存在的索引（比如元素没那么多），系统不会报错，而是返回undefined。
-
-代码举例：
-
-```javascript
- var arr = [21, 22, 23];
-
- console.log(arr[0]); // 打印结果：21
- console.log(arr[5]); // 打印结果：undefined
-```
-
-### 获取数组的长度
-
-可以使用`length`属性来获取数组的长度(即“元素的个数”)。
-
-数组的长度是元素个数，不要跟索引号混淆。
-
-语法：
-
-```javascript
- 数组的长度 = 数组名.length；
-```
-
-代码举例：
-
-```javascript
- var arr = [21, 22, 23];
-
- console.log(arr.length); // 打印结果：3
-```
-
-补充：
-
-对于连续的数组，使用length可以获取到数组的长度（元素的个数）；对于非连续的数组，使用length会获取到数组的最大的索引+1。因此，尽量不要创建非连续的数组。
-
-### 修改数组的长度（修改length）
-
-- 如果修改的length大于原长度，则多出部分会空出来，置为 null。
-
-- 如果修改的length小于原长度，则多出的元素会被删除，数组将从后面删除元素。
-
-- （特例：伪数组arguments的长度可以修改，但是不能修改里面的元素，后面单独讲。）
-
-代码举例：
-
-```javascript
- var arr1 = [11, 12, 13];
- var arr2 = [21, 22, 23];
-
- // 修改数组 arr1 的 length
- arr1.length = 1;
- console.log(JSON.stringify(arr1));
-
- // 修改数组 arr2 的 length
- arr2.length = 5;
- console.log(JSON.stringify(arr2));
-```
-
-打印结果：
-
-```javascript
- [11]
-
- [21,22,23,null,null]
-```
-
-### 遍历数组
-
-**遍历**: 就是把数组中的每个元素从头到尾都访问一次。
-
-最简单的做法是通过 for 循环，遍历数组中的每一项。举例：
-
-```javascript
- var arr = [10, 20, 30, 40, 50];
-
- for (var i = 0; i < arr.length; i++) {
- console.log(arr[i]); // 打印出数组中的每一项
- }
-```
-
-下一篇文章，会学习数组的各种方法，到时候，会有更多的做法去遍历数组。
-
-## 案例
-
-### 例1：翻转数组
-
-代码实现：
-
-```javascript
- var arr = [10, 20, 30, 40, 50]; // 原始数组
- var newArr = []; // 翻转后的数组
- for (var i = 0; i < arr.length; i++) {
- newArr[i] = arr[arr.length - i - 1];
- }
- console.log(JSON.stringify(newArr));
-```
-
-打印结果：
-
-```
- [50,40,30,20,10]
-```
-
-### 例2：冒泡排序
-
-代码实现：
-
-```javascript
- var arr = [20, 10, 50, 30, 40];
- for (var i = 0; i < arr.length - 1; i++) {
- for (var j = 0; j < arr.length - i - 1; j++) {
- if (arr[j] > arr[j + 1]) {
- var temp = arr[j];
- arr[j] = arr[j + 1];
- arr[j + 1] = temp;
- }
- }
- }
- console.log(JSON.stringify(arr));
-```
-
-打印结果：
-
-```
- [10,20,30,40,50]
-```
-
-## 我的公众号
-
-想学习**代码之外的技能**？不妨关注我的微信公众号：**千古壹号**（id：`qianguyihao`）。
-
-扫一扫，你将发现另一个全新的世界，而这将是一场美丽的意外：
-
-
diff --git a/04-JavaScript基础/18-数组的常见方法&数组的遍历.md b/04-JavaScript基础/18-数组的常见方法&数组的遍历.md
index 0a891f4..e9b65aa 100644
--- a/04-JavaScript基础/18-数组的常见方法&数组的遍历.md
+++ b/04-JavaScript基础/18-数组的常见方法&数组的遍历.md
@@ -1,77 +1,207 @@
+## 数组的方法清单
+**数组的类型相关**：
-## 前言
+| 方法 | 描述 | 备注 |
+| :------------------------------- | :----------------------------------- | :--- |
+| Array.isArray() | 判断是否为数组 | |
+| toString() | 将数组转换为字符串 | |
+| Array.from(arrayLike) | 将**伪数组**转化为**真数组** | |
+| Array.of(value1, value2, value3) | 创建数组：将**一系列值**转换成数组 | |
-**数组的四个基本方法如下**：（数组元素的添加和删除）
+注意，获取数组的长度是用`length`属性，不是方法。关于 `length`属性，详见上一篇文章。
+**数组元素的添加和删除**：
+
+| 方法 | 描述 | 备注 |
+| :-------- | :--------------------------------------------------------------- | :------------- |
+| push() | 向数组的**最后面**插入一个或多个元素，返回结果为**新数组的长度** | 会改变原数组 |
+| pop() | 删除数组中的**最后一个**元素，返回结果为**被删除的元素** | 会改变原数组 |
+| unshift() | 在数组**最前面**插入一个或多个元素，返回结果为**新数组的长度** | 会改变原数组 |
+| shift() | 删除数组中的**第一个**元素，返回结果为**被删除的元素** | 会改变原数组 |
+| | | |
+| slice() | 从数组中**提取**指定的一个或多个元素，返回结果为**新的数组** | 不会改变原数组 |
+| splice() | 从数组中**删除**指定的一个或多个元素，返回结果为**被删除元素组成的新数组** | 会改变原数组 |
+| | | |
+| fill() | 填充数组：用固定的值填充数组，返回结果为**新的数组** | 不会改变原数组 |
+
+**数组的合并和拆分**：
+
+| 方法 | 描述 | 备注 |
+| :------- | :--------------------------------------------------- | :--------------- |
+| concat() | 合并数组：连接两个或多个数组，返回结果为**新的数组** | 不会改变原数组 |
+| join() | 将数组转换为字符串，返回结果为**转换后的字符串** | 不会改变原数组 |
+| split() | 将字符串按照指定的分隔符，组装为数组 | 不会改变原字符串 |
+
+注意，`split()`是字符串的方法，不是数组的方法。
+
+**数组排序**：
| 方法 | 描述 | 备注 |
-|:-------------|:-------------|:-------------|
-| push() | 向数组的**最后面**插入一个或多个元素，返回结果为**该数组新的长度**| 会改变原数组|
-| pop() | 删除数组中的**最后一个**元素，返回结果为**被删除的元素**| 会改变原数组|
-| unshift() | 在数组**最前面**插入一个或多个元素，返回结果为**该数组新的长度**| 会改变原数组|
-| shift() | 删除数组中的**第一个**元素，返回结果为**被删除的元素**| 会改变原数组|
+| :-------- | :----------------------------------------------------------------- | :------------- |
+| reverse() | 反转数组，返回结果为**反转后的数组** | 会改变原数组 |
+| sort() | 对数组的元素,默认按照**Unicode 编码**，从小到大进行排序 | 会改变原数组 |
+**遍历数组**：
-**数组的常见方法如下**：
+| 方法 | 描述 | 备注 |
+| :-------- | :--------------------------------------------------------------------------------------------------------- | :------------------------------------------------------- |
+| for 循环 | 这个大家都懂 | |
+| forEach() | 和 for 循环类似，但需要兼容 IE8 以上 | forEach() 没有返回值。也就是说，它的返回值是 undefined |
+| map() | 对原数组中的每一项进行加工，将组成新的数组 | 不会改变原数组 |
+| filter() | 数据过滤：对数组中的每一项运行回调函数，该函数返回结果是 true 的项，将组成新的数组，返回结果为**新的数组** | 不会改变原数组 |
+| every() | 如果有一项返回 false，则停止遍历，此方法返回 false | 一假即假。要求每一项都返回 true，最终的结果才返回 true |
+| some() | 只要有一项返回 true，则停止遍历，此方法返回 true | 一真即真。要求每一项都返回 false，最终的结果才返回 false |
+| reduce | 为数组中的每一个元素，依次执行回调函数 | |
-| 方法 | 描述 | 备注 |
-|:-------------|:-------------|:-------------|
-| slice() | 从数组中**提取**指定的一个或多个元素，返回结果为**新的数组**| 不会改变原数组|
-| splice() | 从数组中**删除**指定的一个或多个元素，返回结果为**新的数组**| 会改变原数组|
-| concat() | 连接两个或多个数组，返回结果为**新的数组**| 不会改变原数组|
-| join() | 将数组转换为字符串，返回结果为**转换后的字符串**| 不会改变原数组|
-| reverse() | 反转数组，返回结果为**反转后的数组**| 会改变原数组|
-| sort() | 对数组的元素,默认按照**Unicode编码**，从小到大进行排序| 会改变原数组|
+**查找数组的元素**：
+| 方法 | 描述 | 备注 |
+| :-------------------- | :---------------------------------------------------- | :--- |
+| indexOf(value) | 从前往后索引，获取 value 在数组中的第一个下标 | |
+| lastIndexOf(value) | 从后往前索引，获取 value 在数组中的最后一个下标 | |
+| find(function()) | 找出**第一个**满足「指定条件返回 true」的元素。 | |
+| findIndex(function()) | 找出**第一个**满足「指定条件返回 true」的元素的 index | |
+| |
-**遍历数组的方法如下**：
-
-| 方法 | 描述 | 备注 |
-|:-------------|:-------------|:-------------|
-| for循环 | 这个大家都懂| |
-| forEach()|和 for循环类似，但需要兼容IE8以上 |forEach() 没有返回值。也就是说，它的返回值是 undefined|
-| map()| 对原数组中的每一项进行加工，将组成新的数组 | 不会改变原数组 |
-| filter()| 对数组中的每一项运行回调函数，该函数返回结果是true的项，将组成新的数组，返回结果为**新的数组**。可以起到过滤的作用| 不会改变原数组|
-| every()| 如果有一项返回false，则停止遍历，此方法返回 false | 一假即假。要求每一项都返回true，最终的结果才返回true |
-| some()| 只要有一项返回true，则停止遍历，此方法返回true | 一真即真。要求每一项都返回false，最终的结果才返回false|
-| reduce | 为数组中的每一个元素，依次执行回调函数 | |
-
-**数组的其他方法如下**：
-
-| 方法 | 描述 | 备注 |
-|:-------------|:-------------|:-------------|
-| indexOf(value) | 从前往后索引，获取 value 在数组中的第一个下标 | |
-| lastIndexOf(value) | 从后往前索引，获取 value 在数组中的最后一个下标 | |
-| find(function()) | 找出**第一个**满足「指定条件返回true」的元素。 | |
-| findIndex(function()) | 找出**第一个**满足「指定条件返回true」的元素的index | |
-| Array.from(arrayLike) | 将**伪数组**转化为**真数组**| |
-| Array.of(value1, value2, value3) | 将**一系列值**转换成数组。| |
-
-## 数组的四个基本方法（数组元素的添加和删除）
-
-### push()
-
-`push()`：向数组的**最后面**插入一个或多个元素，返回结果为**该数组新的长度**。
-
+## isArray()：判断是否为数组
语法：
```javascript
- 数组的新长度 = 数组.push(元素);
+布尔值 = Array.isArray(被检测的数组);
+```
+
+以前，我们会通过 `A instanceof B`来判断 A 是否属于 B 类型。但是在数组里，这种 instanceof 方法已经用的不多了，因为有 isArray()方法。
+
+## toString()：数组转换为字符串
+
+```javascript
+字符串 = 数组.toString();
+```
+
+解释：把数组转换成字符串，每一项用`,`分割。
+
+备注：大多数的数据类型都可以使用`.toString()`方法，将其转换为字符串。
+
+### 知识点补充：将数组转换为字符串，有哪些方式
+
+方式 1：
+
+```js
+字符串 = 数组.toString();
+```
+
+方式 2：
+
+```js
+字符串 = String(数组);
+```
+
+方式 3：
+
+```js
+字符串 = 数组.join(','); // 将数组转为字符串，每一项用 英文逗号 分隔
+```
+
+## Array.from()：将伪数组转换为真数组
+
+**语法**：
+
+```javascript
+array = Array.from(arrayLike);
+```
+
+**作用**：将**伪数组**或可遍历对象转换为**真数组**。
+
+代码举例：
+
+```js
+const name = 'qianguyihao';
+console.log(Array.from(name)); // 打印结果是数组：["q","i","a","n","g","u","y","i","h","a","o"]
+```
+
+### 伪数组与真数组的区别
+
+**伪数组**：包含 length 属性的对象或可迭代的对象。
+
+另外，伪数组的原型链中没有 Array.prototype，而真数组的原型链中有 Array.prototype。因此伪数组没有数组的一般方法，比如 pop()、join() 等方法。
+
+### 伪数组举例
+
+```html
+
+
+
+
+
+
+
+```
+
+上面的布局中，有三个 button 标签，我们通过`getElementsByTagName`获取到的`btnArray`实际上是**伪数组**，并不是真实的数组：
+
+
+
+既然`btnArray`是伪数组，它就不能使用数组的一般方法，否则会报错：
+
+
+
+解决办法：采用`Array.from`方法将`btnArray`这个伪数组转换为真数组即可：
+
+```javascript
+Array.from(btnArray);
+```
+
+然后就可以使用数组的一般方法了：
+
+
+
+## Array.of()：创建数组
+
+**语法**：
+
+```javascript
+Array.of(value1, value2, value3);
+```
+
+**作用**：根据参数里的内容，创建数组。
+
+**举例**：
+
+```javascript
+const arr = Array.of(1, 'abc', true);
+console.log(arr); // 打印结果是数组：[1, "abc", true]
+```
+
+补充：`new Array()`和 `Array.of()`的区别在于：当参数只有一个时，前者表示数组的长度，后者表示数组中的内容。
+
+## 数组元素的添加和删除
+
+### push()
+
+`push()`：向数组的**最后面**插入一个或多个元素，返回结果为**新数组的长度**。
+
+语法：
+
+```javascript
+新数组的长度 = 数组.push(元素);
```
代码举例：
```javascript
- var arr = ["王一", "王二", "王三"];
+var arr = ['王一', '王二', '王三'];
- var result1 = arr.push("王四"); // 末尾插入一个元素
- var result2 = arr.push("王五", "王六"); // 末尾插入多个元素
-
- console.log(result1); // 打印结果：4
- console.log(result2); // 打印结果：6
- console.log(JSON.stringify(arr)); // 打印结果：["王一","王二","王三","王四","王五","王六"]
+var result1 = arr.push('王四'); // 末尾插入一个元素
+var result2 = arr.push('王五', '王六'); // 末尾插入多个元素
+console.log(result1); // 打印结果：4
+console.log(result2); // 打印结果：6
+console.log(JSON.stringify(arr)); // 打印结果：["王一","王二","王三","王四","王五","王六"]
```
### pop()
@@ -81,43 +211,41 @@
语法：
```javascript
- 被删除的元素 = 数组.pop();
+被删除的元素 = 数组.pop();
```
代码举例：
```javascript
- var arr = ["王一", "王二", "王三"];
+var arr = ['王一', '王二', '王三'];
- var result1 = arr.pop();
+var result1 = arr.pop();
- console.log(result1); // 打印结果：王三
- console.log(JSON.stringify(arr)); // 打印结果：["王一","王二"]
+console.log(result1); // 打印结果：王三
+console.log(JSON.stringify(arr)); // 打印结果：["王一","王二"]
```
-
### unshift()
-`unshift()`：在数组**最前面**插入一个或多个元素，返回结果为**该数组新的长度**。插入元素后，其他元素的索引会依次调整。
+`unshift()`：在数组**最前面**插入一个或多个元素，返回结果为**新数组的长度**。插入元素后，其他元素的索引会依次调整。
语法：
```javascript
- 数组的新长度 = 数组.unshift(元素);
+新数组的长度 = 数组.unshift(元素);
```
代码举例：
```javascript
- var arr = ["王一", "王二", "王三"];
+var arr = ['王一', '王二', '王三'];
- var result1 = arr.unshift("王四"); // 最前面插入一个元素
- var result2 = arr.unshift("王五", "王六"); // 最前面插入多个元素
-
- console.log(result1); // 打印结果：4
- console.log(result2); // 打印结果：6
- console.log(JSON.stringify(arr)); // 打印结果：["王五","王六","王四","王一","王二","王三"]
+var result1 = arr.unshift('王四'); // 最前面插入一个元素
+var result2 = arr.unshift('王五', '王六'); // 最前面插入多个元素
+console.log(result1); // 打印结果：4
+console.log(result2); // 打印结果：6
+console.log(JSON.stringify(arr)); // 打印结果：["王五","王六","王四","王一","王二","王三"]
```
### shift()
@@ -127,23 +255,21 @@
语法：
```javascript
- 被删除的元素 = 数组.shift();
+被删除的元素 = 数组.shift();
```
代码举例：
```javascript
- var arr = ["王一", "王二", "王三"];
+var arr = ['王一', '王二', '王三'];
- var result1 = arr.shift();
+var result1 = arr.shift();
- console.log(result1); // 打印结果：王一
- console.log(JSON.stringify(arr)); // 打印结果：["王二","王三"]
+console.log(result1); // 打印结果：王一
+console.log(JSON.stringify(arr)); // 打印结果：["王二","王三"]
```
-接下来，我们讲一下数组的其他常见方法。
-
-## slice()
+### slice()
`slice()`：从数组中**提取**指定的一个或者多个元素，返回结果为**新的数组**（不会改变原来的数组）。
@@ -152,76 +278,85 @@
**语法**：
```javascript
- 新数组 = 原数组.slice(开始位置的索引, 结束位置的索引); //注意：包含开始索引，不包含结束索引
+新数组 = 原数组.slice(开始位置的索引, 结束位置的索引); //注意：包含开始索引，不包含结束索引
```
举例：
```javascript
- var arr = ["a", "b", "c", "d", "e", "f"];
+const arr = ['a', 'b', 'c', 'd', 'e', 'f'];
- var result1 = arr.slice(2); //从第二个值开始提取
- var result2 = arr.slice(-2); //提取最后两个元素
- var result3 = arr.slice(2, 4); //提取从第二个到第四个之间的值（不包括第四个值）
- var result4 = arr.slice(4, 2); //空
-
- console.log("arr:" + JSON.stringify(arr));
- console.log("result1:" + JSON.stringify(result1));
- console.log("result2:" + JSON.stringify(result2));
- console.log("result3:" + JSON.stringify(result3));
- console.log("result4:" + JSON.stringify(result4));
+const result1 = arr.slice(); // 不加参数时，则获取所有的元素。相当于数组的整体赋值
+const result2 = arr.slice(2); // 从第二个值开始提取，直到末尾
+const result3 = arr.slice(-2); // 提取最后两个元素
+const result4 = arr.slice(2, 4); // 提取从第二个到第四个之间的元素（不包括第四个元素）
+const result5 = arr.slice(4, 2); // 空
+console.log('arr:' + JSON.stringify(arr));
+console.log('result1:' + JSON.stringify(result1));
+console.log('result2:' + JSON.stringify(result2));
+console.log('result3:' + JSON.stringify(result3));
+console.log('result4:' + JSON.stringify(result4));
+console.log('result5:' + JSON.stringify(result5));
```
打印结果：
```javascript
- arr:["a","b","c","d","e","f"]
- result1:["c","d","e","f"]
- result2:["e","f"]
- result3:["c","d"]
- result4:[]
-```
+arr:["a","b","c","d","e","f"]
+result1:["a","b","c","d","e","f"]
+result2:["c","d","e","f"]
+result3:["e","f"]
+result4:["c","d"]
+result5:[]
+```
**补充**：
很多前端开发人员会用 slice()将伪数组，转化为真数组。写法如下：
```javascript
-array = Array.prototye.slice.call(arrayLike)
-或者
-array = [].slice.call(arrayLike)
+// 方式1
+array = Array.prototye.slice.call(arrayLike);
+
+// 方式2
+array = [].slice.call(arrayLike);
```
ES6 看不下去这种蹩脚的转化方法，于是出了一个新的 API：（专门用来将伪数组转化成真数组）
```javascript
-array = Array.from(arrayLike)
+array = Array.from(arrayLike);
```
-## splice()
+关于这个 API 的详细介绍，上面的内容已经讲了，请往前翻。
-`splice()`：从数组中**删除**指定的一个或多个元素，返回结果为**新的数组**（会改变原来的数组）。
+### splice()
+
+`splice()`：从数组中**删除**指定的一个或多个元素，返回结果为**被删除元素组成的新数组**（会改变原来的数组）。
备注：该方法会改变原数组，会将指定元素从原数组中删除；被删除的元素会封装到一个新的数组中返回。
语法：
```javascript
- 新数组 = 原数组.splice(起始索引index, 需要删除的个数, 第三个参数, 第四个参数...);
+
+新数组 = 原数组.splice(起始索引index, 需要删除的个数);
+
+新数组 = 原数组.splice(起始索引index, 需要删除的个数, 新的元素1, 新的元素2...);
```
-上方语法中，第三个及之后的参数，表示：向原数组中添加新的元素，这些元素将会自动插入到开始位置索引的前面。
+上方语法中，第三个及之后的参数，表示：删除元素之后，向原数组中添加新的元素，这些元素将会自动插入到起始位置索引的前面。也可以理解成：删除了哪些元素，就在那些元素的所在位置补充新的内容。
-举例1：
+举例 1：
```javascript
- var arr1 = ["a", "b", "c", "d", "e", "f"];
- var result1 = arr1.splice(1); //从第index为1的位置开始，删除元素
+var arr1 = ['a', 'b', 'c', 'd', 'e', 'f'];
+var result1 = arr1.splice(1); //从第index为1的位置开始，删除元素
- console.log("arr1：" + JSON.stringify(arr1));
- console.log("result1：" + JSON.stringify(result1));
+console.log('arr1：' + JSON.stringify(arr1));
+console.log('result1：' + JSON.stringify(result1));
```
打印结果：
@@ -231,16 +366,14 @@ array = Array.from(arrayLike)
result1：["b","c","d","e","f"]
```
-
-举例2：
-
+举例 2：
```javascript
- var arr2 = ["a", "b", "c", "d", "e", "f"];
- var result2 = arr2.splice(-2); //删除最后两个元素
+var arr2 = ['a', 'b', 'c', 'd', 'e', 'f'];
+var result2 = arr2.splice(-2); //删除最后两个元素
- console.log("arr2：" + JSON.stringify(arr2));
- console.log("result2：" + JSON.stringify(result2));
+console.log('arr2：' + JSON.stringify(arr2));
+console.log('result2：' + JSON.stringify(result2));
```
打印结果：
@@ -250,17 +383,14 @@ array = Array.from(arrayLike)
result2：["e","f"]
```
-举例3：
-
-
-
+举例 3：
```javascript
- var arr3 = ["a", "b", "c", "d", "e", "f"];
- var result3 = arr3.splice(1, 3); //从第index为1的位置开始删除元素,一共删除三个元素
+var arr3 = ['a', 'b', 'c', 'd', 'e', 'f'];
+var result3 = arr3.splice(1, 3); //从第index为1的位置开始删除元素,一共删除三个元素
- console.log("arr3：" + JSON.stringify(arr3));
- console.log("result3：" + JSON.stringify(result3));
+console.log('arr3：' + JSON.stringify(arr3));
+console.log('result3：' + JSON.stringify(result3));
```
打印结果：
@@ -270,17 +400,16 @@ array = Array.from(arrayLike)
result3：["b","c","d"]
```
-
-举例4：（我们来看看**第三个参数**的用法）
+举例 4：（我们来看看**第三个参数**的用法）
```javascript
-var arr4 = ["a", "b", "c", "d", "e", "f"];
+var arr4 = ['a', 'b', 'c', 'd', 'e', 'f'];
//从第index为1的位置开始删除元素,一共删除三个元素。并且在 index=1 的前面追加两个元素
-var result4 = arr4.splice(1, 3, "千古壹号", "vae");
+var result4 = arr4.splice(1, 3, '千古壹号', 'vae');
-console.log("arr4：" + JSON.stringify(arr4));
-console.log("result4：" + JSON.stringify(result4));
+console.log('arr4：' + JSON.stringify(arr4));
+console.log('result4：' + JSON.stringify(result4));
```
打印结果：
@@ -290,49 +419,92 @@ arr4：["a","千古壹号","vae","e","f"]
result4：["b","c","d"]
```
+
+### fill()
+
+`fill()`：用一个固定值填充数组，返回结果为**新的数组**。不会改变原数组。
+
+语法：
+
+```js
+// 用一个固定值填充数组。数组里的每个元素都会被这个固定值填充
+新数组 = 数组.fill(固定值);
+
+// 从 startIndex 开始的数组元素，用固定值填充
+新数组 = 数组.fill(固定值, startIndex);
+
+// 从 startIndex 到 endIndex 之间的元素（包左不包右），用固定值填充
+新数组 = 数组.fill(固定值, startIndex, endIndex);
+```
+
+
+举例：
+
+```js
+// 创建一个长度为4的空数组，然后用 'f' 来填充这个空数组
+console.log(Array(4).fill('f')); // ['f', 'f', 'f,' 'f']
+
+// 将现有数组的每一个元素都进行填充
+console.log(['a', 'b', 'c', 'd'].fill('f')); // ['f', 'f', 'f,' 'f']
+
+// 指定位置进行填充
+console.log(['a', 'b', 'c', 'd'].fill('f', 1, 3)); // ["a", "f", "f", "d"]
+```
+
+
## concat()
-`concat()`：连接两个或多个数组，返回结果为**新的数组**。（不会改变原数组）
+`concat()`：连接两个或多个数组，返回结果为**新的数组**。不会改变原数组。`concat()`方法的作用是**数组合并**。
语法：
```javascript
新数组 = 数组1.concat(数组2, 数组3 ...);
-
```
举例：
```javascript
- var arr1 = [1, 2, 3];
- var arr2 = ["a", "b", "c"];
- var arr3 = ["千古壹号", "vae"];
+const arr1 = [1, 2, 3];
+const arr2 = ['a', 'b', 'c'];
+const arr3 = ['千古壹号', 'vae'];
- var result1 = arr1.concat(arr2);
+const result1 = arr1.concat(arr2);
- var result2 = arr2.concat(arr1, arr3);
+const result2 = arr2.concat(arr1, arr3);
- console.log("arr1 =" + JSON.stringify(arr1));
- console.log("arr2 =" + JSON.stringify(arr2));
- console.log("arr3 =" + JSON.stringify(arr3));
+console.log('arr1 =' + JSON.stringify(arr1));
+console.log('arr2 =' + JSON.stringify(arr2));
+console.log('arr3 =' + JSON.stringify(arr3));
- console.log("result1 =" + JSON.stringify(result1));
- console.log("result2 =" + JSON.stringify(result2));
+console.log('result1 =' + JSON.stringify(result1));
+console.log('result2 =' + JSON.stringify(result2));
```
打印结果：
```javascript
-arr1 =[1,2,3]
-arr2 =["a","b","c"]
-arr3 =["千古壹号","vae"]
+arr1 = [1, 2, 3];
+arr2 = ['a', 'b', 'c'];
+arr3 = ['千古壹号', 'vae'];
-result1 =[1,2,3,"a","b","c"]
-result2 =["a","b","c",1,2,3,"千古壹号","vae"]
+result1 = [1, 2, 3, 'a', 'b', 'c'];
+result2 = ['a', 'b', 'c', 1, 2, 3, '千古壹号', 'vae'];
```
从打印结果中可以看到，原数组并没有被修改。
+### 数组合并的另一种方式
+
+我们可以使用`...`这种展开语法，将两个数组进行合并。举例如下：
+
+```js
+const arr1 = [1, 2, 3];
+
+const result = ['a', 'b', 'c', ...arr1];
+console.log(JSON.stringify(result)); // 打印结果：["a","b","c",1,2,3]
+```
+
## join()
`join()`：将数组转换为字符串，返回结果为**转换后的字符串**（不会改变原来的数组）。
@@ -342,30 +514,29 @@ result2 =["a","b","c",1,2,3,"千古壹号","vae"]
语法：
```javascript
- 新的字符串 = 原数组.join(参数); // 参数选填
+新的字符串 = 原数组.join(参数); // 参数选填
```
代码举例：
```javascript
- var arr = ["a", "b", "c"];
+var arr = ['a', 'b', 'c'];
- var result1 = arr.join(); // 这里没有指定连接符，所以默认使用 , 作为连接符
+var result1 = arr.join(); // 这里没有指定连接符，所以默认使用 , 作为连接符
- var result2 = arr.join("-"); // 使用指定的字符串作为连接符
+var result2 = arr.join('-'); // 使用指定的字符串作为连接符
- console.log(typeof arr); // 打印结果：object
- console.log(typeof result1); // 打印结果：string
-
- console.log("arr =" + JSON.stringify(arr));
- console.log("result1 =" + JSON.stringify(result1));
- console.log("result2 =" + JSON.stringify(result2));
+console.log(typeof arr); // 打印结果：object
+console.log(typeof result1); // 打印结果：string
+console.log('arr =' + JSON.stringify(arr));
+console.log('result1 =' + JSON.stringify(result1));
+console.log('result2 =' + JSON.stringify(result2));
```
上方代码中，最后三行的打印结果是：
-```javascript
+```
arr =["a","b","c"]
result1 =a,b,c
result2 =a-b-c
@@ -384,17 +555,17 @@ result2 =a-b-c
举例：
```javascript
- var arr = ["a", "b", "c", "d", "e", "f"];
+var arr = ['a', 'b', 'c', 'd', 'e', 'f'];
- var result = arr.reverse(); // 将数组 arr 进行反转
+var result = arr.reverse(); // 将数组 arr 进行反转
- console.log("arr =" + JSON.stringify(arr));
- console.log("result =" + JSON.stringify(result));
+console.log('arr =' + JSON.stringify(arr));
+console.log('result =' + JSON.stringify(result));
```
打印结果：
-```javascript
+```
arr =["f","e","d","c","b","a"]
result =["f","e","d","c","b","a"]
```
@@ -409,47 +580,47 @@ result =["f","e","d","c","b","a"]
### sort()方法举例：无参时
-如果在使用 sort() 方法时不带参，则默认按照**Unicode编码**，从小到大进行排序。
+如果在使用 sort() 方法时不带参，则默认按照**Unicode 编码**，从小到大进行排序。
-**举例1**：（当数组中的元素为字符串时）
+**举例 1**：（当数组中的元素为字符串时）
```javascript
- var arr1 = ["e", "b", "d", "a", "f", "c"];
+var arr1 = ['e', 'b', 'd', 'a', 'f', 'c'];
- var result = arr1.sort(); // 将数组 arr1 进行排序
+var result = arr1.sort(); // 将数组 arr1 进行排序
- console.log("arr1 =" + JSON.stringify(arr1));
- console.log("result =" + JSON.stringify(result));
+console.log('arr1 =' + JSON.stringify(arr1));
+console.log('result =' + JSON.stringify(result));
```
打印结果：
-```javascript
+```
arr1 =["a","b","c","d","e","f"]
result =["a","b","c","d","e","f"]
```
-从上方的打印结果中，我们可以看到，sort方法会改变原数组，而且方法的返回值也是同样的结果。
+从上方的打印结果中，我们可以看到，sort 方法会改变原数组，而且方法的返回值也是同样的结果。
-**举例2**：（当数组中的元素为数字时）
+**举例 2**：（当数组中的元素为数字时）
```javascript
- var arr2 = [5, 2, 11, 3, 4, 1];
+var arr2 = [5, 2, 11, 3, 4, 1];
- var result = arr2.sort(); // 将数组 arr2 进行排序
+var result = arr2.sort(); // 将数组 arr2 进行排序
- console.log("arr2 =" + JSON.stringify(arr2));
- console.log("result =" + JSON.stringify(result));
+console.log('arr2 =' + JSON.stringify(arr2));
+console.log('result =' + JSON.stringify(result));
```
打印结果：
-```javascript
+```
arr2 =[1,11,2,3,4,5]
result =[1,11,2,3,4,5]
```
-上方的打印结果中，你会发现，使用 sort() 排序后，数字`11`竟然在数字`2`的前面。这是为啥呢？因为上面讲到了，`sort()`方法是按照**Unicode编码**进行排序的。
+上方的打印结果中，你会发现，使用 sort() 排序后，数字`11`竟然在数字`2`的前面。这是为啥呢？因为上面讲到了，`sort()`方法是按照**Unicode 编码**进行排序的。
那如果我想让 arr2 里的数字，完全按照从小到大排序，怎么操作呢？继续往下看。
@@ -457,41 +628,44 @@ result =["f","e","d","c","b","a"]
如果在 sort()方法中带参，我们就可以**自定义**排序规则。具体做法如下：
-我们可以在sort()添加一个回调函数，来指定排序规则。回调函数中需要定义两个形参，浏览器将会分别使用数组中的元素作为实参去调用回调函数
+我们可以在 sort()添加一个回调函数，来指定排序规则。回调函数中需要定义两个形参，浏览器将会分别使用数组中的元素作为实参去调用回调函数
浏览器根据回调函数的返回值来决定元素的排序：（重要）
-- 如果返回一个大于0的值，则元素会交换位置
+- 如果返回一个大于 0 的值，则元素会交换位置
-- 如果返回一个小于0的值，则元素位置不变
+- 如果返回一个小于 0 的值，则元素位置不变
-- 如果返回一个0，则认为两个元素相等，则不交换位置
+- 如果返回一个 0，则认为两个元素相等，则不交换位置
**代码举例**：
```javascript
- var arr3 = [5, 2, 11, 3, 4, 1];
+var arr3 = [5, 2, 11, 3, 4, 1];
- // 自定义排序规则
- var result = arr3.sort(function(a, b) {
- if (a > b) { // 如果 a 大于 b，则交换 a 和 b 的位置
- return 1;
- } else if (a < b) { // 如果 a 小于 b，则位置不变
- return -1;
- } else { // 如果 a 等于 b，则位置不变
- return 0;
+// 自定义排序规则
+var result = arr3.sort(function (a, b) {
+ if (a > b) {
+ // 如果 a 大于 b，则交换 a 和 b 的位置
+ return 1;
+ } else if (a < b) {
+ // 如果 a 小于 b，则位置不变
+ return -1;
+ } else {
+ // 如果 a 等于 b，则位置不变
+ return 0;
}
- });
+});
- console.log("arr3 =" + JSON.stringify(arr3));
- console.log("result =" + JSON.stringify(result));
- ```
+console.log('arr3 =' + JSON.stringify(arr3));
+console.log('result =' + JSON.stringify(result));
+```
打印结果：
```javascript
- arr3 =[1,2,3,4,5,11]
- result =[1,2,3,4,5,11]
+arr3 = [1, 2, 3, 4, 5, 11];
+result = [1, 2, 3, 4, 5, 11];
```
上方代码的写法太啰嗦了，其实也可以简化为如下写法：
@@ -499,27 +673,26 @@ result =["f","e","d","c","b","a"]
**代码优化**：（冒泡排序）
```javascript
- var arr3 = [5, 2, 11, 3, 4, 1];
+var arr3 = [5, 2, 11, 3, 4, 1];
- // 自定义排序规则
- var result = arr3.sort(function(a, b) {
+// 自定义排序规则
+var result = arr3.sort(function (a, b) {
return a - b; // 升序排列
// return b - a; // 降序排列
- });
+});
- console.log("arr3 =" + JSON.stringify(arr3));
- console.log("result =" + JSON.stringify(result));
+console.log('arr3 =' + JSON.stringify(arr3));
+console.log('result =' + JSON.stringify(result));
```
打印结果：
```javascript
- arr3 =[1,2,3,4,5,11]
- result =[1,2,3,4,5,11]
+arr3 = [1, 2, 3, 4, 5, 11];
+result = [1, 2, 3, 4, 5, 11];
```
-
-### sort方法举例：将数组从小到大排序
+### sort 方法举例：将数组从小到大排序
将数组从小到大排序，这个例子很常见。
@@ -553,7 +726,7 @@ result =["f","e","d","c","b","a"]
console.log('qianguyihao 排序前的数组：' + JSON.stringify(dataList));
// 将dataList 数组，按照 publishTime 字段，从小到大排序。（会改变原数组）
- dataList.sort(function(a, b) {
+ dataList.sort(function (a, b) {
return parseInt(a.publishTime) - parseInt(b.publishTime);
});
@@ -561,11 +734,8 @@ result =["f","e","d","c","b","a"]