1、push()

  可以向数组末尾中添加一个或多个元素，并返回数组新的长度（影响原来的数组）

let arr=[1,3,6];
arr.push(6,9,0);
console.log(arr);//[ 1, 3, 6, 6, 9, 0 ]

1
2
3
4

2、pop()

  删除数组的最后一个元素，并将被删除的元素作为返回值返回（影响原来的数组）

let arr=[2,4,74,8];
const result=arr.pop();
console.log(result);//8
console.log(arr);//[ 2, 4, 74 ]

1
2
3
4
5

3、unshift()

  数组开头添加一个或多个元素，并且返回新的数组长度（影响原来的数组）

let arr=[3,5,7,2];
arr.unshift(666,2,5);
console.log(arr);//[666, 2, 5, 3,5, 7, 2]
1
2
3

4、shift()

  删除数组的第一个元素，并将被删除的元素作为返回值返回

let arr=[27,3,5,1,7];
let result=arr.shift()
console.log(result);//27
console.log(arr);//[ 3, 5, 1, 7 ]

1
2
3
4
5

5、slice()

  从已有的数组返回选定的元素。该方法不会影响原数组，而是将截取到的元素封装到一个新数组中返回。

参数：

1. 截取开始的位置的索引，包含开始位置的索引（必需）
2. 截取结束的位置的索引，不包括结束位置的索引。若第二个参数不写，则会截取从开始索引往后的所有元素；如果传递一个负值，则从后往前计算。

let arr = [2, 4, 7, 2, 8];
1

  第一个参数为正数，第二个参数为正数

let result=arr.slice(0,2);
console.log(result);//[ 2, 4 ]
console.log(arr);//[ 2, 4, 7, 2, 8 ]
1
2
3

  第一个参数为正数，第二个参数为负数

let result=arr.slice(2,-1);
console.log(result);//[ 7, 2 ]
1
2

  第一个参数为负数，第二个参数为负数

let result=arr.slice(-4,-1);
console.log(result);//[ 4, 7, 2 ]
1
2

  第一个参数为正数，第二个参数不写，截取从开始索引往后的所有元素

let result=arr.slice(3);
console.log(result);//[ 2, 8 ]
1
2

  第一个参数为负数，第二个参数不写，从后往前计算，截取从开始索引往后的所有元素

let result=arr.slice(-4);
console.log(result);//[ 4, 7, 2, 8 ]
1
2

6、splice()

  删除数组中的指定元素。使用splice（）会影响到原数组，会将指定元素从原数组中删除，并将被删除的元素作为返回值返回。

参数：

1. 开始位置的索引（必需）;
2. 删除的数量（不能为负数）；
3. 第三个及以后，可以传递一些新的元素，这些元素将会自动插入到开始位置索引前边

let arr=[2,4,8,1,4,7,3];
1

  第一个参数为正数，第二个参数不写，删除从开始索引往后的所有元素

let result=arr.splice(4);
console.log(result);//[ 4, 7, 3 ]
console.log(arr);//[ 2, 4, 8, 1 ]
1
2
3
4

  第一个参数为负数，第二个参数不写，从后往前计算，删除从开始索引往后的所有元素；

let result=arr.splice(-2);
console.log(result);//[ 7, 3 ]
console.log(arr);//[ 7, 3 ]
1
2
3

  第一个参数为正数，第二个参数正数，删除从开始索引往后指定的数量；

let result=arr.splice(4,2);
console.log(result);//[ 4, 7 ]
console.log(arr);//[ 2, 4, 8, 1, 3 ]
1
2
3

  第一个参数为负数，第二个参数正数，从后往前计算，删除从开始索引往后指定的数量；

let result=arr.splice(-5,2);
console.log(result);//[ 8, 1 ]
console.log(arr);//[ 2, 4, 4, 7, 3 ]
1
2
3

  三个及三个以上参数，自动插入到开始位置索引前边

let result=arr.splice(5,1,999,666,555);
console.log(result);//[ 7 ]
console.log(arr);//[2,   4,   8, 1, 4,999, 666, 555, 3]  
1
2
3

7、concat()

  可以连接两个或多个数组，并将新的数组返回。该方法不会对原数组产生影响。

let arr1 = ['arr1',28,  27];
let arr2 = ['arr2',29, 19, 0, 42];
let arr3 = ['arr3', 78, 36];
let result1 = arr1.concat(arr3);
let result2=arr2.concat(arr1,arr3);
console.log(result1);//[ 'arr1', 28, 27, 'arr3', 78, 36 ]
console.log(result2);//['arr2', 29, 19,0, 42, 'arr1',28,27, 'arr3',78,36]  
1
2
3
4
5
6
7

8、join()

  将数组转换为一个字符串，该方法不会对元数组产生影响，而是将转换后的字符串作为结果返回。

let arr = [1, 2, 3, 4, 5];
let result = arr.join()
console.log(typeof result, result);//string 1,2,3,4,5
console.log(typeof arr, arr);//object [ 1, 2, 3, 4, 5 ]
1
2
3
4

9、reverse()

  用来反转数组（前边的去后边，后边的去前边）。该方法影响到原数组

let arr = [1, 2, 3, 4, 5];
arr.reverse();
console.log(arr);//[ 5, 4, 3, 2, 1 ]
1
2
3

10、sort()

  对数组元素进行排序，该方法会影响原数组，默认按照Unicode编码进行排序；

let arr=['赵六','李四','王麻子','张三','王五','钱七'];
arr.sort();
console.log(arr);//[ '张三', '李四', '王五', '王麻子', '赵六', '钱七' ]
1
2
3

  即使对于纯数字的数字，使用sort()进行排序时，也会按照Unicode编码进行排序，所以对数值进行排序时，可能会得到错误的结果。

let arr=[2,8,99,5,88,9,22];
arr.sort();
console.log(arr);//[2, 22,  5, 8,88,  9, 99]
1
2
3

  我们可以自己来指定排序的规则。可以在sort（）添加一个回调函数，来指定排序规则。回调函数中需要定义两个形参，浏览器将会分别使用数组中的元素作为实参去调用回调函数。使用哪个元素调用不确定，但是肯定的是在数组中a一定在b前面。
  浏览器会根据回调函数的返回值来觉得元素的顺序，如果返回大于0的值，则元素会交换位置；如果返回一个小于0的值，则元素位置不变；如果返回一个0，则认为两个元素相等，也不会交换位置。

let arr = [2, 3, 41, 5, 21, 11];
arr.sort(function (a, b) {
    // document.write("a="+a);
    // document.write("b="+b);
    /*  if(a>b){
          //前边的大，返回的值大于0，交换位置
          return 1;
      }else if(a

const arr = [1, 5, 3, 8, 4];
arr.forEach((item, index, arr) => {
    if (index === 3) {//下标为3时跳过当次
        return;
    }
    console.log("元素", item, '下标', index, '遍历的数组', arr);
})
1
2
3
4
5
6
7

const arr=[{name:'张三',sex:'女'},{name:'王五',sex:'男'},{name:'赵六',sex:'女'},{name:'钱七',sex:'女'}]
let newArr=arr.filter((item,index,arr)=>{
    //返回性别为“女”的元素
    return item.sex==='女'
})
console.log('arr', arr);
console.log('newArr', newArr);
1
2
3
4
5
6
7

const arr = [1,4,2,8]
let newArr = arr.map((item, index, arr) => {
    //返回性别为“女”的元素
    if (item===8) {
        item=88888
    }
    return item
})
console.log('arr', arr);//arr [ 1, 4, 2, 8 ]
console.log('newArr', newArr);//newArr [ 1, 4, 2, 88888 ]

1
2
3
4
5
6
7
8
9
10
11

const arr = [5,25,35,45]
const result = arr.reduce(function(prev,next,index,arr){
    console.log('prev', prev,index);
    console.log('next', next);
    console.log('prev + next', prev + next);
    return prev + next;
})
console.log(result);
1
2
3
4
5
6
7
8