js基础：数组

zoukankan html css js c++ java

js基础：数组
数组

https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array

数组Array也是一个对象。

创建数组并赋值：
```
  var arr = new Array()
  arr[0] = 1
  arr[1] = 1
```
字面量创建数组
```
  var arr2 = [1,2,3]
  console.log(arr2)
```
数组中元素可以时任意数据类型
```
var arr3 = [1, 'a', true]
```
遍历数组：
```
  //回调函数
  //三个参数：当前元素、当前元素的索引、当前数组
  arr3.forEach( (t, num, arr)=>{
      console.log(t)
      console.log(num)
      console.log(arr)
  })
```
数组的静态方法

Array.from()

Array.from() 方法从一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例。

语法：
```
Array.from(arrayLike[, mapFn[, thisArg]])
```
参数：
- arrayLike
  
  想要转换成数组的伪数组对象或可迭代对象。（数组、Set、Map等）
- mapFn 可选
  
  如果指定了该参数，新数组中的每个元素会执行该回调函数。
- thisArg 可选
  
  可选参数，执行回调函数 mapFn 时 this 对象。
返回值：一个新的数组实例

示例：
```
  //从字符串生成数组
  console.log(Array.from('foo'));
  //从Set生成数组
  console.log(Array.from(new Set(['foo', 'bar', 'baz', 'foo'])));
  //从Map生成数组
  console.log(Array.from(new Map([[1, 2], [2, 4], [4, 8], [8, 4]])));
  //从数组生成数组
  console.log(Array.from([1,2,3,4]))
  //从类数组对象arguments生成数组
  function f() {
    return Array.from(arguments);
  }
  console.log(f(1, 2, 3));
  //指定回调函数
  console.log(Array.from([1, 2, 3], x => x + x))
```
运行结果：

第三个参数，map函数中this指向的对象：

该参数是非常有用的，我们可以将被处理的数据和处理对象分离，将各种不同的处理数据的方法封装到不同的的对象中去，处理方法采用相同的名字。

在调用Array.from对数据对象进行转换时，可以将不同的处理对象按实际情况进行注入，以得到不同的结果，适合解耦。
```
  let fun = {
    do: function(n){
      return n * 2
    }
  }
  console.log(Array.from([1, 2, 3, 4, 5], function (x){
     return this.do(x)
  },fun))
```
Array.isArray()

Array.isArray() 用于确定传递的值是否是一个 Array

语法：
```
Array.isArray(obj)
```
参数：
- obj 需要检测的值。
返回值:

如果值是 [Array]，则为true; 否则为false。

示例：
```
// 下面的函数调用都返回 true
Array.isArray([]);
Array.isArray([1]);
Array.isArray(new Array());
Array.isArray(new Array('a', 'b', 'c', 'd'))
// 鲜为人知的事实：其实 Array.prototype 也是一个数组。
Array.isArray(Array.prototype);

// 下面的函数调用都返回 false
Array.isArray();
Array.isArray({});
Array.isArray(null);
Array.isArray(undefined);
Array.isArray(17);
Array.isArray('Array');
Array.isArray(true);
Array.isArray(false);
Array.isArray(new Uint8Array(32))
Array.isArray({ __proto__: Array.prototype });
```
Array.of()

Array.of() 方法创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。

Array.of() 和 Array 构造函数之间的区别在于处理整数参数：Array.of(7) 创建一个具有单个元素 7 的数组，而 Array(7) 创建一个长度为7的空数组（注意：这是指一个有7个空位(empty)的数组，而不是由7个undefined组成的数组）。

语法：
```
Array.of(element0[, element1[, ...[, elementN]]])
```
返回值：一个新的数组实例

示例：
```
    console.log(Array.of(7));       // [7]
    console.log(Array.of(1, 2, 3)); // [1, 2, 3]
    console.log(Array.of(undefined)) //[undefined]

    console.log(Array(7));         // [ , , , , , , ]
    console.log(Array(1, 2, 3));    // [1, 2, 3]
```
length属性

length 是Array的实例属性。返回或设置一个数组中的元素个数。该值是一个无符号 32-bit 整数，并且总是大于数组最高项的下标。
```
  let arr = Array.of(1, 2, 3, 4, 5, 6);
  console.log(arr.length)  // 6
  // 可以设置 length 属性的值来截断任何数组
  arr.length = 4
  console.log(arr) //[1, 2, 3, 4]
  arr[4] = 5
  console.log(arr.length) // 5
  // 也可以改变length属性值来扩展数组
  arr.length = 8
  console.log(arr) // [1, 2, 3, 4, 5, , , ]
```
数组的方法

concat()

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

语法：
```
var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])
```
参数：valueN可选

数组和/或值，将被合并到一个新的数组中。如果省略了所有 valueN 参数，则 concat 会返回调用此方法的现存数组的一个浅拷贝。

concat方法不会改变this或任何作为参数提供的数组，而是返回一个浅拷贝，它包含与原始数组相结合的相同元素的副本。原始数组的元素将复制到新数组中，如下所示：
- 对象引用（而不是实际对象）：concat将对象引用复制到新数组中。原始数组和新数组都引用相同的对象。也就是说，如果引用的对象被修改，则更改对于新数组和原始数组都是可见的。这包括也是数组的数组参数的元素。
- 数据类型如字符串，数字和布尔（不是String，Number 和 Boolean对象）：concat将字符串和数字的值复制到新数组中。
示例：
```
    var alpha = ['a', 'b', 'c'];
    var numeric = [1, 2, 3];
    console.log(alpha.concat(numeric)); //['a', 'b', 'c', 1, 2, 3]

    //连接三个数组
    var num1 = [1, 2, 3],
        num2 = [4, 5, 6],
        num3 = [7, 8, 9];
    var nums = num1.concat(num2, num3); //[1, 2, 3, 4, 5, 6, 7, 8, 9]
    console.log(nums);
```
copyWithin()

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）。
示例：
```
  const array1 = ['a', 'b', 'c', 'd', 'e'];
  console.log(array1.copyWithin(0)); //['a', 'b', 'c', 'd', 'e']
  console.log(array1.copyWithin(0, 3, 4));//['d', 'b', 'c', 'd', 'e']
  console.log(array1.copyWithin(1, 3));//['d', 'd', 'e', 'd', 'e']
  console.log(array1.copyWithin(-2, -3, -1)) //['d', 'd', 'e', 'e', 'd']
```
entries()

entries() 方法返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对。

语法:
```
arr.entries()
```
返回值：

一个新的 Array 迭代器对象。Array Iterator是对象，它的原型（_proto_:Array Iterator）上有一个next方法，可用用于遍历迭代器取得原数组的[key,value]。

示例：
```
var arr = ["a", "b", "c"];
var iterator = arr.entries();
console.log(iterator);
//使用iterator.next
let next = iterator.next();
while (!next.done) {
    console.log(next.value)
    next =  iterator.next();
}
```
运行结果：

使用for…of 循环:
```
  for (const iter of iterator) {
    console.log(iter)
  }
```
every()

every() 方法测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值。

注意：若收到一个空数组，此方法在一切情况下都会返回 true。

语法：
```
arr.every(callback(element[, index[, array]])[, thisArg])
```
参数：
- callback
  
  用来测试每个元素的函数，它可以接收三个参数：
  
  element 用于测试的当前值。
  
  index可选用于测试的当前值的索引。
  
  array可选调用 every 的当前数组。
- thisArg
  
  执行 callback 时使用的 this 值。
示例：
```
    let func = {
        do: function(n){
            console.log(n)
            return n > 0
        }
    }

    let arr = [1, 3, 4, 5]
    let flag1 = arr.every(function (n) {
        return this.do(n)
    }, func);
    console.log(flag1); //true

    let arr2 = [1, 3, 4, -1, 5]
    let flag2 = arr2.every(function (n) {
        return this.do(n)
    }, func);
    console.log(flag2); //false
```
every 方法为数组中的每个元素执行一次 callback 函数，直到它找到一个会使 callback 返回 false 的元素。如果发现了一个这样的元素，every 方法将会立即返回 false。否则，callback 为每一个元素返回 true，every 就会返回 true。callback 只会为那些已经被赋值的索引调用。不会为那些被删除或从未被赋值的索引调用。

every 不会改变原数组。

every 遍历的元素范围在第一次调用 callback 之前就已确定了。在调用 every 之后添加到数组中的元素不会被 callback 访问到。如果数组中存在的元素被更改，则他们传入 callback 的值是 every 访问到他们那一刻的值。那些被删除的元素或从来未被赋值的元素将不会被访问到。

fill()

fill() 方法用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引。

语法：
```
arr.fill(value[, start[, end]])
```
参数：
- value
  
  用来填充数组元素的值。
- start 可选
  
  起始索引，默认值为0。
- end 可选
  
  终止索引，默认值为 this.length。
返回值：修改后的数组。

fill 方法接受三个参数 value, start 以及 end， start 和 end 参数是可选的, 其默认值分别为 0 和 this 对象的 length 属性值。

如果 start 是个负数, 则开始索引会被自动计算成为 length+start, 其中 length 是 this 对象的 length 属性值。如果 end 是个负数, 则结束索引会被自动计算成为 length+end。

当一个对象被传递给 fill方法的时候, 填充数组的是这个对象的引用。

示例：
```
  let arr = [1, 2, 3, 4, 5]

  arr.fill(100)
  console.log(arr)

  arr.fill(10, 2, 4)
  console.log(arr)
```
filter()

filter() 方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。

语法：
```
var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])
```
参数：
- callback用来测试数组的每个元素的函数。返回 true 表示该元素通过测试，保留该元素，false 则不保留。它接受以下三个参数：
  
  element 数组中当前正在处理的元素。
  
  index可选正在处理的元素在数组中的索引。
  
  array可选调用了 filter 的数组本身。
- thisArg可选
  
  执行 callback 时，用于 this 的值。
返回值：

一个新的、由通过测试的元素组成的数组，如果没有任何数组元素通过测试，则返回空数组。

filter 不会改变原数组，它返回过滤后的新数组。

filter 遍历的元素范围在第一次调用 callback 之前就已经确定了。在调用 filter 之后被添加到数组中的元素不会被 filter 遍历到。如果已经存在的元素被改变了，则他们传入 callback 的值是 filter 遍历到它们那一刻的值。被删除或从来未被赋值的元素不会被遍历到。

示例：
```
  let arr = [1, 2, 3, 4, 5]

  console.log(arr.filter(n => n % 2 === 0));
  console.log(arr)
```
find()、findIndex()

find() 方法返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。

语法：
```
arr.find(callback[, thisArg])
```
参数：
- callback
  
  在数组每一项上执行的函数，接收 3 个参数：
  
  element 当前遍历到的元素。
  
  index可选当前遍历到的索引。
  
  array可选数组本身。
- thisArg可选
  
  执行回调时用作this 的对象。
find方法不会改变数组。

在第一次调用 callback函数时会确定元素的索引范围，因此在 find方法开始执行之后添加到数组的新元素将不会被 callback函数访问到。如果数组中一个尚未被callback函数访问到的元素的值被callback函数所改变，那么当callback函数访问到它时，它的值是将是根据它在数组中的索引所访问到的当前值。被删除的元素仍旧会被访问到，但是其值已经是undefined了。

示例：
```
  let arr = [1, 2, 3, 4, 5]

  let ele = arr.find((n, i, ar) => n === 3)
  console.log(ele) //3
```
findIndex()方法返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回-1。具体用法与find()方法类似，这里不再介绍。

flat()

flat() 方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。

语法：
```
var newArray = arr.flat([depth])
```
参数：
- depth 可选
  
  指定要提取嵌套数组的结构深度，默认值为 1。
返回值：一个包含将数组与子数组中所有元素的新数组。

示例：
```
  let arr = [1, [2], [[3]], [[[4]]], [[5]]]

  console.log(arr.flat());
  console.log(arr.flat(2));
  console.log(arr.flat(3));
```
flat() 方法会移除数组中的空项.
```
console.log([1,,[2]].flat()) //[1,2]
```
map()、flatMap()

map() 方法创建一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值。

语法：
```
var new_array = arr.map(function callback(currentValue[, index[, array]]) {
 // Return element for new_array 
}[, thisArg])
```
返回值：一个由原数组每个元素执行回调函数的结果组成的新数组。

flatMap() 方法首先使用映射函数映射每个元素，然后将结果压缩成一个新数组。它与map连着深度值为1的flat几乎相同，但 flatMap 通常在合并成一种方法的效率稍微高一些。

语法：
```
var new_array = arr.flatMap(function callback(currentValue[, index[, array]]) {
    // return element for new_array
}[, thisArg])
```
参数：
- callback
  
  可以生成一个新数组中的元素的函数，可以传入三个参数：
  
  currentValue 当前正在数组中处理的元素
  
  index可选可选的。数组中正在处理的当前元素的索引。
  
  array可选可选的。被调用的 map 数组
- thisArg可选
  
  可选的。执行 callback 函数时使用的this 值。
返回值：一个新的数组，其中每个元素都是回调函数的结果，并且结构深度 depth 值为1。

示例：
```
    let arr = [1,2,3,4,5,6]
    console.log(arr.map(n => n * 2));
    console.log(arr.flatMap(n => n * 2));
    console.log(arr.flatMap(n => [n * 2]));
    console.log(arr.flatMap(n => [[n * 2]]));

    let arr1 = ["it's Sunny in", "", "California"];
    console.log(arr1.map(x => x.split(" ")));
    console.log(arr1.flatMap(x => x.split(" ")));
    console.log(arr1.flatMap(x => [x.split(" ")]));
```
forEach()

forEach() 方法对数组的每个元素执行一次给定的函数。

语法：
```
arr.forEach(callback(currentValue [, index [, array]])[, thisArg])
```
参数：
- callback
  
  为数组中每个元素执行的函数，该函数接收一至三个参数：
  
  currentValue 数组中正在处理的当前元素。
  
  index 可选数组中正在处理的当前元素的索引。
  
  array 可选 forEach() 方法正在操作的数组。
- thisArg 可选
  
  可选参数。当执行回调函数 callback 时，用作 this 的值。
forEach() 被调用时，不会改变原数组，也就是调用它的数组（尽管 callback 函数在被调用时可能会改变原数组）。（译注：此处说法可能不够明确，具体可参考EMCA语言规范：'forEach does not directly mutate the object on which it is called but the object may be mutated by the calls to callbackfn.'，即 forEach 不会直接改变调用它的对象，但是那个对象可能会被 callback 函数改变。）
注意： 除了抛出异常以外，没有办法中止或跳出 forEach() 循环。如果你需要中止或跳出循环，forEach() 方法不是应当使用的工具。

若你需要提前终止循环，你可以使用：

一个简单的for循环

for...of / for...in 循环

Array.prototype.every()

Array.prototype.some()

Array.prototype.find()

Array.prototype.findIndex()

这些数组方法则可以对数组元素判断，以便确定是否需要继续遍历：

every()

some()

find()

findIndex()

只要条件允许，也可以使用 filter() 提前过滤出需要遍历的部分，再用 forEach() 处理。
示例：
```
    let arr = [1,2,3,,5,6]

    arr.forEach((n) => {
        console.log(n)
    })

    console.table(arr)
```
includes()、indexOf()

includes() 方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回 false。使用 includes()比较字符串和字符时是区分大小写的。

语法：
```
arr.includes(valueToFind[, fromIndex])
```
参数：
- valueToFind
  
  需要查找的元素值。
- fromIndex 可选
  
  从fromIndex 索引处开始查找 valueToFind。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜（即使从末尾开始往前跳 fromIndex 的绝对值个索引，然后往后搜寻）。默认为 0。
  
  如果 fromIndex 大于等于数组的长度，则将直接返回 false，且不搜索该数组。
示例：
```
  [1, 2, 3].includes(2);     // true
  [1, 2, 3].includes(4);     // false
  [1, 2, 3].includes(3, 3);  // false
  [1, 2, 3].includes(3, -1); // true
  [1, 2, NaN].includes(NaN); // true
```
indexOf()方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。

语法：
```
arr.indexOf(searchElement[, fromIndex])
```
参数：
- searchElement
  
  要查找的元素
- fromIndex 可选
  
  开始查找的位置。如果该索引值大于或等于数组长度，意味着不会在数组里查找，返回-1。如果参数中提供的索引值是一个负值，则将其作为数组末尾的一个抵消，即-1表示从最后一个元素开始查找，-2表示从倒数第二个元素开始查找，以此类推。注意：如果参数中提供的索引值是一个负值，并不改变其查找顺序，查找顺序仍然是从前向后查询数组。如果抵消后的索引值仍小于0，则整个数组都将会被查询。其默认值为0.
```
  var array = [2, 5, 9];
  console.log(array.indexOf(2));     // 0
  console.log(array.indexOf(7));     // -1
  console.log(array.indexOf(9, 2));  // 2
  console.log(array.indexOf(2, -1)); // -1
  console.log(array.indexOf(2, -3)); // 0
```
join()

join() 方法将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。如果数组只有一个项目，那么将返回该项目而不使用分隔符。

语法：
```
arr.join([separator])
```
参数：

separator 可选

指定一个字符串来分隔数组的每个元素。如果需要，将分隔符转换为字符串。如果缺省该值，数组元素用逗号（,）分隔。如果separator是空字符串("")，则所有元素之间都没有任何字符。

返回值：一个所有数组元素连接的字符串。如果 arr.length 为0，则返回空字符串。
```
    var a = ['Wind', 'Rain', 'Fire'];
    var myVar1 = a.join();      // myVar1的值变为"Wind,Rain,Fire"
    var myVar2 = a.join(', ');  // myVar2的值变为"Wind, Rain, Fire"
    var myVar3 = a.join(' + '); // myVar3的值变为"Wind + Rain + Fire"
    var myVar4 = a.join('');    // myVar4的值变为"WindRainFire"

    console.log(myVar1)
    console.log(myVar2)
    console.log(myVar3)
    console.log(myVar4)
```
keys()

keys() 方法返回一个包含数组中每个索引键的Array Iterator对象。

语法：
```
arr.keys()
```
示例：
```
const array1 = ['a', 'b', 'c'];
const iterator = array1.keys();
console.log(typeof iterator)

for (const key of iterator) {
  console.log(key);
}

var arr = ["a", , "c"];
var sparseKeys = Object.keys(arr);
var denseKeys = [...arr.keys()];
console.log(sparseKeys); // ['0', '2']
console.log(denseKeys);  // [0, 1, 2]
```
lastIndexOf()

lastIndexOf() 方法返回指定元素（也即有效的 JavaScript 值或变量）在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找，从 fromIndex 处开始。

语法：
```
arr.lastIndexOf(searchElement[, fromIndex])
```
参数：

searchElement被查找的元素。

fromIndex 可选

从此位置开始逆向查找。默认为数组的长度减 1(arr.length - 1)，即整个数组都被查找。如果该值大于或等于数组的长度，则整个数组会被查找。如果为负值，将其视为从数组末尾向前的偏移。即使该值为负，数组仍然会被从后向前查找。如果该值为负时，其绝对值大于数组长度，则方法返回 -1，即数组不会被查找。

lastIndexOf 使用严格相等（strict equality，即 ===）比较 searchElement 和数组中的元素。

示例：
```
  var array = [2, 5, 9, 2];
  var index = array.lastIndexOf(2);
  // index is 3
  index = array.lastIndexOf(7);
  // index is -1
  index = array.lastIndexOf(2, 3);
  // index is 3
  index = array.lastIndexOf(2, 2);
  // index is 0
  index = array.lastIndexOf(2, -2);
  // index is 0
  index = array.lastIndexOf(2, -1);
  // index is 3
```
pop()、push()

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

当数组为空时返回undefined。

示例：
```
let myFish = ["angel", "clown", "mandarin", "surgeon"];
let popped = myFish.pop();
console.log(myFish);
console.log(popped);
```
push() 方法将一个或多个元素添加到数组的末尾，并返回该数组的新长度。

语法：
```
arr.push(element1, ..., elementN)
```
参数：
- elementN
  
  被添加到数组末尾的元素。
示例：
```
  var sports = ["soccer", "baseball"];
  var total = sports.push("football", "swimming", ["1", "2"]);
  console.log(sports);
  console.log(total);
```
reduce()、reduceRight()

reduce() 方法对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值。

语法：
```
arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])
```
参数：
- callback
  
  执行数组中每个值 (如果没有提供 initialValue则第一个值除外)的函数，包含四个参数：
  
  accumulator 累计器累计回调的返回值; 它是上一次调用回调时返回的累积值，或initialValue（见于下方）。
  
  currentValue 数组中正在处理的元素。
  
  index 可选数组中正在处理的当前元素的索引。如果提供了initialValue，则起始索引号为0，否则从索引1起始。
  
  array可选调用reduce()的数组
- initialValue可选
  
  作为第一次调用 callback函数时的第一个参数的值。如果没有提供初始值，则将使用数组中的第一个元素。在没有初始值的空数组上调用 reduce 将报错。
回调函数第一次执行时，accumulator 和currentValue的取值有两种情况：如果调用reduce()时提供了initialValue，accumulator取值为initialValue，currentValue取数组中的第一个值；如果没有提供 initialValue，那么accumulator取数组中的第一个值，currentValue取数组中的第二个值。

如果数组仅有一个元素（无论位置如何）并且没有提供initialValue，或者有提供initialValue但是数组为空，那么此唯一值将被返回并且callback不会被执行。

示例：
```
  var maxCallback = ( acc, cur ) => Math.max( acc.x, cur.x );
  console.log([{x:2},{x:22},{x:42}].reduce(maxCallback)); // NaN
  console.log([{x:2},{x:22}].reduce(maxCallback)) //22
  console.log([{x:2}].reduce( maxCallback ))// { x: 2 }
  console.log([1,2,3,4].reduce((x, y) => x+y)) //10
```
reduceRight() 方法接受一个函数作为累加器（accumulator）和数组的每个值（从右到左）将其减少为单个值。该方法与reduce()类似，这里不再过多介绍。

reverse()、shift()

reverse() 方法将数组中元素的位置颠倒，并返回该数组的引用。

示例：
```
console.log([1,2,3].reverse())//[3,2,1]
```
shift() 方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。

如果数组 length属性的值为 0 (长度为 0)，则返回 undefined。
```
console.log([1,2,3].shift()) //1
```
slice()

slice() 方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。原始数组不会被改变。

语法：
```
arr.slice([begin[, end]])
```
参数：
- begin 可选
  
  提取起始处的索引（从 0 开始），从该索引开始提取原数组元素。
  
  如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取，slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）。
  
  如果省略 begin，则 slice 从索引 0 开始。
  
  如果 begin 超出原数组的索引范围，则会返回空数组。
- end 可选
  
  提取终止处的索引（从 0 开始），在该索引处结束提取原数组元素。slice 会提取原数组中索引从 begin 到 end 的所有元素（包含 begin，但不包含 end）。
  
  slice(1,4) 会提取原数组中从第二个元素开始一直到第四个元素的所有元素（索引为 1, 2, 3的元素）。
  
  如果该参数为负数，则它表示在原数组中的倒数第几个元素结束抽取。 slice(-2,-1) 表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）。
  
  如果 end 被省略，则 slice 会一直提取到原数组末尾。
  
  如果 end 大于数组的长度，slice 也会一直提取到原数组末尾。
slice 不会修改原数组，只会返回一个浅复制了原数组中的元素的一个新数组。原数组的元素会按照下述规则拷贝：
- 如果该元素是个对象引用（不是实际的对象），slice 会拷贝这个对象引用到新的数组里。两个对象引用都引用了同一个对象。如果被引用的对象发生改变，则新的和原来的数组中的这个元素也会发生改变。
- 对于字符串、数字及布尔值来说（不是 String、Number 或者 Boolean 对象），slice 会拷贝这些值到新的数组里。在别的数组里修改这些字符串或数字或是布尔值，将不会影响另一个数组。
如果向两个数组任一中添加了新元素，则另一个不会受到影响。

示例：
```
  var fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'];
  console.log(fruits.slice(1, 3));
  console.log(fruits.slice(1, -1));
```
some()

some() 方法测试数组中是不是至少有1个元素通过了被提供的函数测试。它返回的是一个Boolean类型的值。

如果用一个空数组进行测试，在任何情况下它返回的都是false。

该方法参数与every()方法类似。

示例：
```
  const array = [1, 2, 3, 4, 5];
  const even = (element) => element % 2 === 0;
  console.log(array.some(even));//true
```
sort()

sort() 方法排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16代码单元值序列时构建的

语法：
```
arr.sort([compareFunction])
```
参数：
- compareFunction 可选
  
  用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序。
  
  firstEl 第一个用于比较的元素。
  
  secondEl 第二个用于比较的元素。
返回值：排序后的数组。请注意，数组已原地排序，并且不进行复制。

示例：
```
  let array = [1, 2, 11, 3, 4, 5];
  console.log(array.sort())
  console.log(array.sort((x, y) => x-y))

  //对象数组排序
  function Person(name, age) {
    this.name = name;
    this.age = age
  }
  let person1 = new Person("a", 12);
  let person2 = new Person("b", 11);
  let person3 = new Person("c", 13);
  let arr = [person1, person2, person3, person4]
  arr.sort((p1, p2) => p1.age - p2.age)
  console.log(arr)
```
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"]

//从索引 3 的位置开始删除 1 个元素
var myFish = ['angel', 'clown', 'drum', 'mandarin', 'sturgeon'];
var removed = myFish.splice(3, 1);
// 运算后的 myFish: ["angel", "clown", "drum", "sturgeon"]

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

//从索引 -2 的位置开始删除 1 个元素
var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
var removed = myFish.splice(-2, 1);
// 运算后的 myFish: ["angel", "clown", "sturgeon"]

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

unshift() 方法将一个或多个元素添加到数组的开头，并返回该数组的新长度(该方法修改原有数组)。

语法：
```
arr.unshift(element1, ..., elementN)
```
参数列表
- elementN
  
  要添加到数组开头的元素或多个元素。
返回值：当一个对象调用该方法时，返回其 length 属性值。

示例：
```
  let arr = [4,5,6];
  arr.unshift(1,2,3);
  console.log(arr); // [1, 2, 3, 4, 5, 6]

  arr = [4,5,6]; // 重置数组
  arr.unshift(1);
  arr.unshift(2);
  arr.unshift(3);
  console.log(arr); // [3, 2, 1, 4, 5, 6]
```
values()

values() 方法返回一个新的 Array Iterator 对象，该对象包含数组每个索引的值

示例：
```
let arr = ['w', 'y', 'k', 'o', 'p'];
let eArr = arr.values();

for (let letter of eArr) {
  console.log(letter);
} //"w" "y "k" "o" "p"
```
查看全文

相关阅读:
[C#]App.Config
[转][JS]修改链接中的参数
 [转][Oracle]常见报错及处理
 [转]截图软件分享
 [转][C#]手写 Socket 服务端
 3.6的pprint写法改变了：pprint.pprint()
版本优化-test
python爬取豆瓣小组700+话题加回复啦啦啦python open file with a variable name
爬豆瓣被封的解决方案
 去除列表中字符串中的空格换行等

原文地址：https://www.cnblogs.com/wwjj4811/p/15511904.html

数组

数组的静态方法

Array.from()

Array.isArray()

Array.of()

length属性

数组的方法

concat()

copyWithin()

entries()

every()

fill()

filter()

find()、findIndex()

flat()

map()、flatMap()

forEach()

includes()、indexOf()

join()

keys()

lastIndexOf()

pop()、push()

reduce()、reduceRight()

reverse()、shift()

slice()

some()

sort()

splice()

unshift()

values()