JS中数组方法（分为不改变原来数组的方法和会改变原来数组的方法）

1. 会改变数组的方法（常见的7个）

分别是：push后添加，pop后删除，unshift前添加，shift前删除，sort排序，reverse反转，splice部分替换

• push后添加

// push(若干个往后添加的值),返回值是添加后数组的长度
var arr=[1,2]
console.log(arr.push(9,10));//4
console.log(arr);//[ 1,2,9,10 ]

• pop后删除

// pop(无参数)，删除并返回最后一个值
var arr=[1,2,3,4]
console.log(arr.pop());//4
console.log(arr)//[1,2,3]

• unshift前添加

//unshift(若干个往前添加的值),返回值是添加后数组的长度
var arr=[1,2,3,4]
console.log(arr.unshift(-2,-1,0));//7
console.log(arr)//[-2,-1,0,1,2,3,4]

• shift前删除

//shift(无参数),删除并返回第一个值
var arr=[1,2,3,4]
console.log(arr.shift());// 1
console.log(arr)//[2,3,4]

• sort排序（有很多用法，并不只是简单的排序）

//sort(参数可有可无),返回正序排序结果
var arr=["c","d","a","b"]
console.log(arr.sort());// [ 'a', 'b', 'c', 'd' ]
console.log(arr)// [ 'a', 'b', 'c', 'd' ]

• reverse反转

//reverse(无参数),返回反转结果
var arr= [ 'a', 'b', 'c', 'd' ]
console.log(arr.reverse());// [ 'd', 'c', 'b', 'a' ]
console.log(arr)// [ 'd', 'c', 'b', 'a' ]

• splice部分替换

//splice(start,end(可有可无),替换的若干个值（可有可无，且需要有end）),返回被替换的几个值
var arr= [ 'a', 'b', 'c', 'd' ,'e']
console.log(arr.splice(1,3,   9,9,9));// [ 'b', 'c', 'd' ]
console.log(arr)// [ 'a', 9, 9, 9, 'e' ]

2.会改变数组的方法（常见的11个）

分别是：concat合并，join字符连接，slice截取，forEach遍历，map映射遍历，reduce叠加遍历，filter遍历筛选，every遍历判断，some遍历判断，indexOf查询索引，lastIndexOf反向查询索引

• concat合并

//concat(若干个数组或者数字或者字符),返回被替换的几个值
var arr= [ 'a', 'b', 'c']
console.log(arr.concat([1,2,3],6,["D","D"],"小明"));// ['a','b','c',  1,2,3,  6,  'D','D', '小明']
console.log(arr)// [ 'a', 'b', 'c']

• join字符连接

//slice(start,end(可有可无)),返回截取的几个值，注意这个是包前不包后的
var arr= ['a','b','c',1,2,3]
console.log(arr.slice(1,5));// [ 'b', 'c', 1, 2 ]
console.log(arr)// [ 'a', 'b', 'c', 1, 2, 3 ]

• slice截取

//slice(start,end(可有可无)),返回截取的几个值，注意这个是包前不包后的
var arr= ['a','b','c',1,2,3]
console.log(arr.slice(1,5));// [ 'b', 'c', 1, 2 ]
console.log(arr)// [ 'a', 'b', 'c', 1, 2, 3 ]

• forEach遍历

//forEach(（值，索引，原数组）=>{}),不能用，break和continue
var arr= ['a','b','c',1,2,3]
arr.forEach((value,index,a)=>{console.log(value,index,a);})    
//打印如下：
// a 0 [ 'a', 'b', 'c', 1, 2, 3 ]
// b 1 [ 'a', 'b', 'c', 1, 2, 3 ]

但是，forEach不能使用break和continue，如果硬是需要达到循环中退出的形式，你可以使用抛出错误并接收的形式，如下

//forEach(（值，索引(可写可不写)，原数组（可写可不写））=>{}),不能用break和continue
var arr= ['a','b','c',1,2,3]
try {
    arr.forEach((value,index,a)=>{
        console.log(value,index,a);
        if(index===1) throw Error("ddd")
    })    
} catch (error) {}

• map映射遍历

//map(（值，索引(可写可不写)，原数组（可写可不写））=>{}),不能用break和continue，返回映射结果var arr= ['a','b','c',1,2,3]
var b=arr.map((value,index,a)=>{return value+"iii"})    
console.log(b);//[ 'aiii', 'biii', 'ciii', '1iii', '2iii', '3iii' ]
console.log(arr);//[ 'a', 'b', 'c', 1, 2, 3 ]

• reduce叠加遍历

//reduce(（之前的值，值，索引(可写可不写)，原数组（可写可不写））=>{}),返回连续操作的结果，不能用break和continue
//如下，实现一个简单的连乘
var arr= [1,2,3]
var b=arr.reduce((pre_value,value,index,a)=>{return pre_value*value})
console.log(b);//6
console.log(arr);//[ 1, 2, 3 ]

• filter遍历筛选

//filter(（值，索引(可写可不写)，原数组（可写可不写））=>{}),返回符合条件的值组成的数组，不能用break和continue
var arr= [1,2,3,4,5,5]
var b=arr.filter((value,index,a)=>{return value>=3})
console.log(b);//[ 3, 4, 5, 5 ]
console.log(arr);//[ 1, 2, 3, 4, 5, 5 ]

• every遍历判断

//every(（值，索引(可写可不写)，原数组（可写可不写））=>{}),全部满足条件返回true否则false，不能用break和continue
var arr= [1,2,3]
var b=arr.every((value,index,a)=>{return value>=1})
console.log(b);//true
console.log(arr);//[ 1, 2, 3 ]

• some遍历判断

//some(（值，索引(可写可不写)，原数组（可写可不写））=>{}),一个或多个满足条件返回true否则false，不能用break和continue
var arr= [1,2,3]
var b=arr.some((value,index,a)=>{return value>=3})
console.log(b);//true
console.log(arr);//[ 1, 2, 3 ]

• indexOf查询索引

//indexOf(查找值，start（可写可不写））=>{}),返回查找到的第一个值的索引
var arr= [0,1,2,3,1]
var b=arr.indexOf(1,3)//从索引为3的地方开始查找到，包括索引为3的值
console.log(b);//4
console.log(arr);//[ 0, 1, 2, 3, 1 ]

• lastIndexOf反向查询索引

与indexOf类似，但是反方向查找

3. 所有代码

// push(若干个往后添加的值),返回值是添加后数组的长度
// var arr=[1,2]
// console.log(arr.push(9,10));//4
// console.log(arr);//[ 1,2,9,10 ]

// pop(无参数)，删除并返回最后一个值
// var arr=[1,2,3,4]
// console.log(arr.pop());//4
// console.log(arr)//[1,2,3]

//unshift(若干个往前添加的值),返回值是添加后数组的长度
// var arr=[1,2,3,4]
// console.log(arr.unshift(-2,-1,0));//7
// console.log(arr)//[-2,-1,0,1,2,3,4]

//shift(无参数),删除并返回第一个值
// var arr=[1,2,3,4]
// console.log(arr.shift());// 1
// console.log(arr)//[2,3,4]

//sort(参数可有可无),返回正序排序结果
// var arr=["c","d","a","b"]
// console.log(arr.sort());// [ 'a', 'b', 'c', 'd' ]
// console.log(arr)// [ 'a', 'b', 'c', 'd' ]

// //reverse(无参数),返回反转结果
// var arr= [ 'a', 'b', 'c', 'd' ]
// console.log(arr.reverse());// [ 'd', 'c', 'b', 'a' ]
// console.log(arr)// [ 'd', 'c', 'b', 'a' ]

//splice(start,end(可有可无),替换的若干个值（可有可无，且需要有end）),返回被替换的几个值
// var arr= [ 'a', 'b', 'c', 'd' ,'e']
// console.log(arr.splice(1,3,   9,9,9));// [ 'b', 'c', 'd' ]
// console.log(arr)// [ 'a', 9, 9, 9, 'e' ]

//concat(若干个数组或者数字或者字符),返回被替换的几个值
// var arr= [ 'a', 'b', 'c']
// console.log(arr.concat([1,2,3],6,["D","D"],"小明"));// ['a','b','c',  1,2,3,  6,  'D','D', '小明']
// console.log(arr)// [ 'a', 'b', 'c']

//join(连接的字符串),返回被替换的几个值
// var arr= ['a','b','c',1,2,3]
// console.log(arr.join("--"));// a--b--c--1--2--3
// console.log(arr)// [ 'a', 'b', 'c', 1, 2, 3 ]

//slice(start,end(可有可无)),返回截取的几个值，注意这个是包前不包后的
// var arr= ['a','b','c',1,2,3]
// console.log(arr.slice(1,5));// [ 'b', 'c', 1, 2 ]
// console.log(arr)// [ 'a', 'b', 'c', 1, 2, 3 ]


//forEach(（值，索引(可写可不写)，原数组（可写可不写））=>{}),不能用break和continue
// var arr= ['a','b','c',1,2,3]
// arr.forEach((value,index,a)=>{console.log(value);})//分行打印a b c 1 2 3
// console.log(arr);//[ 'a', 'b', 'c', 1, 2, 3 ]

//map(（值，索引(可写可不写)，原数组（可写可不写））=>{}),不能用break和continue，返回映射结果
// var arr= ['a','b','c',1,2,3]
// var b=arr.map((value,index,a)=>{return value+"iii"})    
// console.log(b);//[ 'aiii', 'biii', 'ciii', '1iii', '2iii', '3iii' ]
// console.log(arr);//[ 'a', 'b', 'c', 1, 2, 3 ]

//reduce(（之前的值，值，索引(可写可不写)，原数组（可写可不写））=>{}),返回连续操作的结果，不能用break和continue
//如下，实现一个简单的连乘
// var arr= [1,2,3]
// var b=arr.reduce((pre_value,value,index,a)=>{return pre_value*value})
// console.log(b);//6
// console.log(arr);//[ 1, 2, 3 ]

//filter(（值，索引(可写可不写)，原数组（可写可不写））=>{}),返回符合条件的值组成的数组，不能用break和continue
// var arr= [1,2,3,4,5,5]
// var b=arr.filter((value,index,a)=>{return value>=3})
// console.log(b);//[ 3, 4, 5, 5 ]
// console.log(arr);//[ 1, 2, 3, 4, 5, 5 ]

//some(（值，索引(可写可不写)，原数组（可写可不写））=>{}),一个或多个满足条件返回true否则false，不能用break和continue
// var arr= [1,2,3]
// var b=arr.some((value,index,a)=>{return value>=3})
// console.log(b);//true
// console.log(arr);//[ 1, 2, 3 ]

//indexOf(查找值，start（可写可不写））=>{}),返回查找到的第一个值的索引
var arr= [0,1,2,3,1]
var b=arr.indexOf(1,3)//从索引为3的地方开始查找到，包括索引为3的值
console.log(b);//4
console.log(arr);//[ 0, 1, 2, 3, 1 ]