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];
复制代码

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

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

假设想把四、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值分别是6五、7四、9七、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数组中的方法。

结尾

若是哪里写得不对或者很差，欢迎各位大佬指点！也但愿你们能给个赞。之后尽可能每周写一篇文章，来提升本身的写做水平，同时把本身学的知识分享给你们。好累~~！从早上写到下午五点多。