js数组方法//arr1和arr还是同一个数组，reverse不通过重新排列的元素创建新数组，而是在原先的数组中重新排列

1.join()

//不改变原数组，返回字符串，括号不填的话，默认插入逗号","

var arr=[1,2,3,4,5,6,7,8,9,10];

//join(空字符串)返回12345678910

var arr1=arr.join("")

//join()效果和.toString()相同

if(arr.join()==arr.toString()){ console.log(true) }

2.reverse()

//颠倒排序,返回逆序数组，同时会颠倒原数组的排序

var arr=[1,2,3,4,5,6,7,8,9,10];
var arr1=arr.reverse()//返回 10,9,8,7,6,5,4,3,2,1

//arr1和arr还是同一个数组，reverse不通过重新排列的元素创建新数组，而是在原先的数组中重新排列它们。

3.sort()

var arr=[1,2,3,4,5,6,7,8,,9,10];

//sort()排序，返回排序后的数组，

//sort有两种使用方法，

//方法一：arr.sort()不加函数条件直接使用，数组按ASCII码表比大小。

//如果有undefined的元素时，排到尾部。

arr.sort()

console.log(arr)//返回[1,10,2,3,4,5,6,7,8,9,empty]

//使用这种方法时，如果有元素大于10的话就没办法排序了。

//方法二：当使用函数条件时sort(function(a,b){return a-b || b-a})

//a是后一项,b是前一项,当return a-b时,返回正向排序,当return b-a时返回反方向排序。

var arr1=[1,2,3,4,5,6,7,8,,9,10]; 
arr1.sort(function(a,b){ return a-b; }) 
console.log(arr1)

//返回[1,2,3,4,5,6,7,8,,9,10,empty]

arr1.sort(function(a,b){
return b-a;
})

console.log(arr1)

//返回[10,9,8,7,6,5,4,3,2,1,empty]

4.concat()

//concat()合并,合并后返回新数组，被合并的数组不会发生变化,空元素也被复制。

var arr=[1,2,3,4,5,6,7,8,,9,10];
var arr1=[11,12,13]

//方法一：在括号内添加新数组

var arr2=arr.concat(arr1)//返回[1,2,3,4,5,6,7,8,,9,10,11,12,13];

//方法二；合并元素，将多个元素与原数组和并，返回新数组（与push()相似）

var arr3=arr.concat(11,12,13)//返回[1,2,3,4,5,6,7,8,,9,10,11,12,13];

//方法三：同时合并元素、数组。

var arr4=arr.concat(11,[12,13],arr1)//[1,2,3,4,5,6,7,8,,9,10,11,12,13,11,12,13]

//方法四：如果直接使用concat就可以完成数组的复制功能。

var arr5=arr.concat()//返回[1,2,3,4,5,6,7,8,,9,10]

5.slice()

//slice()按指定位置截取复制数组的内容，返回包含被截取元素的数组。(slice()不会修改调用的数组)

//slice(0,3)括号内第一个值代表起点，表示从哪里开始，第二个值代表终点，表示截取到那个下标之前。

var arr=[1,2,3,4,5,6,7,8,,9,10];

var arr1=arr.slice(0,3)//返回[1,2,3]

//当slice()括号内不指定参数或括号内参数为(0)时，会截取整个数组

var arr2=arr.slice()//返回[1,2,3,4,5,6,7,8,,9,10];

var arr3=arr.slice(0)//返回[1,2,3,4,5,6,7,8,,9,10];

//当slice()括号内的参数为负数时，它表示相对于数组中最后一个元素位置。

var arr4=arr.slice(-3)//返回[empty,9,10]

var arr5=arr.slice(-2,-1)//返回[9],-1是数组最后一个元素。

6.splice()

//splice()在数组中插入或删除元素的通方法，不同于concat和slice的是splice会修改调用的数组。

//splice()的第一个参数指定了插入或者删除的起点，第2个参数值指定了删除元素的个数,第3个参数指定要插入的元素

var arr=[1,2,3,4,5,6,7,8,,9,10];

var arr1=arr.splice(5)//返回[6,7,8,,9,10] 原函数为[1,2,3,4,5]

var arr2=arr.splice(2,1)//返回[3],原函数为[1,2,4,5]

var arr3=arr.splice(2,0,3)//返回[],原函数为[1,2,3,4,5]

var arr4=arr.splice(5,0,6,[7,8])//返回[],原函数为[1,2,3,4,5,6,[7,8]]

7.push() pop()

//push()在尾部添加元素,返回添加元素后数组的长度

//pop()在尾部删除元素，返回被删除的元素

var arr=[1,2,3,4,5,6,7,8,,9,10];

var arr1=arr.pop()//返回10，原数组为[1,2,3,4,5,6,7,8,,9]

var arr2=arr.push(10)//返回添加元素数后数组的arr.length=11,
原数组值为[1,2,3,4,5,6,7,8,,9,10]

arr.push(11,12,[1,2,3])//push可以一次添加多个元素

8.unshift() shift()

//shift()和unshift()类似于pop()和push()

//shift()删除数组头部的元素，然后把所有元素下移一个位置来填补头部空缺，返回删除元素后数组的长度。

//unshift()在数组的头部添加元素，然后把所有随后的元素移动到更高的索引位来获得足够的空间，返回添加元素的值

var arr=[1,2,3,4,5,6,7,8,,9,10];

var arr1=arr.shift()//返回1，原数组为[2,3,4,5,6,7,8,,9,10]

var arr2=arr.unshift(1)//返回11，原数组为[1,2,3,4,5,6,7,8,,9,10];

9.forEach()

//forEach()从头到尾遍历数组，forEach没有返回值

//forEach(fanction(元素,下标,数组){})

var arr=[1,2,3,4,5,6,7,8,,9,10];

arr.forEach(function(a,b,c){            
console.log(a,b,c)//forEach遍历会跳过空元素        
})

//求数组中所有元素的和

var sum=0;        
arr.forEach(function(a,b,c){            
sum+=a        
})

console.log(sum)//55

10.map()

//map()从头到尾遍历数组，与forEach的区别是forEach没有返回值而map有返回值。

var arr=[1,2,3,4,5,6,7,8,,9,10];

//用map返回一个与原数组长度相等的新数组，map不会修改原数组。

var arr1=arr.map(function(a){            
return a        
})

// 筛选数组中大于5的值

var arr2=arr.map(function(a){            
if(a>5) return a;        
})

// 创建一个新数组,新数组的值是原数组的10倍

var arr3=arr.map(function(a){            
return a*10        
})

11.filter()

//filter()判定函数，调用filter()的方法和map()、forEach()一样，

//不同点是如果返回值是true或能转换为true的值时，那么传递给判定函数的元素就是这个子集的成员。

//它将被添加到一个作为返回值的数组中。

//总而言之就是筛选数组中满足条件的结果。

var arr=[1,2,3,4,5,6,7,8,,9,10];

/// 要求是将数组中大于5的返回到一个新数组

// 首先想到map，但map只能实现原数组和新数组长度相同

var arr1=arr.filter(function(a){            
return a>5        
})

//根据filter()的特点可以返回没有空原素的数组。

console.log(arr1)//返回[6,7,8,9,10]；

//filter也可以去除空元素。

var arr2=arr.filter(function(a){            
return true        
})        
console.log(arr2)//返回[1,2,3,4,5,6,7,8,9,10];

12.every() some()

//every()和some()是数组的逻辑判定：它们对数组元素应用指定的函数判断，返回true或false

//some

// 查找数组中是否有满足条件的元素，如果有就返回true，如果没有就返回false

// 遍历数组，如果有一个满足条件的元素，都会直接返回true，不继续向后遍历

var arr=[1,2,3,4,5,6,7,8,,9,10];       
var arr1=arr.some(function(a){            
return a>5        
})        
console.log(arr1)//返回true。

//every

// 判断数组中是否每一个都满足条件，如果有一个不满足条件，直接跳出

// 所有都满足时返回为ture

var arr2=arr.every(function(a){            
return a>=0        
})        
console.log(arr2)//返回true。

13.reduce() redusceRight()

// reduce()和reduceRight()的区别是reduce是从头到尾遍历，而reduceRight是从尾到头

// 从数组的第1位开始遍历，第0位没有遍历，下标从1开始

// 刚开始value是数组的第0项，后面每次value都是undefined

// 如果在函数中使用return 就会将返回值在下次数组的遍历中赋予value

// reduce(function(初始值,元素,下标,数组){})

// reduce返回的是一个值，就是遍历到最后一次return出来的值

var arr=[1,2,3,4,5,6,7,8,,9,10];        
var arr1=arr.reduce(function(value,item,index,arr){})
console.log(value);
return value+1

// 循环的次数是数组的个数-1

// value就是上次遍历return的值，第0次遍历时（最开始时是数组的第0项）

//数组累加

// 如果reduce没有设置初始值，累计值是数组的第0位元素，遍历从下标1开始

var arr2=arr.reduce(function(value,item,index,arr){            
return value+item        
})

// 如果reduce设置了初始值，累积值就是从这个初始值开始，遍历从下标0开始

var arr3=arr.reduce(function(value,item,index,arr){            
return value+item        
},100)

14.indexOf() lastIdexOf()

//数组.indexOf(要查询得元素,从什么位置开始查询) 位置就是下标

//indexOf()和lastIdexOf()搜索整个数组中具有给定值的元素，返回找到的第一个元素的索引。

//如果没找到就返回-1

var arr=[1,2,3,4,5,6,7,8,,9,10];        
var arr1=arr.indexOf(6)        
console.log(arr1)//返回5

var arr=[1,2,3,4,5,6,6,7,8,6,9,6,6,10];        
// 从下标7后查找        
var arr1=arr.indexOf(6,7)//返回9        
var arr2=arr.indexOf(11)//返回-1