数组的方法

数组：一些数据的集合,每一个数据是数组的元素。
字面量方式定义数组：var arr[]
不可以用数组名.键的方式访问属性，要用[]l来访问。数组名[索引]
length属性，表示数组的长度，即元素的个数。数组最后一个元素的下标是length-1
获取数组最后一个元素arr[arr.length-1]
数组中查找对象用下标，当属性不存在时，显示undefined。并且参与数组长度计算个数
增改：arr[x下标]=值。如果下标超出了原来的length长度，length会自动发生改变。（如果开始长度是5，增加时arr[10],长度会自动增加到11）
增删改查
执行后改变原数组
在结尾添加：数组.push(2,3,4),在数组最后添加2，3，4，并改变长度，返回值是数组长度
结尾删除：pop（），括号内不接值，删除最后一个，并返回删除的元素
在开头添加，unshift(,,,)，可添加一个或多个元素。返回新数组的长度
shift()在开头删除，删除第一个，并返回删除的元素
插入截取
splice（index）从index下标位置开始向后截取，直到结尾，返回截取的元素组成新数组，原数组发生改变。
当传入的index下标不存在，返回空数组，原数组不改变
传入的是负数时，等于从数组的最后一个往前找，最后一个为-1.依然向后截取
splice（index，num）从index下标开始向后截取num个值，返回这些元素组成的新数组，原数组改变
splice（index，num，8,9,2）从index下标位置开始，截取num个元素，截取的这些元素组成一个新数组返回，并且原数组从index位置开始插入8,9,2
splice（index，0，8,9,2）从index下标位置开始，不截取只插入，并且原数组从index位置开始插入8,9,2
将原数组倒序排列，返回新的数组，原数组也改变为倒序。reverse（）
执行后不改变原数组
将数组转换成字符串，不改变原数组。join（）
join（）拷贝出来的元素用，隔开
join（“”）拷贝出来的元素连接在一起
slice（）
slice（）将原数组拷贝
slice（index）从index下标位置开始向后截取，直到结尾，返回截取的元素组成新数组，原数组不改变。
传入的是负数时，等于从数组的最后一个往前找，最后一个为-1.
slice（startIndex,endIndex）从startIndex下标开始到endIndex下标（不包含）结束，组成新数组，原数组不变
endIndex下标大于startIndex,截取为空
可以是负数，截取
concat([]，[])将一个或多个数组(或元素)合并到原数组中，原数组不发生改变
Array.isArray(),判断传入的参数是不是数组
遍历数组：
for(var i=0;i<length;i++){console.log(arr[i])}
可以添加其他属性，但不会增加长度
得到的下标是数字
for（vai key in arr）{console.log(arr[key])}
添加属性，长度增加，并且可通过下标获取
得到的下标是字符串
数组元素对应的键是以0开头的数字，也是数组的索引，下标
构造函数方式定义数组：var arr= new Array（）此处（）内如果是数字，代表数组的长度，如果不是数字，表示声明了有一个元素为此值的数组。
数组排序
冒泡排序
选择排序
sort（）排序
不传参数时，转换成字符串，按字符对应的ASCII码值排序
sort()方法进行数值排序，需要设置一个参数，这个参数是一个函数，函数返回正数，升序，返回负数，降序

   arr.sort(function(a,b){//只能对数值排序，返回值必须是Number类型
       return a-b升 或 return a-b 降
   })
var arr = [23,8,67,199];
 var newArr=arr.sort(function(a,b){
 return a-b
}
console.log(newArr,arr)
案例：
    随机排序:
        var arr = [23,8,67,199];
      arr.sort(function(){
            return Math.random()-0.5; //随机排序
      })；
      alert( arr )

    ES5新增数组方法
        arr.indexOf()
            arr.indexOf(ele);检测ele在数组arr中书否存在，存在返回下标，不存在返回-1；
            arr.indexOf(ele,index);从index位置向后查找ele是否在数组arr中存在，存在返回下标，不存在返回-1
        arr.lastIndexof()
            arr.lastIndexof(ele);检测ele在数组arr中是否存在，从后往前查找，存在返回下标，不存在返回-1
            arr.lastIndexof(ele,index),从index下标开始向前查找，找到返回下标，找不到返回-1
        arr.some(function(ele,index,array){
return
})
        arr.every(function(ele,index,array){})
        arr.forEach(function(ele，index，array){}),本质上是for循环
        过滤，循环，var newArr=arr.filter(function(ele,index,array){
}),返回新数组
            var arr=[1,4,7,0,9,23,12,14]
var newArr=arr.filter(function(ele){
return x>5;
})过滤出数组arr中大于5的数字，组成新的数组


            传入一个函数，函数接收一个参数，这个参数代表的是数组元素，函数如果return  true，当前元素返回，否则，元素被过滤掉，不显示
        映射，循环，var newArr=arr.map(function(ele,index,array){
}),返回新数组
            var newArr=arr.map(function(ele,){
return ele*ele
}),
把数组的所有元素都开平方
            传入一个函数，函数有三个选填参数，数组中的元素，元素的索引，循环的数组。
        reduce（）
            arr.reduce(function(x,y){}),
                1执行后归并为 一个值
//      var result = arr.reduce(function(prev,next,index,array){
//          //第一次循环运行时prev是数组arr的第一个元素，next是arr的下一个，index从1开始
//          //下一次循环运行时prev是上一次回调函数执行的return结果
//          console.log(prev,next,index,array);
//          return prev+next;
//      });
//      console.log("result:"+result);//result是最后一次回调函数执行的return结果
                2执行后归并为 一个新的数组
        ```
        var arr = ["tom",19,"110"];
        var brr = ["name","age","phone"];
        var newArr = arr.reduce(function(prev,next,index){
            //index从0开始遍历
            console.log(prev,next,index);
            var obj = {};
            obj[brr[index]] = next;
            prev.push(obj);
            return prev;
        },[]);
        console.log(newArr);

                3执行后归并为 一个新的对象
        var arr = ["tom",19,"110"];
        var brr = ["name","age","phone"];
        
        var obj = arr.reduce(function(prev,next,index){
            prev[brr[index]] = next;
            return prev;
        },{});
        console.log(obj);
    ```