数组方法
数组也是对象数据类型的，也是由键值对组成的
var ary =[12,23,34]
/*
结构：
0:12,
1:23,
2:34,
length:3
*/
1.以数组作为索引（属性名），索引从零开始递增
2.有一个length属性存储的是数组长度
ary[0] 获取第一项
ary[ary.length-1] 获取最后一项
数组中每一项的值可以是任何数据类型的
//=>多维数组
var ary =[
{
name:'xxx',
age:20
},
{
name:'xxx',
age:20
}
];
数组中的常用方法
按照四个维度记忆：
- 方法的作用
- 方法的参数
- 方法的返回值
- 原有数组是是否改变
push()
作用：向数组‘末尾’追加新的内容
参数：追加新的内容（可以是一个，也可是多个）
返回值：新增后数组的长度
原有数组改变
var ary = [12,23,34];
ary.push(56); //=> len:4 ary:[12,23,34,56];
ary.push(100,{name:'xxx'}); //=> len:6 ary:[12,23,34,56,100,{name:'xxx'}]
pop()
作用：删除数组最后一项
参数：无
返回：被删除的那一项内容
原有数组改变
var ary =[12,23,34];
ary.pop();//返回34。
//len：2 ary:[12,23]
shift()
作用：删除数组中的第一项
参数：无
返回：被删除的那一项内容
原有数组改变
var ary = [12,23,34];
ary.shift() //返回12
// len：2 ary:[23,34]
基于shift删除数组的第一项，第一项被删除后，原有后面每一项的索引都要向前减1（往前提一位）
unshift()
作用：想数组开始位置追加新内容
参数：要新增的内容
返回：新增后数组的长度
原有数组改变
var ary = [12,23,34];
ary.unshift(100,true); //返回数组添加完之后的长度 len：5
// ary:[100,true,12,23,34]
splice
基于splice可以对数组进行很多的操作：删除指定位置的内容、向数组指定位置增加内容、还可以修改指定位置的信息
删除：ary.splice(n,m)
从索引n开始，删除m个内容，把删除部分以一个新数组返回，原有数组改变
如果不指定m或者m大于数组的长度，则删除到末尾
var ary = [0,1,2,3,4,5,6];
ary.splice(2,3);//从索引2开始删除，包括2，删除3个。
//=>返回[2,3,4] 改变原来数组ary:[0,1,5,6]
ary.splice(2);//从索引2开始删除到末尾结束
//=>返回[2,3,4,5,6] 原数组变为ary:[0,1]
新增 ：ary.splice(n,0,x,...)
从索引n开始伤处零项（没删除），把x或者更多需要插入的内容存放到数组中索引n的“前面”
var ary = [0,1,2,3,4,5,6];
ary.splice(1,0,'在索引1之前添加','在索引1之前添加')//=>因为没有删除项，所以返回[]
//=>改变原来数组 ary:[0, "在索引1之前添加", "在索引1之前添加",1, 2, 3, 4, 5, 6]
修改：ary.splice(n,m,x,....)
修改的原理就是把原有内容删除掉，然后用新的内容替换这部分信息即可
var ary = [0,1,2,3,4,5,6];
ary.splice(2,3,'弄啥嘞');//=>返回删除项[2,3,4]
// 改变原数组 ary:[0,1,'弄啥嘞',5,6]
练习：
- 删除数组最后一项的方法？
var ary = [0,1,2,3,4,5,6];
1. ary.pop()//返回6, ary:[0,1,2,3,4,5]
2. ary.splice(ary.length-1) //返回[5], ary:[0,1,2,3,4]
3. ary.length-- //返回5（原数组长度）, ary:[0,1,2,3]
------以下方法不建议------
不建议基于delete删除数组中的某一项，虽然内容没了，但是数组的length长度没有改变
4. delete ary[ary.length-1]//返回true ary:[0,1,2] len：4
- 数组最后一项添加内容的方法?
var ary = [0,1,2,3,4,5,6];
1. ary.push(100); //返回 8->增加后的长度，
2. ary.splice(ary.length,0,100);//返回[],因为没有删除项。
3. ary[ary.length]=100;//返回100 ->添加的值。
slice
作用：在一个数组中，按照条件查找出其中的部分内容
参数 : 两个参数（n/m），从索引n开始，找到索引m处，单数不包含m
返回 : 以一个新数组存储查找的内容原有数组不会变
var ary = [0,1,2,3,4,5,6,7,8,9]
ary.slice(2,7)//=>返回:[2,3,4,5,6] 不包含m处
ary.slice(2)//=>返回:[2,3,4,5,6,7,8,9] 不写m，则查找到数组末尾
ary.slice(0) && ary.slice()//=>返回:[0,1,2,3,4,5,6,7,8,9]
//实现数组的克隆：克隆一个新的数组出来，和原油数组内容一样，但是不是相同的内存空间，两个数组是不相等独立的
ary.slice(-3，-1)//=>返回[7,8] 支持负数索引，负数运算规则：数组总长度+负数索引
concat
作用：实现多个数组（或者值）的拼接
参数：数组或者值
返回：拼接后的新数组
原有数组不变
var ary1=[1,2,3];
var ary2=[4,5,6];
var ary3=[7,8,9];
ary1.concat(ary2,'哈哈',ary3)//=>返回[1, 2, 3, 4, 5, 6, "哈哈", 7, 8, 9]
[].concat(ary1,ary2,'haha',ary3)//=>返回[1, 2, 3, 4, 5, 6, "哈哈", 7, 8, 9] 可以基于空数组作为皮节的开始，在小括号中排列拼接的顺序，空数组不会占据内容的位置
toString
作用：把数组转换为字符串
参数：无
返回：数组中的每一项用逗号分隔的字符串
原有数组不变
var ary=[1,2,3];
ary.toString()//=>返回"1,2,3" 原数组不变
join
作用：和tosTring类似，也是把数组转换为字符串，但是我们可以设置为字符串后，每一项之间的连接符
参数：指定的连接符
返回：字符串
原有数组不变
var ary = [1,2,3,4,5,6];
ary.join() && ary.join(',')//=>"1,2,3,4,5,6"
ary.join("+")//输出"1+2+3+4+5+6"
eval(ary.join("+"))// 21 基于join我们可以实现数组中每一项求和的功能
1. 基于join，使用+作为分隔符，先把数组变为每一项相加的字符串
2. 基于eval，把字符串变为JS表达式执行，得到的结果就是数组中每一项累加的和
reverse
作用：把数组倒过来排列
参数：无
返回：排列后的新数组
原有数组改变
var ary =[1,2,3,4,5];
ary.reverse()//返回[5,4,3,2,1] ary:[5,4,3,2,1]
sort
作用：给数组排序
参数：无/函数
返回：排序后的新数组
原有数组改变
//=>sort在不传递参数的情况下，只能处理10以内数字排序
var ary = [7,6,4,5,2,3,1]
ary.sort()//返回[1, 2, 3, 4, 5, 6, 7]
var ary=[18,1,23,4543,21,3,4];
ary.sort()//返回[1, 18, 21, 23, 3, 4, 4543] 并没有按照我们想象的排序
//=>真实项目中，基于sort排序，我们都需要传递参数
var ary = [18,1,23,4543,21,3,4];
ary.sort(function (a,b){
return a-b;//升序
return b-a;//降序
})
indexOf / lastIndexOf
这两个方案不兼容IE低版本浏览器（IE6~8）
作用：检测当前值在数组中第一次或者最后一次出现位置的索引
参数：要检测的值
返回：索引
原有数组不变
var ary = [1,2,3,4];
ary.indexOf(3)//返回索引2 基于indexOf检测，如果数组中有着一项，返回一个大于等于零的索引
ary.indexOf(100)//返回-1 如果没有返回的索引为-1
//验证数组中是否包含某一项
if(ary.indexOf(100)>1){
//=>ARY中包含100这一项
}
除了以上方法，数组中还包含很多常用方法（Array.prototype）
- every
- filter
- find
- forEach
- includes
- keys
- map
- reduce / reduceRight
- some
- ...
搞懂这些方法需要了解OPP/作用域/回调函数等
数组去重
//以下方法耗性能
//方法一
var ary = [1,2,2,1,4,5,3,4,6,5,6];
// =>i<ary.length-1；不用拿最后一项
for(var i = 0;i<ary.length-1;i++){
var item = ary[i];
//=>item; 依次拿出的每一项
//=>i;当前拿出的项的索引
//=>和当前项后面的每一项比较：起始索引应该是i+1 j<ary.length找到末尾进行比较
for(var j = i+1;j<ary.length;j++){
//=>ary[j]:后面需要拿出来和当前项比较的这个值
if(item==ary[j]){
//=>相等：重复了，我们拿出来的j这个比较项在原有数组中删除
// ary.splice(j,1);
/*这里删除后会导致数组塌陷问题，当我们把当前项删除，后面的项都要向前进一位，也就是原数组的索引发生了改变，索引都会减-1，此时我们继续j+1，下次再拿出来的结果就会跳过一位。
原数组 [1,2,3,4]
i=1 =>2 我们把这一项干掉，然后i++，i=2
原数组[1,3,4]
i=2这一项是4，3这一项就错过了
*/
ary.splice(k,1);//删除后不让K累加
k--;//删除后先减减，再加加的时候相当于没加没减
}
}
}
//方法二
var ary = [1, 2, 2, 1, 4, 5, 3, 4, 6, 5, 6];
var obj = {};
for (var i = 0; i < ary.length; i++) {
var item = ary[i];
//=>存储之前需要做判断:如果对象中已经存在这个属性了，说明当前item再之前出现过，也就是当前项重复了，我们把当前项删除
if (typeof obj[item] === "undefined") {
obj[item] = item;//=>obj[1]=1 =>{1:1}
continue;
// 这种删除方式不好，如果数组很长，我们删除某一项，后面索引都需要重新机选，非常耗性能
}
ary.splice(i, 1);
i--;//防止数组塌陷
}
ES6方法，有兼容性问题
var ary = [1, 2, 2, 1, 4, 5, 3, 4, 6, 5, 6];
var newAry = Array.from(new Set(ary))
//newAry: [1, 2, 4, 5, 3, 6]
数组去重推荐方法
1.
var ary = [1, 2, 2, 1, 4, 5, 3, 4, 6, 5, 6];
var obj = {};
for (var i = 0; i < ary.length; i++) {
var item = ary[i];
//=>存储之前需要做判断:如果对象中已经存在这个属性了，说明当前item再之前出现过，也就是当前项重复了，我们把当前项内容替换为最后一项内容，然后把最后一项删掉，然后i--,重新判断当前项
//这样不影响索引，不耗性能
if (typeof obj[item] !== "undefined") {
ary[i] = ary[ary.length - 1]
ary.pop();
i--;
continue;
}
obj[item] = item;
}
console.log(ary)
2.
// 创建一个新数组，判断新数组有无，无则添加，有则跳过进行下次循环
var ary = [1, 2, 2, 1, 4, 5, 3, 4, 6, 5, 6];
var newAry = [];
for (var i = 0; i < ary.length; i++) {
if(newAry.indexOf(ary[i])>-1){
continue
}
newAry.push(ary[i])
}
