JavaScript Array 方法 事件

Array

对数组的内置支持    (Object -> Array)

构造函数：

• new Array()
• new Array(size)
• new Array(element0, element1, ···, elementn)

属性：

• Array.length
  返回或设置一个数组中的元素个数。
• Array.prototype
  表示 Array 构造函数的原型，并允许您向所有Array对象添加新的属性和方法。
• Array.prototype[@@unscopables]

方法

• Array.from()

  从一个类似数组或可迭代对象中创建一个新的，浅拷贝的数组实例。

  语法

  Array.from(arrayLike[, mapFn[, thisArg]])

  例子

  console.log(Array.from('foo'));
  // expected output: Array ["f", "o", "o"]
  
  console.log(Array.from([1, 2, 3], x => x + x));
  // expected output: Array [2, 4, 6]
  

• Array.isArray()

  用于确定传递的值是否是一个 Array。

  语法

  Array.isArray(obj)

  Array.isArray([1, 2, 3]);  
  // true
  Array.isArray({foo: 123}); 
  // false
  Array.isArray("foobar");   
  // false
  Array.isArray(undefined);  
  // false
  

• Array.observe() (已废弃)

• Array.of()

  创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。

  语法

  Array.of(element0[, element1[, ...[, elementN]]])

  示例

  Array.of(1);         // [1]
  Array.of(1, 2, 3);   // [1, 2, 3]
  Array.of(undefined); // [undefined]
  

• Array.prototype.concat()

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

  语法

  var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])

  示例

  var num1 = [1, 2, 3],
      num2 = [4, 5, 6],
      num3 = [7, 8, 9];
  
  var nums = num1.concat(num2, num3);
  
  console.log(nums); 
  // results in [1, 2, 3, 4, 5, 6, 7, 8, 9]
  

• Array.prototype.copyWithin()

  浅复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组的长度。

  语法

  arr.copyWithin(target[, start[, end]])

  示例

  var array1 = ['a', 'b', 'c', 'd', 'e'];
  
  console.log(array1.copyWithin(0, 3, 4));
  // Array ["d", "b", "c", "d", "e"]
  
  console.log(array1.copyWithin(1, 3));
  // Array ["d", "d", "e", "d", "e"]
  

• Array.prototype.entries()

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

  语法

  arr.entries()

  示例

  var array1 = ['a', 'b', 'c'];
  var iterator1 = array1.entries();
  console.log(iterator1.next().value); // Array [0, "a"]
  console.log(iterator1.next().value); // Array [1, "b"]
  

• Array.prototype.every()

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

  语法:

  arr.every(callback[, thisArg])

  参数

    callback
    用来测试每个元素的函数，它可以接收三个参数：
        element
        用于测试的当前值。
        
        index 可选
        用于测试的当前值的索引。
        
        array 可选
        调用 every 的当前数组。
        
    thisArg
    执行 callback 时使用的 this 值。
  

  返回值

  若收到一个空数组，此方法在一切情况下都会返回 true。 一个新的、由通过测试的元素组成的数组，如果没有任何数组元素通过测试，则返回空数组。

  示例

  // 下例检测数组中的所有元素是否都大于 10
  
  function isBigEnough(element, index, array) {
      return element >= 10;
  }
  [12, 5, 8, 130, 44].every(isBigEnough);   // false
  [12, 54, 18, 130, 44].every(isBigEnough); // true
  

• Array.prototype.fill()

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

  语法

  arr.fill(value[, start[, end]])

  示例

  [1, 2, 3].fill(4);               // [4, 4, 4]
  [1, 2, 3].fill(4, 1);            // [1, 4, 4]
  [1, 2, 3].fill(4, 1, 2);         // [1, 4, 3]
  [1, 2, 3].fill(4, 1, 1);         // [1, 2, 3]
  [1, 2, 3].fill(4, 3, 3);         // [1, 2, 3]
  [1, 2, 3].fill(4, -3, -2);       // [4, 2, 3]
  [1, 2, 3].fill(4, NaN, NaN);     // [1, 2, 3]
  [1, 2, 3].fill(4, 3, 5);         // [1, 2, 3]
  Array(3).fill(4);                // [4, 4, 4]
  [].fill.call({ length: 3 }, 4);  // {0: 4, 1: 4, 2: 4, length: 3}
  
  // Objects by reference.
  var arr = Array(3).fill({}) // [{}, {}, {}];
  arr[0].hi = "hi"; // [{ hi: "hi" }, { hi: "hi" }, { hi: "hi" }]
  

• Array.prototype.filter()

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

  语法

  var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])

  参数

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

  返回值

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

  示例

  下例使用 filter 创建了一个新数组，该数组的元素由原数组中值大于 10 的元素组成
  
  function isBigEnough(element) {
    return element >= 10;
  }
  var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
  // filtered is [12, 130, 44]
  

• Array.prototype.find()

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

  语法

  arr.find(callback[, thisArg])

  参数

    callback
    在数组每一项上执行的函数，接收 3 个参数：
        element
        当前遍历到的元素。
        
        index可选
        当前遍历到的索引。
        
        array可选
        数组本身。
        
    thisArg可选
    执行回调时用作this 的对象。
  

  返回值

  数组中第一个满足所提供测试函数的元素的值，否则返回 undefined

  示例

  // 用对象的属性查找数组里的对象
  
    var inventory = [
      {name: 'apples', quantity: 2},
      {name: 'bananas', quantity: 0},
      {name: 'cherries', quantity: 5}
  ]
  
  function findCherries(fruit) { 
      return fruit.name === 'cherries';
  }
  
  console.log(inventory.find(findCherries)); // { name: 'cherries', quantity: 5 }
  

• Array.prototype.findIndex()

  返回数组中满足提供的测试函数的第一个元素的索引。否则返回-1。

  语法

  arr.findIndex(callback[, thisArg])

  参数

    callback
    在数组每一项上执行的函数，接收 3 个参数：
        element
        当前遍历到的元素。
        
        index可选
        当前遍历到的索引。
        
        array可选
        数组本身。
        
    thisArg可选
    执行回调时用作this 的对象。
  

  返回值

  数组中通过提供测试函数的第一个元素的索引。否则，返回-1

  示例

  //以下示例查找数组中素数的元素的索引（如果不存在素数，则返回-1）
  
  function isPrime(element, index, array) {
  var start = 2;
  while (start <= Math.sqrt(element)) {
  if (element % start++ < 1) {
    return false;
  }
  }
  return element > 1;
  }
  
  console.log([4, 6, 8, 12].findIndex(isPrime)); // -1, not found
  console.log([4, 6, 7, 12].findIndex(isPrime)); // 2
  

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

  语法

  var newArray = arr.flat([depth])

  参数

    depth 可选
    指定要提取嵌套数组的结构深度，默认值为 1。
  

  返回值

  一个包含将数组与子数组中所有元素的新数组。

  示例

  // 扁平化嵌套数组
  var arr1 = [1, 2, [3, 4]];
  arr1.flat(); 
  // [1, 2, 3, 4]
  
  var arr2 = [1, 2, [3, 4, [5, 6]]];
  arr2.flat();
  // [1, 2, 3, 4, [5, 6]]
  
  var arr3 = [1, 2, [3, 4, [5, 6]]];
  arr3.flat(2);
  // [1, 2, 3, 4, 5, 6]
  
  //使用 Infinity 作为深度，展开任意深度的嵌套数组
  arr3.flat(Infinity); 
  // [1, 2, 3, 4, 5, 6]
  
  //扁平化与空项
  var arr4 = [1, 2, , 4, 5];
  arr4.flat();
  // [1, 2, 4, 5]
  

• Array.prototype.flatMap()

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

  语法

  var new_array = arr.flatMap(function callback(currentValue[, index[, array]]) { // 返回新数组的元素 }[, thisArg])

  参数

    callback
    可以生成一个新数组中的元素的函数，可以传入三个参数：
        currentValue
        当前正在数组中处理的元素
  
        index可选
        可选的。数组中正在处理的当前元素的索引
    array可选
    可选的。被调用的 map 数组
    
    thisArg可选
    可选的。执行 callback 函数时 使用的this 值。
  

  示例

  // Map 与 flatMap
  var arr1 = [1, 2, 3, 4];
  arr1.map(x => [x * 2]); // [[2], [4], [6], [8]]
  arr1.flatMap(x => [x * 2]); // [2, 4, 6, 8]
  
  // 只会将 flatMap 中的函数返回的数组 “压平” 一层
  arr1.flatMap(x => [[x * 2]]); // [[2], [4], [6], [8]]
  
  
  let arr = ["今天天气不错", "", "早上好"]
  arr.map(s => s.split(""))
  // [["今", "天", "天", "气", "不", "错"],[],["早", "上", "好"]]
  arr.flatMap(s => s.split(''));
  // ["今", "天", "天", "气", "不", "错", "早", "上", "好"]
  
  
  **********等价操作***********
  
  // 归纳（reduce） 与 合并（concat）
  var arr1 = [1, 2, 3, 4];
  arr1.flatMap(x => [x * 2]);
  // 等价于
  arr1.reduce((acc, x) => acc.concat([x * 2]), []);
  // [2, 4, 6, 8]
  
  

• Array.prototype.forEach()

  对数组的每个元素执行一次提供的函数

  语法

  arr.forEach(callback[, thisArg]);

  参数

    callback
    为数组中每个元素执行的函数，该函数接收三个参数：
        currentValue
        数组中正在处理的当前元素。
        
        index可选
        数组中正在处理的当前元素的索引。
        
        array可选
        forEach() 方法正在操作的数组。
        
    thisArg可选
    可选参数。当执行回调函数时用作 this 的值(参考对象)。
  

  示例

  // for 循环转换为 forEach
  const items = ['item1', 'item2', 'item3'];
  const copy = [];
  
  // before
  for (let i=0; i<items.length; i++) {
    copy.push(items[i]);
  }
  
  // after
  items.forEach(function(item){
    copy.push(item);
  });
  
  

• Array.prototype.includes()

  用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回false。

  语法

  arr.includes(valueToFind[, fromIndex])

  示例

  [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
  
  // fromIndex 大于等于数组长度
  var arr = ['a', 'b', 'c'];
  arr.includes('c', 3);   // false
  arr.includes('c', 100); // false
  
  // 作为通用方法的 includes()
  (function() {
    console.log([].includes.call(arguments, 'a')); // true
    console.log([].includes.call(arguments, 'd')); // false
  })('a','b','c');
  

• Array.prototype.indexOf()

  返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1

  语法

  arr.indexOf(searchElement)
  arr.indexOf(searchElement[, fromIndex = 0])
  

  参数

    searchElement
    要查找的元素
    fromIndex
    开始查找的位置。
  

  返回值

  首个被找到的元素在数组中的索引位置; 若没有找到则返回 -1

  示例

  // 以下例子使用indexOf方法确定多个值在数组中的位置。
  var array = [2, 5, 9];
  array.indexOf(2);     // 0
  array.indexOf(7);     // -1
  array.indexOf(9, 2);  // 2
  array.indexOf(2, -1); // -1
  array.indexOf(2, -3); // 0
  
  // 找出指定元素出现的所有位置
  var indices = [];
  var array = ['a', 'b', 'a', 'c', 'a', 'd'];
  var element = 'a';
  var idx = array.indexOf(element);
  while (idx != -1) {
    indices.push(idx);
    idx = array.indexOf(element, idx + 1);
  }
  console.log(indices);
  // [0, 2, 4]
  
  // 判断一个元素是否在数组里，不在则更新数组
  function updateVegetablesCollection (veggies, veggie) {
      if (veggies.indexOf(veggie) === -1) {
          veggies.push(veggie);
          console.log('New veggies collection is : ' + veggies);
      } else if (veggies.indexOf(veggie) > -1) {
          console.log(veggie + ' already exists in the veggies collection.');
      }
  }
  
  var veggies = ['potato', 'tomato', 'chillies', 'green-pepper'];
  
  // New veggies collection is : potato,tomato,chillies,green-papper,spinach
  updateVegetablesCollection(veggies, 'spinach'); 
  // spinach already exists in the veggies collection.
  updateVegetablesCollection(veggies, 'spinach');
  

• Array.prototype.join()

  将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。如果数组只有一个项目，那么将返回该项目而不使用分隔符。 如果一个元素为 undefined 或 null，它会被转换为空字符串。

  语法

  arr.join([separator])

  参数

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

  返回值

  一个所有数组元素连接的字符串。如果 arr.length 为0，则返回空字符串

  示例

  // 使用四种不同的分隔符连接数组元素
  var a = ['Wind', 'Rain', 'Fire'];
  var myVar1 = a.join();      // "Wind,Rain,Fire"
  var myVar2 = a.join(', ');  // "Wind, Rain, Fire"
  var myVar3 = a.join(' + '); // "Wind + Rain + Fire"
  var myVar4 = a.join('');    // "WindRainFire"
  
  // 连接类数组对象
  function f(a, b, c) {
    var s = Array.prototype.join.call(arguments);
    console.log(s); // '1,a,true'
  }
  f(1, 'a', true);
  

• Array.prototype.keys()

  返回一个包含数组中每个索引键的Array Iterator对象。

  语法

  arr.keys()

  返回值

  一个新的 Array 迭代器对象。

  示例

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

• Array.prototype.lastIndexOf()

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

  语法

  arr.lastIndexOf(searchElement[, fromIndex = arr.length - 1])

  参数

    searchElement
    被查找的元素。
    fromIndex
    从此位置开始逆向查找。默认为数组的长度减 1，即整个数组都被查找。
  

  返回值

  数组中最后一个元素的索引，如未找到返回-1

  示例

  // 下例使用 lastIndexOf 定位数组中的值。
  
  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
  
  // 查找到一个元素在数组中所有的索引（下标），并使用 push 将所有添加到另一个数组中。
  
  var indices = [];
  var array = ['a', 'b', 'a', 'c', 'a', 'd'];
  var element = 'a';
  var idx = array.lastIndexOf(element);
  
  while (idx != -1) {
    indices.push(idx);
    idx = (idx > 0 ? array.lastIndexOf(element, idx - 1) : -1);
  }
  
  console.log(indices); // [4, 2, 0];
  

• Array.prototype.map()

  创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。

  语法

  var new_array = arr.map(function callback(currentValue[, index[, array]]) { // Return element for new_array }[, thisArg])

  参数

    callback
    生成新数组元素的函数，使用三个参数：
        currentValue
        callback 数组中正在处理的当前元素。
        
        index可选
        callback 数组中正在处理的当前元素的索引。
        
        array可选
        callback  map 方法被调用的数组。
        
    thisArg可选
    执行 callback 函数时使用的this 值。
  

  返回值

  一个新数组，每个元素都是回调函数的结果。

  示例

  // 求数组中每个元素的平方根
  var numbers = [1, 4, 9];
  var roots = numbers.map(Math.sqrt);
  // roots的值为[1, 2, 3],
  // numbers的值仍为[1, 4, 9]
  
  // 使用 map 重新格式化数组中的对象
  var kvArray = [
      {key: 1, value: 10}, 
      {key: 2, value: 20}, 
      {key: 3, value: 30}
  ];
  
  var reformattedArray = kvArray.map(function(obj) { 
     var rObj = {};
     rObj[obj.key] = obj.value;
     return rObj;
  });
  
  // reformattedArray 数组为： [{1: 10}, {2: 20}, {3: 30}], 
  
  // kvArray 数组未被修改: 
  // [{key: 1, value: 10}, 
  //  {key: 2, value: 20}, 
  //  {key: 3, value: 30}]
  

• Array.prototype.pop()

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

  语法

  arr.pop()

  返回值

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

  示例

  // 删除掉数组的最后一个元素
  let myFish = ["angel", "clown", "mandarin", "surgeon"];
  
  let popped = myFish.pop();
  
  console.log(myFish); 
  // ["angel", "clown", "mandarin"]
  
  console.log(popped); 
  // surgeon
  

• Array.prototype.push()

  将一个或多个元素添加到数组的末尾，并返回该数组的新长度。

  语法

  arr.push(element1, ..., elementN)

  返回值

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

  示例

  **** 添加元素到数组 ****
  var sports = ["soccer", "baseball"];
  var total = sports.push("football", "swimming");
  
  console.log(sports); 
  // ["soccer", "baseball", "football", "swimming"]
  
  console.log(total);  
  // 4
  
  ****合并两个数组****
  var vegetables = ['parsnip', 'potato'];
  var moreVegs = ['celery', 'beetroot'];
  
  // 将第二个数组融合进第一个数组
  // 相当于 vegetables.push('celery', 'beetroot');
  Array.prototype.push.apply(vegetables, moreVegs);
  
  console.log(vegetables); 
  // ['parsnip', 'potato', 'celery', 'beetroot']
  

• Array.prototype.reduce()

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

  语法

  arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])

  参数

    callback
    执行数组中每个值的函数，包含四个参数：
        accumulator
        累计器累计回调的返回值; 它是上一次调用回调时返回的累积值，或initialValue（见于下方）。
        
        currentValue
        数组中正在处理的元素。
        
        currentIndex 可选
        数组中正在处理的当前元素的索引。 如果提供了initialValue，则起始索引号为0，否则为1。
        
        array 可选
        调用reduce()的数组
        
    initialValue可选
    作为第一次调用 callback函数时的第一个参数的值。 如果没有提供初始值，则将使用数组中的第一个元素。 在没有初始值的空数组上调用 reduce 将报错。
  

  返回值

  函数累计处理的结果

  示例

  // 数组里所有值的和
  var sum = [0, 1, 2, 3].reduce(function (accumulator, currentValue) {
    return accumulator + currentValue;
  }, 0);
  // 和为 6
  
  // 箭头形式
  var total = [ 0, 1, 2, 3 ].reduce(
    ( acc, cur ) => acc + cur,
    0
  );
  
  // 累加对象数组里的值
  var initialValue = 0;
  var sum = [{x: 1}, {x:2}, {x:3}].reduce(function (accumulator, currentValue) {
      return accumulator + currentValue.x;
  },initialValue)
  console.log(sum) // logs 6
  
  // 箭头形式
  var initialValue = 0;
  var sum = [{x: 1}, {x:2}, {x:3}].reduce(
      (accumulator, currentValue) => accumulator + currentValue.x
      ,initialValue
  );
  console.log(sum) // logs 6
  
  // 将二维数组转化为一维
  var flattened = [[0, 1], [2, 3], [4, 5]].reduce(
    function(a, b) {
      return a.concat(b);
    },
    []
  );
  // flattened is [0, 1, 2, 3, 4, 5]
  

• Array.prototype.reduceRight()

  接受一个函数作为累加器（accumulator）和数组的每个值（从右到左）将其减少为单个值。

  语法

  arr.reduceRight(callback[, initialValue])

  参数 callback 一个回调函数，用来操作数组中的每个元素，可接受四个参数： previousValue 上一次调用回调的返回值，或提供的 initialValue

        currentValue
        当前被处理的元素
        
        index
        当前处理元素的索引
        
        array
        调用 reduce 的数组
        
    initialValue
    可作为第一次调用回调 callback 的第一个参数
  

  返回值

  执行之后的返回值

  示例

  // 例子：求一个数组中所有值的和
  var total = [0, 1, 2, 3].reduceRight(function(a, b) {
      return a + b;
  });
  // total == 6
  
  
  // 例子：扁平化（flatten）一个元素为数组的数组
  var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) {
      return a.concat(b);
  }, []);
  // flattened is [4, 5, 2, 3, 0, 1]
  
  
  /*例子：reduce 与 reduceRight 之间的区别
  var a = ['1', '2', '3', '4', '5']; 
  var left  = a.reduce(function(prev, cur)      { return prev + cur; }); 
  var right = a.reduceRight(function(prev, cur) { return prev + cur; }); 
  
  console.log(left);  // "12345"
  console.log(right); // "54321"
  

• Array.prototype.reverse()

  将数组中元素的位置颠倒，并返回该数组。该方法会改变原数组。

  语法

  arr.reverse()

  示例

  var sourceArray = ['one', 'two', 'three'];
  var reverseArray = sourceArray.reverse();
  
  console.log(sourceArray ) // ['three', 'two', 'one']
  console.log(sourceArray === reverseArray); // true
  

• Array.prototype.shift()

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

  语法

  arr.shift()

  返回值

  从数组中删除的元素; 如果数组为空则返回undefined 。

  示例

  let myFish = ['angel', 'clown', 'mandarin', 'surgeon'];
  
  console.log('调用 shift 之前: ' + myFish);
  // "调用 shift 之前: angel,clown,mandarin,surgeon"
  
  var shifted = myFish.shift(); 
  
  console.log('调用 shift 之后: ' + myFish); 
  // "调用 shift 之后: clown,mandarin,surgeon" 
  
  console.log('被删除的元素: ' + shifted); 
  // "被删除的元素: angel"
  

• Array.prototype.slice()

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

  语法

  arr.slice([begin[, end]])

  示例

  var fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'];
  var citrus = fruits.slice(1, 3);
  
  // fruits contains ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango']
  // citrus contains ['Orange','Lemon']
  

• Array.prototype.some()

  测试数组中是不是有元素通过了被提供的函数测试。它返回的是一个Boolean类型的值。 如果用一个空数组进行测试，在任何情况下它返回的都是false。

  语法

  arr.some(callback(element[, index[, array]])[, thisArg])

  参数 callback 用来测试每个元素的函数，接受三个参数： element 数组中正在处理的元素。

        index 可选
        数组中正在处理的元素的索引值。
        
        array可选
        some()被调用的数组。
        
    thisArg可选
    执行 callback 时使用的 this 值。
  

  返回值

  只要数组中有一个元素通过回调函数的测试就会返回true；所有元素都没有通过回调函数的测试返回值才会为false

  示例

  // 例子:检测在数组中是否有元素大于 10。
  
  function isBiggerThan10(element, index, array) {
    return element > 10;
  }
  
  [2, 5, 8, 1, 4].some(isBiggerThan10);  // false
  [12, 5, 8, 1, 4].some(isBiggerThan10); // true
  
  [2, 5, 8, 1, 4].some(x => x > 10);  // false
  [12, 5, 8, 1, 4].some(x => x > 10); // true
  
  // 使用箭头函数判断数组元素中是否存在某个值
  var fruits = ['apple', 'banana', 'mango', 'guava'];
  
  function checkAvailability(arr, val) {
    return arr.some(arrVal => val === arrVal);
  }
  
  checkAvailability(fruits, 'kela');   // false
  checkAvailability(fruits, 'banana'); // true
  

• Array.prototype.sort()

  用原地算法对数组的元素进行排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16代码单元值序列时构建的

  由于它取决于具体实现，因此无法保证排序的时间和空间复杂性。

  语法

  arr.sort([compareFunction])

  参数 compareFunction 可选 用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序。 firstEl 第一个用于比较的元素。

        secondEl
        第二个用于比较的元素
  

  返回值

  排序后的数组。请注意，数组已原地排序，并且不进行复制。

  示例

  //定义一个数组对象
  var array = ["Code", true, "Player", -5.21, false, 12, 0];
  
  // 按照ASCII字符顺序进行升序排列
  var sortedArray = array.sort();
  document.writeln( sortedArray ); // -5.21,0,12,Code,Player,false,true
  document.writeln( array ); // -5.21,0,12,Code,Player,false,true
  // 返回的数组对象sortedArray就是经过排序后的数组array本身
  document.writeln( array === sortedArray ); // true
  
  
  // 根据元素转换为字符串后的字符长度进行升序排列
  function arraySortByLength(a, b){
      // 为便于用户理解，此处未考虑a或b为undefined或null的情况。
  	var aStr = a.toString(), bStr = b.toString();
      // 如果是按照字符长度降序排序，则应该为bStr.length - aStr.length
  	return aStr.length - bStr.length;
  }
  
  // 定义一个等同的数组对象
  var array2 = ["Code", true, "Player", -5.21, false, 12, 0];
  // 使用自定义函数进行排序
  array2.sort( arraySortByLength );
  document.writeln( array2 ); // 0,12,Code,true,-5.21,false,Player
  

• Array.prototype.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.toString()

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

  语法

  arr.toString()

  示例

  var array1 = [1, 2, 'a', '1a'];
  console.log(array1.toString()); // "1,2,a,1a"
  

• Array.prototype.unshift()

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

  语法

  arr.unshift(element1, ..., elementN)

  返回值

  当一个对象调用该方法时，返回其 length 属性值。

  示例

  let arr = [1, 2];
  
  arr.unshift(0);
  // arr is [0, 1, 2]
  
  arr.unshift(-2, -1); // the new array length is 5
  // arr is [-2, -1, 0, 1, 2]
  
  arr.unshift([-4, -3]); // the new array length is 6
  // arr is [[-4, -3], -2, -1, 0, 1, 2]
  
  arr.unshift([-7, -6], [-5]); // the new array length is 8
  // arr is [ [-7, -6], [-5], [-4, -3], -2, -1, 0, 1, 2 ]
  

• Array.prototype.values() 语法 参数 返回值 示例

  使用 for...of 循环进行迭代
  
  let arr = ['w', 'y', 'k', 'o', 'p'];
  let eArr = arr.values();
  // 您的浏览器必须支持 for..of 循环
  // 以及 let —— 将变量作用域限定在 for 循环中
  for (let letter of eArr) {
    console.log(letter);
  }
  
  
  另一种迭代方式
  
  let arr = ['w', 'y', 'k', 'o', 'p'];
  let eArr = arr.values();
  console.log(eArr.next().value); // w
  console.log(eArr.next().value); // y
  console.log(eArr.next().value); // k
  console.log(eArr.next().value); // o
  console.log(eArr.next().value); // p