对原数组直接操作

1
var arr= ['Apple', 'Banana']

  • Array.push()——添加元素到数组的末尾

    1
    2
    3
    > var newArray = arr.push('Orange');
    > //newArray: ["Apple", "Banana", "Orange"]
    >

  • Array.pop()——删除数组末尾的元素

    1
    2
    3
    > var newArray = arr.pop();
    > // newArray: ["Apple"];
    >

  • Array.shift()——删除数组最前面（头部）的元素

    1
    2
    3
    > var newArray = arr.shift();
    > // newArray: ["Banana"];
    >

  • Array.unshift()——添加元素到数组的头部

    1
    2
    3
    > var newArray = arr.unshift('Orange');
    > // newArray: ["Orange","Apple","Banana"];
    >

  • Array.indexOf()——找出某个元素在数组中的索引

    1
    2
    3
    > var pos = Array.indexOf('Banana');
    > // 1
    >

  • Array.splice(pos , n)——通过索引删除某个元素 / 从一个索引位置删除多个元素

    1
    2
    3
    4
    5
    6
    7
    8
    > // 通过索引删除某个元素
    > var newArray = arr.splice(1,1);
    > // newArray: ["Apple"]
    > 
    > // 从一个索引位置删除多个元素
    > var newArray = Array.splice(0,2);
    > // newArray: []
    >

  • Array.from(arrayLike , fn)——获取两个索引间的所有数值

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

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

    1
    2
    3
    4
    5
    6
    > Array.of(7);       // [7] 
    > Array.of(1, 2, 3); // [1, 2, 3]
    > // 注意区分Array(n)
    > Array(7);          // [ , , , , , , ]
    > Array(1, 2, 3);    // [1, 2, 3]
    >

  • Array.isArray()——判断传入值是否数组

    1
    2
    3
    4
    5
    6
    7
    8
    9
    > Array.isArray([1, 2, 3]);  
    > // true
    > Array.isArray({foo: 123}); 
    > // false
    > Array.isArray("foobar");   
    > // false
    > Array.isArray(undefined);  
    > // false
    >

  • Array.reverse()——将数组中元素的位置颠倒

    1
    2
    3
    > var newArray = arr.reverse();
    > // newArray: ["Banana", "Apple"]
    >

  • Array.sort()——对数组的元素进行排序

    1
    2
    3
    > var newArray = arr.sort();
    > // newArray: ["Apple", "Banana"]
    >

对数组操作，返回一个新的数组或期望值

  • Array.concat()——用于合并两个或多个数组

    1
    2
    3
    4
    5
    6
    > var array1 = ['a', 'b', 'c'];
    > var array2 = ['d', 'e', 'f'];
    > 
    > console.log(array1.concat(array2));
    > // expected output: Array ["a", "b", "c", "d", "e", "f"]
    >

  • Array.includes()——用来判断一个数组是否包含一个指定的值

    1
    2
    3
    4
    > var array1 = [1, 2, 3];
    > array1.includes(2);
    > // true
    >

  • Array.join()——将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符

    1
    2
    3
    4
    > var elements = ['Fire', 'Wind', 'Rain'];
    > console.log(elements.join());
    > // expected output: Fire,Wind,Rain
    >

  • Array.slice(pos , pos)——获取两个索引间的所有数值

    1
    2
    3
    4
    5
    6
    7
    8
    > // 通过索引删除某个元素
    > var newArray = arr.slice(0,1);
    > // newArray: ["Apple"]
    > 
    > // 【技巧】：拷贝一个数组
    > var newArray = arr.slice();
    > // newArray: ["Apple", "Banana"]
    >

数组遍历操作

  • Array.forEach()

    1
    2
    3
    4
    > array.forEach(callback(currentValue, index, array){
    >     //do something
    > }, this)
    >

  • Array.every()——测试数组的所有元素是否都通过了指定函数的测试

    1
    2
    3
    4
    5
    6
    7
    > function isBelowThreshold(currentValue) {
    >   return currentValue < 40;
    > }
    > var array1 = [1, 30, 39, 29, 10, 13];
    > console.log(array1.every(isBelowThreshold));
    > // expected output: true
    >

  • Array.some()——测试数组中的某些元素是否通过由提供的函数实现的测试

    1
    2
    3
    4
    5
    6
    7
    8
    > var array = [1, 2, 3, 4, 5];
    > var even = function(element) {
    >   // checks whether an element is even
    >   return element % 2 === 0;
    > };
    > console.log(array.some(even));
    > // expected output: true
    >

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

    1
    2
    3
    4
    5
    6
    7
    > var words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];
    > 
    > const result = words.filter(word => word.length > 6);
    > 
    > console.log(result);
    > // expected output: Array ["exuberant", "destruction", "present"]
    >

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

    1
    2
    3
    4
    5
    6
    7
    8
    > var array1 = [5, 12, 8, 130, 44];
    > 
    > var found = array1.find(function(element) {
    >   return element > 10;
    > });
    > console.log(found);
    > // expected output: 12
    >

  • Array.findIndex()——返回数组中满足提供的测试函数的第一个元素的索引。否则返回-1。

    1
    2
    3
    4
    5
    6
    7
    8
    > var array1 = [5, 12, 8, 130, 44];
    > 
    > function findFirstLargeNumber(element) {
    >   return element > 13;
    > }
    > console.log(array1.findIndex(findFirstLargeNumber));
    > // expected output: 3
    >

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

    1
    2
    3
    4
    5
    6
    7
    8
    > var array1 = [1, 4, 9, 16];
    > 
    > // pass a function to map
    > const map1 = array1.map(x => x * 2);
    > 
    > console.log(map1);
    > // expected output: Array [2, 8, 18, 32]
    >

  • Array.reduce()——对累计器和数组中的每个元素（从左到右）应用一个函数，将其简化为单个值。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    > const array1 = [1, 2, 3, 4];
    > const reducer = (accumulator, currentValue) => accumulator + currentValue;
    > 
    > // 1 + 2 + 3 + 4
    > console.log(array1.reduce(reducer));
    > // expected output: 10
    > 
    > // 5 + 1 + 2 + 3 + 4
    > console.log(array1.reduce(reducer, 5));
    > // expected output: 15
    >