JS基础之数组

数组的基础结构：

数组也是对象数据类型的 typeof []->'object'
数组也有属性名，只不过属性名为数字，我们把数字属性名称之为它的索引：数组是以数字作为索引，索引从零开始，有一个length属性，代表数组的长度
类数组：类似于数组，但不是数组
1.通过getElementByTagName获取的元素集合是类数组
2.函数中的实参集合arguments也是类数组 ->document.getElementByTagName('*')
循环数组中的每一项

 var ary=[12,23,34];
 //for循环操作
 for(var i=0;i

数组中的常用方法

数组中有很多常用的方法(使用数组方法需要考虑以下几点：)
1.方法的意义和作用
2.方法的形参
3.方法的返回值
4.通过此方法，原来的数组是否发生改变

实现数组的增加、修改、删除、查询

• 增加：push 参数可以为1到多个，可以传递多个，用逗号隔开，向数组的末尾增加新内容 返回数组的长度 原数组改变；数组里边的每一项值可以是任意类型值
  unshift:向数组的开头追加新元素，参数可以为1到多个，传递多个用逗号隔开，返回数组的长度 原数组改变；
  arr[arr.length]=xxx;可以把数组当做普通对象，使用对象键值对操作，向数组的末尾增加新的内容
• 删除：pop 删除数组最后一项，不支持参数，返回被删除的那一项内容，原有数组改变
  shift:删除数组第一项，不支持参数，返回被删除的那一项内容，原数组改变，后面每一项的索引都要向前进一位，导致后面的索引发生改变
  delete arr[索引] 把数组当成普通对象操作 删除指定索引对象，原有数组其他项索引不会改变 返回true,当前数组的length不会改变　　
  arr.length--:删除数组最后一项
  splice:数组中内置的方法，可以实现数组的增加、修改、删除 返回被删除的内容（以一个新数组保存被删除的内容），原有数组改变
  splice(n,m):从索引n开始删除m个（m不写是删除到数组末尾）;不带参数一项也不删除，返回空数组，splice(0)清空数组
  splice实现修改 splice(n,m,x)在原有删除的基础上用x代替删除的内容
  splice实现增加(n,0,x):在修改的基础上，一项都不删除，把x插入到索引n的前面，返回空数组
  arr.splice(0,0,x) 向数组开头追加新的内容
  arr.splice(arr.length,0,x) 向数组末尾增加新内容
  arr.splice(0,1) 删除第一项 arr.splice(ary.length-1)删除最后一项　
  查询 ：slice 参数（n,m）从索引n开始找到索引m处（不包含m），返回找到的部分以新数组返回；原数组不变,如果只写n 从索引n开始找到末尾 如果写个0或者不写 数组克隆，克隆一份和原来数组一模一样的新数组
  支持负数索引，如果索引为负数，浏览器解析的时候是按照 总长度+负数索引来处理的
• 拼接：concat 将多个数组拼接在一起，参数是要拼接的内容，可以是数组，也可以是一些数据值；返回拼接后的新数组，原数组不变；如果不带参数，什么都没有拼接，相当于把原有数组克隆一遍
• 转为字符串: toString 实现把数组转换为字符串（转换后的字符串以逗号分隔每一项），不需要参数，返回转换的字符串，原数组不变
  join 把数组按照指定的分隔符转为字符串，和字符串中的split相对应 参数：指定的链接符,返回转换后的字符串，原数组不变,如果不带参数返回只有长度为一的数组；可用于数组求和

// 数组求和
//     1.循环求和
    var total=null;
    for(var i=0;i

• 排列：reverse 把数组中的每一项倒过来排列，不需要参数，返回排序后的数组，原数组改变
• 排序： sort 实现数组的排序 无参数或者一个回调函数，返回排序后的数组，原数组改变,不传参数的情况下：可以给10以内的数字进行升序排列，但是超过10的就无法处理了（多位数只识别第一位）,解决：sort(function(a,b){return a-b;}) a-b 升序 b-a 降序
• 验证数组中是否包含某一项：indexof/lastIndexof 获取当前项在数组中第一次/最后一次出现的位置的索引，如果当前数组中没有返回-1；用于验证是否包含,数组中的这两个方法不支持IE6-8但是字符串中的这两个方法支持所有浏览器

Array.prototype.myIndexOf=function myIndexOf(value) {
     var result=-1;
     for(var i=0;i

遍历数组的方法：以下的方法在IE(6-8)都不兼容

• forEach 遍历数组中的每一项
• map:遍历数组中的每一项，在forEach的基础上，可以修改每一项的值

  arr.forEach(function(value,index){
        /*数组中有多少项，当前回调函数就执行多少次；每一次传递进来
        的value就是当前遍历数组这一项的值，index就是遍历这一项的索引
         */
    })
 arr.map(function(value,index){
        /*数组中有多少项，当前回调函数就执行多少次；每一次传递进来
        的value就是当前遍历数组这一项的值，index就是遍历这一项的索引
         */
        return xxx;//return 后面返回的结果就是把当前遍历的对象修改为xxx
    })

数组去重

• 方案一：遍历数组中的每一项，拿每一项和它后面的项一次比较，如果相同了，则把相同的这一项在原来的数组中删除即可,缺点：性能不好 循环次数太多
  数组塌陷：我们使用splice删除数组中的某一项后，删除的这一项,后面的每一项索引都要向前进一位（在原有索引上减一），此时如果我们j++,循环操作的值增加了，我们通过最新j获取的元素不是紧挨删除这一项的元素，而是跳过这一项元素

var arr=[1,2,3,1,2,3,345,12,4,43,213,11,3,5,3,3,6];
//length-1：最后一项后面没有内容了，我们不需要在比较
for(var i=0;i

• 方案二：利用indexOf来验证数组中是否包含某一项，包含包当前项删除掉(不兼容ie(6-8))

 var arr=[1,2,3,1,2,3,345,12,4,43,213,11,3,5,3,3,6];
 for(var i=0;i-1){
        //后面的就包含当前项（当前这一项是重复的），删除即可
         arr.splice(i,1);
         i--;
     }
 }
 console.log(arr);

• 方案三：
  原理：对象去重的方式,遍历数组中的每一项，把每一项的作为新对象的属性名和属性值存储起来,在每一次向对象中存储之前，首先看一下原有对象中是否包含了这个属（typeofobj[xxx]==='undefined' 说明当前对象中没有xxx这个属性）如果已经存在这个属性，说明数组中的当前项是重复的（1在原有的数组中删除这一项2不在向对象中存储这个结果），如果不存在（把当前项）作为对象的属性名和属性值存储进去即可)

  var arr=[1,2,3,1,2,3,345,12,4,43,213,11,3,5,3,3,6];
    var obj={};
    for(var i=0;i

数组排序（算法）
-冒泡排序：让数组中的当前项和后一项进行比较，如果当前项大于后一项，我们让两者交换位置(小->大) 一轮不能完成比较，每一轮都能把当前最大的放到末尾 具体比较的轮数 arr.length-1

  /*bubble 冒泡排序
     @parameter
     arr：[array] 需要实现排序的数组
     @return
      [array]排序后的数组（升序）
      by team on 2019/3/6
     */
function bubble(arr) {
    //外层循环控制比较轮数
    for(var i=0;iarr[j+1]){
                //当前项比后一项大，我们交换位置
                var temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }
    return arr;
}

递归：函数自己调用自己

   //1-100之间，把所有能被3并且被5整除的获取到，然后累加求和
     var total=null;
    function fn(num) {
        if(num>100){
            return 0;
        }
        if(num%15===0){
            return num+fn(num+1)
        }
        fn(num+1)
  }
  fn(1)

• 快速排序：先找中间项，然后把余项中的每一个值和中间相进行比较，小的放左边，大的放右边，然后左边右边重复执行

 function quick(arr) {
     //如果传递进来的数组只有一项或者是空的，我们则不再继续拆分了
     if(arr.length<=1){
         return arr;
     }
     //获取中间项索引：把中间值获取到，原有数组中删除中间项
     var centerIndex=Math.floor(arr.length/2);
     var centerValue=arr.splice(centerIndex,1)[0];//返回数组
     //用剩余数组中的每一项和中间项比较，小的在左边，大的在右边
     var leftArr=[],rightArr=[];
     for(var i=0;i

类数组:
元素集合是类数组
var Oli=document.getElementsByTagName('div');
节点集合也是类数组
var oLi=document.getElementsByName('div');
在IE6-8中，元素集合和节点集合的类数组 不支持借用数组slice实现类数组变为数组
arguments支持
var Oli=document.getElementsByTagName('div');
var ary=Array.prototype.slice.call(Oli);
console.log(ary)
解决兼容:
for(var i=0;i arr[ary.length]=oli[i]
}

  //处理IE不兼容类数组转为数组　
   listToArray:function (likeAry) {
           var arr=[];
           try{
            arr=Array.prototype.slice.call(likeAry)
           }catch(e){
                for(var i=0;i

 function avgFn() {
        /*arguments是类数组，不能使用数组 方法 sort;将数组转为数组
        数组slice()是克隆数组，可以借鉴封装一个克隆的方法
        Array.prototype.mySlice=function () {
        var arr=[];
        for(var i=0;i