数组的方法总结

数组的方法

Array.from

• Array.from() 方法从一个类似数组或可迭代对象中创建一个新的数组实例。
• 语法
  • Array.from(arrayLike[, mapFn[, thisArg]])
• 参数
  • arrayLike:想要转换成数组的伪数组对象或可迭代对象。
  • mapFn (可选参数):如果指定了该参数，新数组中的每个元素会执行该回调函数。
  • thisArg (可选参数):可选参数，执行回调函数 mapFn 时 this 对象。
• 返回值
  • 一个新的数组实例

Array​.isArray()

• Array.isArray() 用于确定传递的值是否是一个 Array。
• 返回布尔值，是-->true 否-->false

Array.of()

• Array.of() 方法创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。
• Array.of() 和 Array 构造函数之间的区别在于处理整数参数：Array.of(7) 创建一个具有单个元素 7 的数组，而 Array(7) 创建一个长度为7的空数组（注意：这是指一个有7个空位(empty)的数组，而不是由7个undefined组成的数组）。
• 示例
  • Array.of(1); // [1]
  • Array.of(1, 2, 3); // [1, 2, 3]
  • Array.of(undefined); // [undefined]

Array​.prototype​.forEach()

• forEach() 方法对数组的每个元素执行一次提供的函数。
• 参数1:callback 为数组中每个元素执行的函数，该函数接收三个参数：
  • currentValue(当前值):数组中正在处理的当前元素。
  • index(索引):数组中正在处理的当前元素的索引。
  • array:forEach()方法正在操作的数组。
• 参数2:thisArg 可选参数。当执行回调 函数时用作this的值
• 返回值：undefined
• 是否影响老数组：由callback决定
• 简而言之就是遍历数组

Array​.prototype​.push()

• push() 方法将一个或多个元素添加到数组的末尾，并返回新数组的长度

• 语法：arr.push(element1, ..., elementN)

• 参数:被添加到数组末尾的元素

• 返回值：当调用该方法时，新的 length 属性值将被返回

• 是否影响老数组：影响

    var arr =[1,2,3,4];
    var res = arr.push("5",true,{})
    console.log(arr,res)//[1,2,3,4,"5",true,{}]
  复制代码

Array​.prototype​.map()

• map() 方法创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果
• 参数1:callback 为数组中每个元素执行的函数，该函数接收三个参数：
  • currentValue(当前值):数组中正在处理的当前元素。
  • index(索引):数组中正在处理的当前元素的索引。
  • array:forEach()方法正在操作的数组。
• 参数2:thisArg 可选参数。当执行回调 函数时用作this的值。
• 返回值：一个新数组，每个元素都是回调函数的结果。
• 是否影响老数组：不影响

Array​.prototype​.pop()

• pop()方法从数组中删除最后一个元素，并返回该元素的值。此方法更改数组的长度

• 语法：arr.pop()

• 参数：无

• 返回值：从数组中删除的元素(当数组为空时返回undefined)

• 是否影响老数组：影响

    var arr =[1,2,3,"abc"];
    var result = arr.pop();
    console.log(result,arr);//[1,2,3]
  复制代码

Array​.prototype​.every()

• every() 方法测试数组的所有元素是否都通过了指定函数的测试
• 参数1:callback 为数组中每个元素执行的函数，该函数接收三个参数：
  • currentValue(当前值):数组中正在处理的当前元素。
  • index(索引):数组中正在处理的当前元素的索引。
  • array:forEach()方法正在操作的数组。
• 参数2:thisArg
  • 可选参数。当执行回调 函数时用作this的值。
• 返回值：true false
• 是否影响老数组：不影响

Array​.prototype​.sort()

• sort() 方法使用in-place算法对数组的元素进行排序，并返回数组。 默认排序顺序是根据字符串Unicode码点。
• sort()参数compareFunction 可选。 用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序。
• 返回值：返回排序后的数组。
• 是否影响老数组： 影响 原数组已经被排序后的数组代替。

Array​.prototype​.join()

• join() 方法将一个数组的所有元素连接成一个字符串并返回这个字符串
• 语法：arr.join(separator)
• 参数：separator ---> 指定一个字符串来分隔数组的每个元素。如果省略()，数组元素用逗号分隔。默认为 ","。
• 返回值：一个所有数组元素连接的字符串。如果 arr.length 为0，则返回空字符串
• 是否影响老数组：不影响

•   var arr =[1,2,1,4];
    var result = arr.join("damu");
    console.log(result,arr);//1damu2damu1damu4,[1,2,1,4]
  复制代码

Array​.prototype​.reverse()

• reverse() 方法颠倒数组中元素的位置，并返回该数组的引用
• 语法： arr.reverse()
• 参数：无
• 返回值：该数组的引用。
• 是否影响老数组：影响

Array​.prototype​.reduce()

• reduce() 方法对累加器和数组中的每个元素（从左到右）应用一个函数，将其减少为单个值。
• 参数1:callback 为数组中每个元素执行的函数，该函数接收三个参数：
  • accumulator(当前值):累加器累加回调的返回值; 它是上一次调用回调时返回的累积值
  • currentValue:数组中正在处理的元素。
  • currentIndex可选:数组中正在处理的当前元素的索引。 如果提供了initialValue，则索引号为0，否则为索引为1。
  • array可选：调用reduce的数组。
• 参数2:initialValue 用作第一个调用 callback的第一个参数的值。 如果没有提供初始值，则将使用数组中的第一个元素。 在没有初始值的空数组上调用 reduce 将报错。
• 返回值： 累加器
• 是否影响老数组：不影响 //数组里所有值的和 var arr =[2, 1, 2, 3]; var sum = arr.reduce(function (a,b,index,arr) { console.log(a) return a + b; },0); console.log(sum);//7 console.log(arr);[2, 1, 2, 3]

Array​.prototype​.toString()

• toString() 返回一个字符串，表示指定的数组及其元素。

• 语法：arr.toString()

• 参数：无

• 返回值：返回一个字符串。

• 是否影响老数组：不影响

    var arr =[1,2,3,4];
    var result = arr.toString();
    console.log(result,arr);//1234,[1,2,3,4]
  复制代码

Array​.prototype​.concat()

• concat() 方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。

• 描述

  • concat方法创建一个新的数组，它由被调用的对象中的元素组成，每个参数的顺序依次是该参数的元素（如果参数是数组）或参数本身（如果参数不是数组）。它不会递归到嵌套数组参数中。

• concat方法不会改变this或任何作为参数提供的数组，而是返回一个浅拷贝，它包含与原始数组相结合的相同元素的副本。 原始数组的元素将复制到新数组中，如下所示：

• 对象引用（而不是实际对象）：

  • concat将对象引用复制到新数组中。 原始数组和新数组都引用相同的对象。 也就是说，如果引用的对象被修改，则更改对于新数组和原始数组都是可见的。 这包括也是数组的数组参数的元素。
  • 数据类型如字符串，数字和布尔（不是String，Number 和 Boolean 对象）：concat将字符串和数字的值复制到新数组中。

• 两个数组合并

var numeric = [1, 2, 3];
alpha.concat(numeric);
复制代码

• 三个或多个数组合并

var num1 = [1, 2, 3],
    num2 = [4, 5, 6],
    num3 = [7, 8, 9];
var nums = num1.concat(num2, num3);
复制代码

Array​.prototype​.copy​Within()

• copyWithin() 方法浅复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组的长度。
• 语法
  • arr.copyWithin(target[, start[, end]])
• 参数
  • target:0 为基底的索引，复制序列到该位置。如果是负数，target 将从末尾开始计算。 如果 target 大于等于 arr.length，将会不发生拷贝。如果 target 在 start 之后，复制的序列将被修改以符合 arr.length。
  • start:0 为基底的索引，开始复制元素的起始位置。如果是负数，start 将从末尾开始计算。 如果 start 被忽略，copyWithin 将会从0开始复制。
  • end: 0 为基底的索引，开始复制元素的结束位置。copyWithin 将会拷贝到该位置，但不包括 end 这个位置的元素。如果是负数， end 将从末尾开始计算。 如果 end 被忽略，copyWithin 方法将会一直复制至数组结尾（默认为 arr.length）。
• 返回值:改变后的数组。

Array​.prototype​.fill()

• fill() 方法用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引。
• 语法
  • arr.fill(value, start, end)
• 参数
  • value:用来填充数组元素的值。
  • start 可选:起始索引，默认值为0。
  • end 可选:终止索引，默认值为 this.length。
• 返回值：修改后的数组

Array​.prototype​.every()

• every() 方法测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值。
• 注意：若收到一个空数组，此方法在一切情况下都会返回 true。
• 案例：
  • 检测所有数组元素的大小节
  • 下例检测数组中的所有元素是否都大于 10。

  return element >= 10;
}```
复制代码

[12, 5, 8, 130, 44].every(isBigEnough); // false

复制代码

[12, 54, 18, 130, 44].every(isBigEnough); // true

#### Array​.prototype​.find()
* find() 方法返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。
* 语法
	* arr.find(callback, thisArg)
* 参数
	* callback:在数组每一项上执行的函数，接收 3 个参数：
	* element:当前遍历到的元素。
	* index可选:当前遍历到的索引。
	* array可选：数组本身。
	* thisArg可选：执行回调时用作this 的对象。
* 返回值：数组中第一个满足所提供测试函数的元素的值，否则返回 undefined。
* 案例
* 
```var array1 = [5, 12, 8, 130, 44];
复制代码

  return element > 10;
});
复制代码

console.log(found);
// expected output: 12
复制代码

Array​.prototype​.find​Index()

• findIndex()方法返回数组中满足提供的测试函数的第一个元素的索引。否则返回-1。
• 用法与find()方法一样只是返回值不同

Array​.prototype​.indexOf()

• indexOf()方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。
• 语法：arr.indexOf(searchElement, fromIndex = 0)
• 参数：
  • searchElement被查找的元素。
  • fromIndex：从此位置开始逆向查找。默认为数组的长度减 1，即整个数组都被查找。如果该值大于或等于数组的长度，则整个数组会被查找。如果为负值，将其视为从数组末尾向前的偏移。即使该值为负，数组仍然会被从后向前查找。如果该值为负时，其绝对值大于数组长度，则方法返回 -1，即数组不会被查找。
• 返回值：数组中第一个符合条件的元素的索引，如未找到返回-1
• 案例

• 复制代码

```console.log(animals.indexOf('Dodo'));
// expected output: 1
复制代码

console.log(animals.indexOf('Tiger'));
// expected output: 1```

#### Array​.prototype​.last​IndexOf()
* lastIndexOf() 方法返回指定元素（也即有效的 JavaScript 值或变量）在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找，从 fromIndex 处开始。
* 语法：arr.lastIndexOf(searchElement[, fromIndex = arr.length - 1])
* 参数：
	* searchElement被查找的元素。
	* fromIndex：从此位置开始逆向查找。默认为数组的长度减 1，即整个数组都被查找。如果该值大于或等于数组的长度，则整个数组会被查找。如果为负值，将其视为从数组末尾向前的偏移。即使该值为负，数组仍然会被从后向前查找。如果该值为负时，其绝对值大于数组长度，则方法返回 -1，即数组不会被查找。
* 返回值：数组中最后一个元素的索引，如未找到返回-1
* 案例
* ```var animals = ['Dodo', 'Tiger', 'Penguin', 'Dodo'];
复制代码

// expected output: 3
复制代码

console.log(animals.lastIndexOf('Tiger'));
// expected output: 1```
#### Array​.prototype​.splice()
* splice() 方法通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容。此方法会改变原数组。
* 语法：array.splice(start, deleteCount, item1, item2, ...)
* 参数
	* start：指定修改的开始位置（从0计数）。如果超出了数组的长度，则从数组末尾开始添加内容；如果是负值，则表示从数组末位开始的第几位（从-1计数，这意味着-n是倒数第n个元素并且等价于array.length-n）；如果负数的绝对值大于数组的长度，则表示开始位置为第0位。
	* deleteCount 可选：整数，表示要移除的数组元素的个数。
如果 deleteCount 大于 start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）。
如果 deleteCount 被省略了，或者它的值大于等于array.length - start(也就是说，如果它大于或者等于start之后的所有元素的数量)，那么start之后数组的所有元素都会被删除。
如果 deleteCount 是 0 或者负数，则不移除元素。这种情况下，至少应添加一个新元素。
	* item1, item2, ... 可选：要添加进数组的元素,从start 位置开始。如果不指定，则 splice() 将只删除数组元素。
* 返回值：由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组。
* 案例
	* 从第 2 位开始删除 0 个元素，插入“drum”节
```var myFish = ["angel", "clown", "mandarin", "sturgeon"];```
```var removed = myFish.splice(2, 0, "drum");```
```// 运算后的 myFish: ["angel", "clown", "drum", "mandarin", "sturgeon"]
// 被删除的元素: [], 没有元素被删除```
	* 从第 2 位开始删除 0 个元素，插入“drum” 和 "guitar"节
```var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];```
```var removed = myFish.splice(2, 0, 'drum', 'guitar');```
```// 运算后的 myFish: ["angel", "clown", "drum", "guitar", "mandarin", "sturgeon"]```
```// 被删除的元素: [], 没有元素被删除```
	* 从第 3 位开始删除 1 个元素节
```var myFish = ['angel', 'clown', 'drum', 'mandarin', 'sturgeon'];```
```var removed = myFish.splice(3, 1);```
复制代码

// 运算后的 myFish: ["angel", "clown", "drum", "sturgeon"] // 被删除的元素: ["mandarin"]* 从第 2 位开始删除 1 个元素，插入“trumpet”节var myFish = ['angel', 'clown', 'drum', 'sturgeon'];var removed = myFish.splice(2, 1, "trumpet");```

// 运算后的 myFish: ["angel", "clown", "trumpet", "sturgeon"]
// 被删除的元素: ["drum"]```
	* 从第 0 位开始删除 2 个元素，插入"parrot"、"anemone"和"blue"节
```var myFish = ['angel', 'clown', 'trumpet', 'sturgeon'];```
```var removed = myFish.splice(0, 2, 'parrot', 'anemone', 'blue');```
复制代码

// 运算后的 myFish: ["parrot", "anemone", "blue", "trumpet", "sturgeon"] // 被删除的元素: ["angel", "clown"]* 从第 2 位开始删除 2 个元素节var myFish = ['parrot', 'anemone', 'blue', 'trumpet', 'sturgeon'];var removed = myFish.splice(myFish.length - 3, 2);```

// 运算后的 myFish: ["parrot", "anemone", "sturgeon"]
// 被删除的元素: ["blue", "trumpet"]```
	* 从倒数第 2 位开始删除 1 个元素节
	```var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];```
```var removed = myFish.splice(-2, 1);```
复制代码

// 运算后的 myFish: ["angel", "clown", "sturgeon"] // 被删除的元素: ["mandarin"]* 从第 2 位开始删除所有元素节var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];var removed = myFish.splice(2);```

// 运算后的 myFish: ["angel", "clown"]
// 被删除的元素: ["mandarin", "sturgeon"]```
#### Array​.prototype​.shift()
* shift() 方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。
* 返回值:从数组中删除的元素; 如果数组为空则返回undefined 。 
* 案例
	* ```var array1 = [1, 2, 3];```
复制代码

var firstElement = array1.shift();

```console.log(array1);```
```// expected output: Array [2, 3]```
复制代码

console.log(firstElement); // expected output: 1 ```

Array​.prototype​.unshift()

• unshift() 方法将一个或多个元素添加到数组的开头，并返回新数组的长度

• 语法：arr.unshift(element1, ..., elementN)

• 参数：要添加到数组开头的元素

• 返回值：当一个对象调用该方法时，返回其 新的length 属性值

• 是否影响老数组：影响

    var arr =[1,2,3,4];
    var result = arr.unshift(0,-9);
    console.log(result,arr);//[1,2,3,4,0,-9]
  复制代码

Array​.prototype.entries()

• entries() 方法返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对。
• 语法
  • arr.entries()
• 返回值: 一个新的 Array 迭代器对象。Array Iterator是对象，它的原型（proto:Array Iterator）上有一个next方法，可用用于遍历迭代器取得原数组的[key,value]。

转载于:https://juejin.im/post/5cebd200f265da1b6f4353d0