JavaScript数据结构-数组含数组方法大家好，我是前端图图。经过上一篇文章(也是我的第一篇文章)，个人感觉获得

大家好，我是前端图图。经过上一篇文章(也是我的第一篇文章)，个人感觉获得蛮不错的成绩，好开心拿下了年度征文的杰出奖。

最近也在寻思下一篇写什么东西呢？最近在学数据结构与算法这本书。那就讲讲数据结构吧！也把这次写作当作复盘。输入的同时也要输出的，不然学了一点用都没有。下面废话不多说，我们开始吧！

为什么使用数组

假设有这样一个需求：保存一组人名，可以像下面这样。

const name1 = "小红";
const name2 = "小黄";
const name3 = "小明";
const name4 = "小周";

但这样并不是最好的方案，如果按照这样的方法的话，只能存部分的人名。要创建几个到几十个变量，这样显然是行不通的。像这种需求我们就可以用数组来解决了。

const names = ["小红", "小黄", "小明", "小周"];

用数组来存这些人名就比刚才声明多个变量要简洁得多了。

创建和初始化数组

js创建和初始化数很简单，有二种方式创建或初始化一个数组。

使用new关键字创建数组

// 声明一个数组
const arr1 = new Array();
// 将数组元素作为参数
const arr2 = new Array("1", "2", "3", "4");
// 给数组一个指定长度
const arr3 = new Array(7);

使用new关键字，能简单地声明初始化一个数组，用这种方法，还可以创建一个指定长度的数组。另外也可以直接将数组元素作为参数传递给它的构造器。

但是new创建数组并不是最好的方式，还有一种创建数组的方式。

使用`[]`形式

创建一个数组还可以用[]的形式创建，这也是js最常见的一种方式。

// 通过字面量的方式创建
const arr1 = [];
//可以用一些元素初始化数组
const strs = ["1", "2", "3", "4"];

如果想知道数组中存有多少个元素(也就是数组的长度)，访问数组的length属性即可。

const numbers = [1, 2, 3, 4, 5, 6];
console.log(numbers.length); // 6

访问元素和迭代数组

要想访问数组里特定位置的元素，可以用中括号传递元素位置的数值，这就可以得到想知道的值或赋新的值。

const numbers = [1, 2, 3, 4, 5];
console.log(numbers[0]); // 1
console.log(numbers[1]); // 2

numbers[2] = 5;
console.log(numbers[2]); // 5

如果想数组numbers里的所有元素，通过for循环迭代数组、打印元素。for循环的用法就不讲了，是个程序员都会的循环语句。还有其他的数组方法下面会讲到。

const numbers = [1, 2, 3, 4, 5];

for (let i = 0; i < numbers.length; i++) {
console.log(numbers[i]);
}

通过for循环迭代每一项就可以得到数组里的所有元素并在控制台打印。

添加元素

在数组中添加元素也很简单，就拿上面的numbers举例。

const numbers = [1, 2, 3, 4, 5];

从数组尾部添加元素

想要给数组添加一个元素(比如6)，只要把值赋给数组中最后一个空位上的元素就可以了。

const numbers[numbers.length] = 6;

在js里，数组是一个可修改的对象，如果添加元素，就会自动增长。

使用push方法

数组有一个push方法，把元素添加到数组的尾部。使用push方法，能添加N元素。

let numbers = [0, 1, 2, 3, 4, 5];
numbers[numbers.length] = 6;
numbers.push(7);
numbers.push(8, 9);
console.log(numbers);
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

在最后的log中就得到了从0到9的值。

从数组头部添加元素

使用unshift方法

unshift方法，可以直接把元素插入到数组的头部。

let numbers = [0, 1, 2, 3, 4, 5];
numbers.unshift(-2, -1);
numbers.unshift(-4, -3);
console.log(numbers);
// [-4, -3, -2, -1, 0, 1, 2, 3, 4, 5]

删除元素

从数组的末尾删除元素

数组的pop方法，用于删除数组最后面的元素。

let arr = [1, 2, 3, 4, 5];
arr.pop();
console.log(arr);
// [1, 2, 3, 4]

从数组的头部删除元素

数组有一个shift方法，用于删除数组的第一个元素。

let numbers = [1, 2, 3, 4, 5, 6];
numbers.shift();
console.log(numbers);
// [ 2, 3, 4, 5, 6]

假如数组中的值是从1到6，长度为6。执行shift方法之后，数组就剩下2到6，长度也变成了5。使用shift和unshift方法，可以用数组来模拟队列的数据结构。

在任意位置添加或删除元素

使用splice方法，可以简单地通过指定位置或索引删除相应位置上指定数量的元素。

let numbers = [1, 2, 3, 4, 5, 6];
numbers.splice(4, 2);
console.log(numbers);
// [1, 2, 3, 4]

上面的代码中，删除了索引4开始的2个元素。这就表示把numbers[5]、numbers[6]这两个元素删除了。最后数组中的值是1, 2, 3, 4。

还可以使用delete运算符删除数组中的元素。

let numbers = [1, 2, 3, 4, 5];
delete numbers[2];
console.log(numbers);
// [1, 2, empty, 4, 5]

可以看到delete运算符，把numbers[2]位置上的值变成了empty。delete运算符是把元素删除了，但是位置还保留着，这个位置上值是个空值。所以不建议大家使用delete运算符数组中的元素。

现在再把5, 6放回到数组中原来的位置上，还可以使用splice方法。

let numbers = [1, 2, 3, 4, 5, 6];
numbers.splice(4, 2);
console.log(numbers);
// [1, 2, 3, 4]

number.splice(4, 0, 5, 6);
console.log(numbers);
// [1, 2, 3, 4, 5, 6]

splice方法接收第一个参数是想要删除或插入的索引值。第二个参数是删除元素的个数（这个的例子目的不是删除元素，所以传0）。第三个参数往后，就是添加到数组中的值。

二维数组和多维数组

下面用一个平均气温测量的例子，来实现一个矩阵（二维数组，或数组的数组）。

let airTemperature = [];

airTemperature[0] = [28, 22, 24, 26, 10];
airTemperature[1] = [20, 16, 18, 30, 21];
console.log(airTemperature);
// [ [ 28, 22, 24, 26, 10 ], [ 20, 16, 18, 30, 21 ] ]

上面的代码里，分别制定了每天和每小时的数据。我也照书上画了个图，方便大家理解。

每一行就是每天的数据，每一列就是当天不同时段的气温。

迭代二维数组的元素

迭代二维数组其实就是用两层for循环来实现。

let airTemperature = [];

airTemperature[0] = [28, 22, 24, 26, 10];
airTemperature[1] = [20, 16, 18, 30, 21];

for (let i = 0; i < airTemperature.length; i++) {
  console.log(airTemperature[i]);
  for (let j = 0; j < airTemperature[i].length; j++) {
    console.log(airTemperature[i][j]);
  }
}

其中变量i表示行，j表示列。每一个airTemperature[i]代表一个数组，所以在嵌套的for循环中迭代airTemperature[i]的每一个位置。

多维数组

假设要创建一个3 x 3 x 3的矩阵，每一格里包含矩阵的i(行)、j(列)、z(深度)之和。

let Arrx3x3x3 = [];
for (let i = 0; i < 3; i++) {
  Arrx3x3x3[i] = [];
  for (let j = 0; j < 3; j++) {
    Arrx3x3x3[i][j] = [];
    for (let z = 0; z < 3; z++) {
      Arrx3x3x3[i][j][z] = i + j + z;
    }
  }
}

console.log(Arrx3x3x3);
/* [
  [
    [0, 1, 2],
    [1, 2, 3],
    [2, 3, 4]
  ],
  [
    [1, 2, 3],
    [2, 3, 4],
    [3, 4, 5]
  ],
  [
    [2, 3, 4],
    [3, 4, 5],
    [4, 5, 6]
  ]
] */

数据结构有几个维度没有什么关系，可以用循环迭代每个维度来访问所有的格子。Arrx3x3x3矩阵如下图。

下面来输出一下这个矩阵里的内容。

for (let i = 0; i < Arrx3x3x3.length; i++) {
  for (let j = 0; j < Arrx3x3x3[i].length; j++) {
    for (let z = 0; z < Arrx3x3x3[i][j].length; z++) {
      console.log(Arrx3x3x3[i][j][z]); // 这里输出z的结果
    }
  }
}

如果是一个3 x 3 x 3 x 3的矩阵，就用到四层for循环语句，以此类推。在开发当中很少会用到四维数组，二维是最常见的。

js数组方法

下面来盘点一下除了以上用过的数组方法，js还有哪些数组方法。

concat：拼接2个数组或更多数组，并返回拼接后的数组。
every：对数组中的每个元素运行指定函数，检测数组的元素是否符合条件，有一个元素不符合条件都会返回false，剩余的元素不会进行检测。
filter：对数组中的每个元素运行指定函数，返回这个函数会返回true的元素组成的数组。
forEach：迭代数组的每个元素。这个方法没有返回值。
join：把数组中的所有元素连成一个字符串。
indexOf：返回一个传入的值最先出现的索引，没有找到则返回-1。(从数组的头部开始找)
lastIndexOf：返回一个传入的值最后出现的索引，没有找到则返回-1。(从数组的末尾开始找)
map：对数组中的每个元素运行指定函数，返回每次调用函数的结果组成数组。
reverse：颠倒数组中元素的顺序，第一个变成最后一个，最后一个变成第一个。
slice：传入索引值，把数组中对应索引范围内的元素作为新数组返回。
some：检测数组的每个元素是否符合添加，如果其中一个元素符合条件，则返回true。
sort：用于对数组的元素进行排序。
toString：把数组作为字符串返回。(将数组转成以逗号分隔的字符串)
valueOf：和toString类似，把数组作为字符串返回。

concat方法

如果有多个数组，想要合并成一个数组的话，可以使用concat方法。

let arr1 = [1, 2, 3];
let arr2 = [4, 5, 6];
let number = 7;
let arr3 = arr1.concat(arr2, number);
console.log(arr3);
// [1, 2, 3, 4, 5, 6, 7]

concat方法可以向一个数组传递数组、对象或者是其他类型的值。数组会按照该方法传入的参数顺序成指定数组。上面的例子里，arr2被合并到arr1中，然后number变量的值也被合并。最后输出的结果是[1, 2, 3, 4, 5, 6, 7]。

迭代函数

除了for循环语句之外，js还内置很多迭代数组的方法。我们需要一个数组和一个函数：假设数组中的值是从1到10；如果数组的元素可以被2整除，函数就返回true，否则返回false。

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

function isEven(val) {
  return val % 2 === 0;
}

every方法

every方法会迭代数组中的每个元素，直到返回false。

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(arr.every(isEven));
// false

上面的例子中，数组的第一个元素是1，它不是2的倍数，所以isEven函数返回false，然后执行就结束了。

some方法

some方法跟eveny方法的行为相反，会迭代数组的每个元素，直到函数返回true为止。

console.log(arr.some(isEven));
// true

这个例子中，数组中的第一个偶数是2。第一个被迭代的元素是1，isEven返回false。第二个被迭代的元素是2，isEven返回true，迭代就结束了。

forEach方法

forEach方法用来迭代整个数组，它和for循环效果一样。切记，forEach方法是没有返回值的。

arr.forEach((val) => console.log(val % 2 === 0));
// false
// true
// false
// true
// false
// true
// false
// true
// false
// true

map和filter方法

map和filter方法都会返回新的数组。首先看map方法。

const myMap = arr.map(isEven);
console.log(myMap);
// [false, true, false, true, false, true, false, true, false, true]

数组myMap里的值是：[false, true, false, true, false, true, false, true, false, true]。它保存了传入map方法的isEven函数的运行结果。这样就容易知道哪个元素是偶数了。比如，myMap[0]是false，因为1不是偶数。

filter方法，它返回的新数组是由isEven函数返回true的元素组成的。

const filterNumbers = arr.filter(isEven);
console.log(filterNumbers);
// [ 2, 4, 6, 8, 10 ]

相当于筛选了数组中被2整除的元素，但也是用于筛选数组中符合条件的元素。

reduce方法

reduce方法接收四个参数的函数：preVal(初始值)、currVal(当前元素)、index(当前索引)和array(当前元素所在的数组)。index和array是可选参数。这个函数返回一个将被叠加到累加器的值，reduce方法停止执行后会返回这个累加器。如果要对一个数组的所有元素求和，这个方法就很有用。

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

const myReduce = arr.reduce((preVal, currVal) => preVal + currVal);
console.log(myReduce); // 输出55

ES6添加的数组方法

@@iterator：返回一个包含数组键值对的迭代器对象，通过同步调用得到数组元素的键值对。
copyWithin：复制数组中一系列元素到同一个数组指定的起始位置。
entries：返回包含数组所有键值对的@@iterator。
includes：如果数组中存在某个元素则返回true，否则返回false。
find：根据回调函数给定的条件从数组中查找元素，如果找到则返回该元素。
findIndex：根据回调函数给定的条件从数组中查找元素，如果找到则返回该元素在数组中的索引。
fill：用静态值填充数组。
from：用于把类数组的对象和可遍历的对象转成真正的数组。
keys：返回包含数组所有索引的@@iterator。
of：根据传入的参数创建一个新数组。
values：返回包含数组中所有值的@@iterator。

for...of方法

ES6增加迭代数组的方法for...of循环，下面是它的用法。

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
for (let i of arr) {
  // n就是arr中的元素
  console.log(n % 2 === 0);
}

`@@iterator`对象

ES6还为Array增加了一个@@iterator属性，需要通过Symbol.iterator来访问。

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let iterator = arr[Symbol.iterator]();
console.log(iterator.next().value); // 1
console.log(iterator.next().value); // 2
console.log(iterator.next().value); // 3
console.log(iterator.next().value); // 4

然后，不断调用迭代器的next方法，就能依次得到数组中的值。arr数组中有10个值，那么就要调用10次。这显然不实际，但是可以使用for...of循环来输出这些值。

let iterator = arr[Symbol.iterator]();
for (const n of iterator) {
  console.log(n);
}

数组中的值被迭代完之后，再次调用iterator.next().value则会返回undefined。

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let iterator = arr[Symbol.iterator]();
for (const n of iterator) {
  console.log(n);
}
console.log(iterator.next().value); // undefined

数组的`entries`、`keys`和`values`方法

ES6还增加了三种从数组中得到迭代器的方法。

entries方法

let aEntries = arr.entries(); // 这里得到键值对的迭代器
console.log(aEntries.next().value); // [0, 1] 位置0的值为1
console.log(aEntries.next().value); // [1, 2] 位置1的值为2
console.log(aEntries.next().value); // [2, 3] 位置2的值为3

arr数组中都是数，key是数组中的位置，value是保存在数组索引的值。也可以使用for...of循环对aEntries进行迭代。

keys方法

key方法返回包含数组索引的@@iterator。

let aKeys = arr.keys(); // 得到数组索引的迭代器
console.log(aKeys.next()); // { value: 0, done: false }
console.log(aKeys.next()); // { value: 1, done: false }
console.log(aKeys.next()); // { value: 2, done: false }

keys方法会返回arr数组的索引。如果没有可迭代的值，aKeys.next()就返回一个value属性为undefined、done属性为true的对象。如果done属性的值为false，就说明还有可迭代的值。

values方法

values方法返回@@iterator则包含数组的值。

let aValues = arr.values();
console.log(aValues.next()); // { value: 1, done: false }
console.log(aValues.next()); // { value: 2, done: false }
console.log(aValues.next()); // { value: 3, done: false }

`form`方法

Array.form方法用于把可遍历的对象、类数组的对象转为真正的数组（包括Set和Map数据结构）。也可以根据已有的数组创建一个新的数组。比如，要复制arr数组。

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let arr2 = Array.from(arr);
console.log(arr2);
// [0, 2, 3, 4,  5, 6, 7, 8, 9, 10]

// 可遍历对象转数组
let obj = {
  0: "1",
  1: "2",
  2: "3",
  length: 3,
};
console.log(Array.from(obj));
// [ '1', '2', '3' ]

// 类数组的对象转为真正的数组，arguments就是类数组的对象
function args() {
  console.log(Array.from(arguments));
}

args(1, 2); // [ 1, 2 ]

还可以传入一个用来过滤值的函数，例子如下。

let evens = Array.from(arr, (x) => x % 2 === 0);
console.log(evens);
// [false, true, false, true, false, true, false, true, false, true]

上面的代码会创建一个evens数组，以及值true（在原数组中为偶数）或false（在原数组中为奇数）。

`Array.of`方法

Array.of方法根据传入的参数创建一个新数组。

let arr2 = Array.of(1);
let arr3 = Array.of(2, 3, 4, 5, 6, 7, 8);
console.log(arr2); // [ 1 ]
console.log(arr3); // [2, 3, 4, 5, 6, 7, 8]

也可以用这个方法复制已有的数组，如下。

let arrCopy = Array.of(...arr3);
console.log(arrCopy); // [2, 3, 4, 5, 6, 7, 8];

上面的代码和Array.form(arr3)的效果是一样的。

`fill`方法

fill方法用给定的值，填充一个数组。

let arrCopy = Array.of(1, 2, 3, 4, 5, 6);

arrCopy数组的length是6，证明有6个位置，再看下面的代码。

let arrCopy = Array.of(1, 2, 3, 4, 5, 6);
arrCopy.fill(0);
console.log(arrCopy);
// [ 0, 0, 0, 0, 0, 0 ]

arrCopy数组所有位置上的值都会变成0。还可以指定开始填充的索引，如下所示。

arrCopy.fill(2, 1);
console.log(arrCopy);
// [ 1, 2, 2, 2, 2, 2 ]

上面的例子，数组中从1开始的所有位置上的值都是2。

也可以指定结束填充的索引。

arrCopy.fill(1, 3, 5);
console.log(arrCopy);
// [ 1, 2, 3, 1, 1, 6 ]

上面的例子中，会把1填充到数组索引3到5的位置（不包括3和5）。

想创建数组并初始化值的时候，fill方法非常好用，像下面这样。

let ones = Array(6).fill(1);
console.log(ones); // [ 1, 1, 1, 1, 1, 1 ]

这里创建了一个长度为6、所有值都是1的数组。

`copyWithin`方法

copyWithin方法复制数组中的一系列元素到同一数组指定的位置。

let copyArray = [1, 2, 3, 4, 5, 6];

假设想把4、5、6三个值复制到数组前三个位置，得到[4, 5, 6, 4, 5, 6]这个数组，可以用下面的代码。

copyArray.copyWithin(0, 3);
console.log(copyArray);
// [ 4, 5, 6, 4, 5, 6 ]

假设想把4、5这个两个值（在位置3和4上）复制到位置1和2。可以这样做：

copyArray.copyWithin(1, 3, 5);
console.log(copyArray);
// [ 1, 4, 5, 4, 5, 6 ]

这种情况下，会把位置3开始到位置5结束（不包括3和5）的元素复制到位置1。

排序元素

下面展示最常用的搜索和排序方法。js也提供了一个排序方法和一组搜索方法。

首先是反序输出数组arr。要实现这样的功能，可以使用reverse方法，把数组内的元素反序。

arr.reverse();
console.log(arr);
// [10, 9, 8, 7, 6, 5, 4, 3, 2, 1];

现在就可以看到，输出arr之后得到的结果是[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]。

下面来看sort方法。

arr.sort();
console.log(arr);
// [1, 10, 2, 3, 4, 5, 6, 7, 8, 9];

然而，输出数组，结果是[1, 10, 2, 3, 4, 5, 6, 7, 8, 9]。看起来不太对劲，这是因为sort方法在对数组做排序时，把元素默认成字符串进行相互比较了。

可以传入自己写的比较函数。因为数组里都是数，可以像下面这样写。

arr.sort((a, b) => a - b);
console.log(arr);
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

在b大于a时，这段代码会返回负数，反之则返回正数。如果相等的话，就会返回0。也就是说返回的是负数，就说明a比b小，这样sort就能根据返回值的情况对数组进行排序了。

之前的代码也可以表示像下面这样。

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
arr.sort();
console.log(arr);
// [1, 10, 2, 3, 4, 5, 6, 7, 8, 9];
function compare(a, b) {
  if (a < b) {
    return -1;
  }
  if (a > b) {
    return 1;
  }
  // a等于b就返回0
  return 0;
}
arr.sort(compare);
console.log(arr);
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

这是因为js的sort方法接收compareFunction作为参数，然后sort会用它排序数组。在这个例子里，声明了一个用来比较数组元素的函数，使数组升序排序。

自定义排序

可以对任何对象类型的数组进行排序，也可以创建compareFunction来比较元素。例如，对象Person有名字和年龄属性，我们想根据年龄排序。

const friends = [
  { name: "xiaohong", age: 20 },
  { name: "xiaoming", age: 19 },
  { name: "xiaojia", age: 23 },
];

function compare(a, b) {
  if (a.age < b.age) {
    return -1;
  }

  if (a.age > b.age) {
    return 1;
  }
  return 0;
}

console.log(friends.sort(compare));
// [
//   { name: 'xiaoming', age: 19 },
//   { name: 'xiaohong', age: 20 },
//   { name: 'xiaojia', age: 23 }
// ]

在这个例子里，输出结果如上。

字符串排序

假如有这样一个数组。

let names = ["Ana", "ana", "john", "John"];

使用sort方法排序之后如下所示。

console.log(names.sort());
// [ 'Ana', 'John', 'ana', 'john' ]

既然a在字母表里排第一位，为何ana却排在了John之后呢？这是因为js在做字符比较的时候，是根据字符对应的一种叫做ASCII值来比较的。例如，A、J、a、j对应的ASCII值分别是65、74、97、106。

虽然a在字母表里是最靠前的，但J的ASCII值比a的小，所以排在了a前面。

如果给sort传入一个忽略大小写的比较函数，将输出["Ana", "ana", "John", "john"]。

let names = ["Ana", "ana", "john", "John"];
console.log(
  names.sort((a, b) => {
    if (a.toLowerCase() < b.toLowerCase()) {
      return -1;
    }
    if (a.toLowerCase() > b.toLowerCase()) {
      return 1;
    }
    return 0;
  })
);

在这种情况下，sort函数不会有任何作用。它会按照现在的大小写字母顺序排序。

如果希望小写字母排在前面，就需要使用localeCompare方法。

let names = ["Ana", "ana", "john", "John"];
names.sort((a, b) => a.localeCompare(b));
console.log(names);
// [ 'ana', 'Ana', 'john', 'John' ]

结果输出如上。

假如对带有重音符号的字符做排序的话，也可以用localeCompare来实现。

const name2 = ["Maève", "Maeve"];
console.log(name2.sort((a, b) => a.localeCompare(b)));
// [ 'Maeve', 'Maève' ]

最后结果输出如上。

搜索

搜索有两个方法：indexOf和lastIndexOf这两个方法，前者是返回与参数匹配的第一个元素的索引。后者则是返回与参数匹配的最后一个元素的索引，就用arr数组来做例子。

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(arr.indexOf(5)); // 4
console.log(arr.lastIndexOf(11)); // -1

可以看到上面的打印结果，第二行打印出了4，第三行打印出了-1（因为11并不在数组里面）。

`find`和`findIndex`方法

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

function multipleOf(ele, index, array) {
  return ele % 13 === 0;
}

console.log(arr.find(multipleOf)); // undefined
console.log(arr.findIndex(multipleOf)); // -1

find和findIndex方法接收一个回调函数，搜索一个满足回调函数条件的值。上面的例子中，要从数组里找一个13的倍数。

find和findIndex的不同之处在于，find方法返回第一个满足条件的值，而findIndex方法返回这个值在数组中的索引。如果没有满足条件的值，find返回undefined，而findIndex返回-1。

includes方法

includes方法是用于检测数组中是否包含某个元素，如果存在则返回true，否则返回false。

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

console.log(arr.includes(5)); // true
console.log(arr.includes(11)); // false

如果给includes方法传入一个起始索引，搜索就会从索引指定的位置开始。

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

console.log(arr.includes(4, 6)); // false

这里输出了false，是因为数组索引6之后都不包含元素4。

输出数组为字符串

如果想要把数组里所有的元素输出为一个字符串，可以使用toString和join这两个方法。

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(arr.toString()); // 1,2,3,4,5,6,7,8,9,10
console.log(arr.join()); // 1,2,3,4,5,6,7,8,9,10

如果想用一个不同的分隔符（例如-）把元素隔开，就可以用join方法。

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(arr.join("-")); // 1-2-3-4-5-6-7-8-9-10

join方法，我一般用在给后端传多个时间或者日期用得比较多点。

以上就是js数组中的方法。

结尾

如果哪里写得不对或者不好，欢迎各位大佬指点！也希望大家能给个赞。以后尽量每周写一篇文章，来提高自己的写作水平，同时把自己学的知识分享给大家。好累~~！从早上写到下午五点多。

JavaScript数据结构-数组 含数组方法