数组方法：插入删除替换操作数组元素

​

Array.shift（）

作用：删除原数组第一项，并返回删除元素的值；如果数组为空则返回undefined
参数 : 没有参数`
语法：

// 数组.shtif()
let a = [ 1,2,3,4,5 ]
let b = a.shift(); // a:[ 2,3,4,5 ]  b:1 

---

Array.unshift(‘val’)

作用：将参数添加到原数组开头，返回数组长度
参数：val:要添加到数组的参数
语法：

// 数组.unshtif(参数1,参数2,.....)
let a = [ 1,2,3,4,5 ]
let b = a.unshift(6,'pink'); // a:[ 6,'pink',1,2,3,4,5 ]  b:7

---

Array.pop()

作用 ：删除原数组最后一项，并返回删除元素的值；如果数组为空则返回undefined删除原数组第一项，并返回删除元素的值；如果数组为空则返回undefined
参数 : 没有参数
语法：

// 数组.pop()
let a = [ 1,2,3,4,5 ]
let b = a.pop(); // a:[ 1,2,3,4 ]  b:5

---

Array.push(‘val’)

作用：将参数添加到原数组尾部，返回数组长度
参数：val:要添加到数组的参数
语法：

// 数组.push(参数1,参数2,.....)
let a = [ 1,2,3,4,5 ]
let b = a.push(6,'pink'); // a:[ 1,2,3,4,5,6,'pink' ]  b:7

---

Array.concat(‘val’)

作用：往数组里面添加新的元素；并返回组成后新的数组
参数：val:要添加到数组的参数
语法：

// 数组.concat(参数1,参数2,.....)
let a = [ 1,2,3,4,5 ]
let b = a.concat(6,'pink'); // a:[ 1,2,3,4,5 ]  b:[ 1,2,3,4,5,6,'pink' ] 

---

Array.splice(start,[deleteCount,val1,val2…])

作用： 可以删除/修改/添加原数组指定位置的参数 返回删除后的内容
参数：
- start:必填参数，输入索引值，表示从哪开始删除
- deleteCount：可选，要删除的个数
- val1，val2…: 可选，删除后替换的参数
语法：

// 数组.splice(start,[deleteCount,val1,val2......])
let a = [ 1,2,3,4,5 ]
let b = a.splice(1, 2, 'pink'); // a:[ 1, 'pink', 4, 5 ]   b:[ 2, 3 ]  

---

Array.slice(startIndex, endIndex)

作用： 截取开始索引与结束索引之间的内容 返回截取内容
参数：
- 语法：
- startIndex：开始位置的索引号
- endIndex：可选 结束位置的索引号 不写默认截取后面的全部

// 数组.slice(开始的索引号,结束的索引号)
let a = [ 1,2,3,4,5 ]
let b = a.slice(1, 3); // a: [ 1,2,3,4,5 ]  b:[ 1, 5 ] 
let c = a.slice(1); // a: [ 1,2,3,4,5 ]  b:[ 1 ]  

---

Array.reverse()

作用：将原数组进行翻转,返回的是反转后的内容
参数：没有参数
语法：

// 数组.reverse()
let a = [ 1,2,3,4,5 ]
let b = a.reverse(); // a:[5, 4, 3, 2, 1]  b:[5, 4, 3, 2, 1]

---

Array.join(separator)

作用：将数组使用separator进行分割处理组成一个字符串
参数：separator：可选 默认用逗号分割
语法：

// 数组.join('用什么分割')
let a = [ 1,2,3,4,5 ]
let b = a.join(); // a:[ 1,2,3,4,5 ]  b:"1,2,3,4,5 "
let c = a.join('#'); // a:[ 1,2,3,4,5 ]  b:"1#2#3#4#5 "

---

Array.sort( compareFunction（firstEI,secondEl))

作用：对数组的元素进行排序到位并返回排序后的数组。默认排序顺序是升序。
参数：
- compareFunction:可选参数，不填默认升序排序，通过firstEI,secondEl比较进行排序
----firstEl：比较的第一个元素。使用时一般写成a
----secondEl：用于比较的第二个元素。使用时一般写成b
----比较规则：
---------compareFunction函数里return firstEl - secondEl 则是升序
---------compareFunction函数里return secondEl - firstEl 则是降序
语法：

// 数组.sort( function（a,b) return 规则 )
let a = [ 1,2,3,4,5 ]
let b = a.sort((a,b)=>a-b); // a:[1, 2, 3, 4, 5]  b:[1, 2, 3, 4, 5]
let x = [ 1,2,3,4,5 ] 
let y = x.sort((a,b)=>b-a); // a:[5, 4, 3, 2, 1]  b:[5, 4, 3, 2, 1]

---

Array.every(function callbackFn(element, index, array) { … }, thisArg)

作用：判断数组里面所有元素是否全部满足当前条件，满足返回true，反之falue。它返回一个布尔值。
参数：
-callbackFn：必填 用于测试每个元素的函数，采用三个参数：
-----·element：数组中正在处理的当前元素
-----·index：数组中正在处理的当前元素的索引
-----·array：被every所调用的数组
-thisArg：可以让this指向到此对象

语法：

//数组.every(函数体(正在处理的元素, 索引, 数组) { ... }, 对象)
let a = [ 1,2,3,4,5 ]
let b = a.every(function (element, ind, arr) {
			console.log(element);  //打印数组里的所有内容
            console.log(ind);	//打印所有索引号
            console.log(arr);	//[ 1,2,3,4,5 ]
            console.log(this): //{ a:1 }
            //判断数组里面的元素是否全部都大于3
            return element > 3
      }, { a: 1 });
console.log(a);//a: [1, 2, 3, 4, 5]
console.log(b);//b: false

---

Array.some(function callbackFn(element, index, array) { … }, thisArg)

作用：判断数组里面是否有满足当前条件的元素，有返回true，反之falue。
参数：
-callbackFn：必填 用于测试每个元素的函数，采用三个参数：
-----·element：数组中正在处理的当前元素
-----·index：数组中正在处理的当前元素的索引
-----·array：被every所调用的数组
-thisArg：可以让this指向到此对象

语法：

//数组.some(函数体(正在处理的元素, 索引, 数组) { ... }, 对象)
let a = [ 1,2,3,4,5 ]
let b = a.some(function (element, ind, arr) {
			console.log(element);  //打印数组里的所有内容
            console.log(ind);	//打印所有索引号
            console.log(arr);	//[ 1,2,3,4,5 ]
            console.log(this): //{ a:1 }
            //判断数组里面的元素是否有大于三3的元素
            return element > 3
      }, { a: 1 });
console.log(a);//a: [1, 2, 3, 4, 5]
console.log(b);//b: true	

---

Array.find(function callbackFn(element, index, array) { … }, thisArg)

作用：判断数组里面是否有满足当前条件的元素，有返回匹配到的第一个元素的值，反之返回undefined。
参数：
-callbackFn：必填 用于测试每个元素的函数，采用三个参数：
----·element：数组中正在处理的当前元素
----·index：数组中正在处理的当前元素的索引
----·array：被every所调用的数组
-thisArg：可以让this指向到此对象

语法：

//数组.find(函数体(正在处理的元素, 索引, 数组) { ... }, 对象)
let a = [ 1,2,3,4,5 ]
let b = a.find(function (element, ind, arr) {
			console.log(element);  //打印数组里的所有内容
            console.log(ind);	//打印所有索引号
            console.log(arr);	//[ 1,2,3,4,5 ]
            console.log(this): //{ a:1 }
            //判断数组里面的元素是否有大于三3的元素
            return element > 3
      }, { a: 1 });
console.log(a);//a: [1, 2, 3, 4, 5]
console.log(b);//b: 4	     

Array.findIndex(function callbackFn(element, index, array) { … }, thisArg)

作用：判断数组里面是否有满足当前条件的元素，通过测试的数组中第一个元素的索引，反之返回 -1 。
参数：
callbackFn：必填 用于测试每个元素的函数，采用三个参数：
-----element：数组中正在处理的当前元素
-----index：数组中正在处理的当前元素的索引
-----array：被every所调用的数组
thisArg：可以让this指向到此对象
语法：

//数组.findIndex(函数体(正在处理的元素, 索引, 数组) { ... }, 对象)
let a = [ 1,2,3,4,5 ]
let b = a.findIndex(function (element, ind, arr) {
			console.log(element);  //打印数组里的所有内容
            console.log(ind);	//打印所有索引号
            console.log(arr);	//[ 1,2,3,4,5 ]
            console.log(this): //{ a:1 }
            //判断数组里面的元素是否有大于三3的元素
            return element > 3
      }, { a: 1 });
console.log(a);//a: [1, 2, 3, 4, 5]
console.log(b);//b: 3	     

---

Array.forEach(function callbackFn(element, index, array) { … }, thisArg)

作用：循环遍历数组 。返回值全部都是undefined
注意: 如果数组里面的元素是简单数组类型，就无法对齐进行影响
参数：
callbackFn：必填 用于测试每个元素的函数，采用三个参数：
-----element：数组中正在处理的当前元素
-----index：数组中正在处理的当前元素的索引
-----array：被every所调用的数组
thisArg：可以让this指向到此对象
语法：

//数组.forEach(函数体(正在处理的元素, 索引, 数组) { ... }, 对象)
let a = [ 1,2,3,4,5 ]
let b = a.forEach(function (element, ind, arr) {
			console.log(element);  //打印数组里的所有内容
            console.log(ind);	//打印所有索引号
            console.log(arr);	//[ 1,2,3,4,5 ]
            console.log(this): //{ a:1 }
            //判断数组里面的元素是否有大于三3的元素
            element+=1    // 不会影响数组
      }, { a: 1 });
console.log(a);//a: [1, 2, 3, 4, 5]
console.log(b);//b: undefined	     

---

Array.includes(valueToFind[, fromIndex])

作用：方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回 false。
注意: 如果数组里面的元素是简单数组类型，就无法对齐进行影响
参数：
valueToFind：需要查找的元素值。
fromIndex ：从fromIndex 索引处开始查找 valueToFind。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜 （即使从末尾开始往前跳 fromIndex 的绝对值个索引，然后往后搜寻）。默认为 0。
语法：

//数组.includes(函数体(需要查找的元素值, [开始查找的索引]) 
let a = [ 1,2,3,4,5 ]
let b =  a.includes('1')
console.log(a);//a: [1, 2, 3, 4, 5]
console.log(b);//b: true

---

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

作用：方法对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值。
参数：
callback：执行数组中每个值 (如果没有提供 initialValue则第一个值除外)的函数，包含四个参数:
-----accumulator:累计器累计回调的返回值; 它是上一次调用回调时返回的累积值，或initialValue（见于下方）。
-----currentValue:数组中正在处理的元素。
-----index：数组中正在处理的当前元素的索引。 如果提供了initialValue，则起始索引号为0，否则从索引1起始。
-----array：调用reduce()的数组
initialValue: 可选 作为第一次调用 callback函数时的第一个参数的值。 如果没有提供初始值，则将使用数组中的第一个元素。 在没有初始值的空数组上调用 reduce 将报错。(第一次循环的值)
语法：

//数组.reduce(函数体(积累的返回值, 正在处理的元素[, 索引[,正在处理的数组]])[, 循环开始的起始值])
let a = [1, 2, 3, 4, 5]
let b = a.reduce(function(accumulator,currentValue,index,array){
    console.log(index);// 索引号
    console.log(array);// [1, 2, 3, 4, 5]
    return accumulator+=currentValue
},5)//敲黑板这个0   是开始那个和索引为1相加  默认不给就是1+2+3+4+5  给5就是5+1+2+3+4+5   给6就是6+1+2+3+4+5
console.log(a);//a: [1, 2, 3, 4, 5]
console.log(b);//b: 20
console.log(a);//a: [1, 2, 3, 4, 5]
console.log(b);//b: undefined

Array.filter(callback(element[, index[, array]])[, thisArg])

作用：满足符合条件的内容
参数：
callback：执行数组中每个值 (如果没有提供 initialValue则第一个值除外)的函数，包含四个参数:
-----element:当前正在处理的元素
-----index：正在处理的元素在数组中的索引。
-----array：调用filter()的数组
thisArg: 可选 可以改变this指向
语法：

//数组.filter(函数体(正在处理的元素[, 索引[,正在处理的数组]])[改变this指向])
let a = [1, 2, 3, 4, 5]
let c= 'so hello!'
let b = a.filter(function (element, index, array) {
    console.log('this',this); // String {'so hello!'}
    return element >= 3
},c)
console.log(a);// [1, 2, 3, 4, 5]
console.log(b);// [3,4,5]