数组的方法
数组方法中的回调函数中参数2都可以改变回调函数中的this的指向。
[TOC]
1 循环数组forEach
使用方法：对应的值和找到下标。
缺点：
- forEach不能选择从哪个位置开始循环。
- 不能停止break和跳过continue
//语法 arr.forEach(function(item,index,array){ console.log(item,index,array) },可选参数2)通过参数2可以改变forEach中this的指向
自己封装：
var arr = [1,2,3,4,5,6]; function foreach(arry,callback){ for(var i=0; i<arr.length; i++){ callback(arry[i],i) } } foreach(arr,function(a,b){ console.log(a,b); })
2 将数组转为字符串arr.join(参数);
和split相反，没有参数时，默认用逗号连接，可以定义连接符， 参数定义连接符。
3 arr.push(参数1，参数2，··· )
向数组的末尾添加内容。会改变数组的内容 返回操作之后的长度
push的返回值是数组添加内容之后的长度。
4 arr.unshift(参数1，参数2，··· )
向数组的开头位置添加内容。会改变数组的内容 返回操作之后的长度
unshift的返回值是数组添加内容之后的长度。
5 arr.pop()
删除数组的末尾一项,没有参数 返回数组中删除的内容
默认删除最后一个，每次调用都会删除一项。返回值是删除的那一项。
6 arr.shift()
删除数组的开始一项,没有参数 返回数组中删除的内容
默认删除开始的一项，每次调用都会删除一项。返回值是删除的那一项。
7 arr.map(回调函数)
该方法会把回调函数执行结果拼成一个数组。返回该数组
var maps = arr.map(function(item){
return `<li>${item}</li>`
//返回的是一个数组，将每一次执行完回调函数的值添加到这个数组的对应的位置
})
//list.innerHTML = maps;结构中都是字符串类型的，即使maps是数组，也会把它转为字符串，默认调用toString()方法，把逗号也转了，所以不能直接用。
list.innerHTML = maps.join('');
8 arr.filter(回调函数)
回调函数的返回值为true，那么就把循环到的这一项放到新数组中，在回调函数中，放入条件return 条件；将满足条件的项重新组成一个新的数组。并返回。
var arred = arr.filter(function(item){
return item.age>25;
})
9 arr.concat();连接一个多个数组
var arr1 = [1,2,3]
var arr2 = [4,5,6]
var newarr = arr1.concat(arr2,['a','b'],'miaov')
// [1, 2, 3, 4, 5, 6, "a", "b", "miaov"]
括号中没有参数时，返回的是arr1，但是不是arr1，而是一个新数组
10 arr.reverse();颠倒数组，翻转数组
var arr3 = [1,2,3,4]
console.log(arr3.reverse())
//[4, 3, 2, 1]
会改变原来的数组顺序。不接受任何参数。
11 arr.slice(参数1，参数2);截取指定位置的数组
var arr4 = [1,2,3,4]
console.log(arr4.slice())//[1, 2, 3, 4]
console.log(arr4.slice(1,3))//[2, 3]
console.log(arr4.slice(2))//[3, 4]
console.log(arr4.slice(-1))//[4]
console.log(arr4)//[1, 2, 3, 4]
没有参数时，默认截取整个数组，从头截到尾。 参数1定义开始位置，参数2定义结束位置前的。 接收负数，arr4.slice（-1），截取的是最后一个。 只有一个参数时，从该位置截取到结尾
12 arr.splice(参数1，参数2,参数3);截取指定个数后组成数组
参数1开始位置，参数2截取个数，参数3是替换的值；可以为多个
会改变原来数组的值，分情况：1参数为空 2参数正常两个 3参数为一个 4参数为三个 ```
var arr5 = [1,2,3,4,5,6]
console.log(arr5.splice())
//为空数组
console.log(arr5)
//[1, 2, 3, 4, 5, 6] 返回的新的数组，和原来相似
console.log(arr5.splice(2,3))
//[3, 4, 5]
console.log(arr5)
// [1, 2, 6] 会改变原数组
console.log(arr5.splice(2))
//[3, 4, 5, 6] 一个参数从指定位置截取到结尾位置
console.log(arr5)
//[1, 2]
console.log(arr5.splice(2,3,'a','b'))
//[3, 4, 5] 替换
console.log(arr5)
//[1, 2, "a", "b", 6] 替换 ```
静态属性和静态方法
自定义的属性，挂在函数上的属性，属于静态属性 给函数属性定义一个函数，属于静态方法
13 数组的静态方法from，isArray
- 将类数组（可循环对象）转为数组Array.from(类数组) ``` var lis = document.getElementsByTagName(‘li’)//lis为类数组 var lisarr = Array.from(lis)//转为数组 lisarr.push(1) console.log(lisarr) //[li, li, li, li, li, 1]
console.log(Array.isArray(lisarr)) //true
第二个参数时一个回调函数，将类数组的每一项做进一步处理，将回调函数中return后的值放入新生成的数组中。
第三个参数改变函数this的指向。
转完之后可以调用数组的所有方法
* 判断类型是否为数组Array.isArray(值)
### 14 arr.indexOf(参数)
## for in循环
每一次循环的时候都会把对象的key值赋值给变量
`for(var attr in obj){}//attr都是字符串`
数组的的key值是类型为字符串的下标。循环数组就用for循环，循环对象就用for in。也可以用for循环，但是key值必须是数字从0开始。手动添加length属性。
对象没有length属性，需手动添加。
## 冒泡排序
冒泡排序
依次比较数组两个值，按大小条件交换位置，持续重复的比较，直到没有再需要交换为止，说明该数组排序完成了。
以下是从小到大排序步骤：
* 比较数组中每一对相邻的元素，
如果第一个比第二个大，就交换他们两个。从数组第一对到结尾的最后一对
* 经过一轮比较之后，会把最大的排到末尾
* 针对所有的元素重复第一步，除了最后一个（因为已经是最大值）。
* 持续每次对越来越少的元素重复第一步，直到没有任何一对数字需要比较。
**1 第一种方法：通过第三方赋值**
var arr = [1,8,3,4,7,2,0,4]
for(var j=0; j<arr.length-1; j++){ //0,1 1,2 2,3 length-2,length-1 第0个j找的是第1个最大值 for( var i=0; i<arr.length-1-j; i++ ){ //每一次找到最大值后就不用比较最后的最大值了 if(arr[i]>arr[i+1]){ var c = arr[i] arr[i] = arr[i+1] arr[i+1] = c } } }
**2 第二种方法：通过数组运算**
var arr = [1,8,3,4,7,2,0,4]
for(var j=0; j<arr.length-1; j++){ //0,1 1,2 2,3 length-2,length-1 第0个j找的是第1个最大值 for( var i=0; i<arr.length-1-j; i++ ){ //每一次找到最大值后就不用比较最后的最大值了 if(arr[i]>arr[i+1]){ arr[i]=[arr[i+1],arr[i+1]=arr[i]][0] } }
console.log(arr) } ```
递归
定义：函数自己调用自己（程序调用自身的编程技巧称为递归）
条件：当递归的时候，需要有一个条件让递归停下来
只有函数执行完成之后才有返回值。
function fn(n){
if(n<=1) return n;
return fn(n-1) + n;
}
console.log(fn(3))//6
快速排序
这种排序的思想是数组中的每个元素与基准值，数组中比基准值小的放在基准值的左边，形成左部；大的放在右边，形成右部；接下来将左部和右部分别递归地执行上面的过程：选基准值，小的放在左边，大的放在右边。。。直到排序结束。
以下是从小到大排序步骤：
- 从数组张找出一个元素作为基准，pivot=数组.shift()
- 分区（Partition）：比基准值小的放左边，大的放右边，基准值(Pivot)放左部与右部的之间。
- 对左边和右边分区进行递归操作，重复以上步骤 ``` var arr = [1,8,3,4,7,2,4,9,0,4]
function speed(date){ if(date.length<=1) return date;//数组中还剩一个值时没必要再执行了 var pivot = date.shift();//取数组中的第一个拿出，不参与比较 var left = []; var right = []; for(var i=0; i<date.length; i++){ if(date[i]<pivot){ left.push(date[i])//小的放在左边 }else{ right.push(date[i])//大的放在右边 } } return speed(left).concat(pivot,speed(right))//分别拿左边的数组和右边的数组再次调用speed快速排序，用concat连接左小右大 } console.log(speed(arr))// [0, 1, 2, 3, 4, 4, 4, 7, 8, 9]
| 左 | 5,8,4 | 右 |
| :-------: | :-----: | :----: |
| 4 | 5（取出的参考值） | 8 |
| 4 | 5 | 8 |
| 组成新的数组： |4,5,8| |
## sort排序
var arr = [5,21,0,9,12,3,8,0,1] arr.sort(); console.log(arr) //[0, 0, 1, 12, 21, 3, 5, 8, 9]
默认是按字符串排序的，按第一位排序，引用ASCII编码。'2'>11; '20'>'2';
#### 带参数的sort排序
- return后的是一个新的数组。
var arr = [1,8,3,4,7,2,4,9,0,4]
arr.sort(function(a,b){ return a-b;//return后是正数，互换位置，负数或0，不换位置。相当于拿出1和8,1-8<0,不换位置，8-3>0,则互换位置。 }) console.log(arr)//[0, 1, 2, 3, 4, 4, 4, 7, 8, 9]
## 数组去重
* 方法1
var arr = [5,6,5,8,1,2,8,4,9,3,1,2,4,7] var arrNo = [] for( var i=0; i<arr.length; i++ ){ var onOff = false; for( var j=0; j<arrNo.length; j++ ){ if(arr[i] === arrNo[j]){//如果原数组中的第i个依次和新数组中的数比较后都不相等，说明跟目前的新数组的数不重复；相等的话，说明跟新数组中的数有重复的，把开关设为true， onOff = true; break; } } if(!onOff){//不重复的话就在新数组循环完成后，把第i个数放入新数组中 arrNo.push(arr[i])//[5,6,8,1,2,4,9,3,7] } } console.log(arrNo)//[5,6,8,1,2,4,9,3,7]
* 方法2：利用数组方法indexOf找重复的值
var arr = [5,6,5,8,1,2,8,4,9,3,1,2,4,7] var arrNo = [] for( var i=0; i<arr.length; i++ ){ if(arrNo.indexOf(arr[i]) == -1){//说明没有找到 arrNo.push(arr[i]) } } console.log(arrNo)//[5, 6, 8, 1, 2, 4, 9, 3, 7]
* 方法3：利用对象key值得唯一性判断比较
var arr = [5,6,5,8,1,2,8,4,9,3,1,2,4,7] var arrNo = [] var obj = {} for( var i=0; i<arr.length; i++ ){ if(!obj[arr[i]]){//没有这个key值时，说明新数组中没有重复的 arrNo.push(arr[i])//添加进新数组中 obj[arr[i]] = 1;//把对象的这个属性赋值：obj{5:1} } } console.log(arrNo)//[5, 6, 8, 1, 2, 4, 9, 3, 7]
## 从0-100找10个不重复的数
* 方法1
```javascript
var arr1 = [];
var obj = {};
for(var i=0;arr1.length<10;i++){//用arr1的长度作为判断条件进行判断
var n = Math.round(Math.random()*100)
if(!obj[n]){
arr1.push(n)
}
}
console.log(arr1)
- 方法2
var arr1 = []; var obj = {}; for(var i=0;i<100;i++){ var n = Math.round(Math.random()*1000) if(!obj[n]){ arr1.push(n) }else{ i--;//没有返回前一位重新开始 } } console.log(arr1)