数组去重

方法1：用for双重循环

  var ary=[1,2,3,5,6,7,8,89,4,3,12,1,1,2,3,4,54,65,2];
    for(var i=0;i<ary.length;i++){
        var cur=ary[i];
        for(var j=i+1;j<ary.length;j++){
            if (ary[i]==ary[j]){
                ary.splice(i,1);
                i--;  //防止数组塌陷
            }
        }
    }

方法2：先sort，然后用当前项和相邻项进行比较

 var ary=[1,2,3,5,6,7,8,89,4,3,12,1,1,2,3,4,54,65,2];
    var newary=ary.sort(function (n,m) {
        return n-m;
    })
    for (var i=0;i<ary.length;i++){
        if (newary[i]==newary[i+1]){
            newary.splice(i,1);
            i--;   //防止数组塌陷
        }
        else {

        }
    }

方法3：建立新数组，用indexOf

  var ary=[1,2,3,5,6,7,8,89,4,3,12,1,1,2,3,4,54,65,2];
    var search=[];
    for (var i=0;i<ary.length;i++){
        if(search.indexOf(ary[i])==-1){
            search.push(ary[i]);
        }
    }

方法4：利用函数不重名的属性

 var ary=[1,2,3,5,6,7,8,89,4,3,12,1,1,2,3,4,54,65,2];
    var obj={};
    for (i=0;i<ary.length;i++){
        if(obj[ary[i]]){
            ary.splice(i,1);
            i--;   //防止数组塌陷
        }
        else {
            obj[ary[i]]=ary[i];
            }
    }

方法5：利用对象不重名的特性，实现了重复次数的记录，里面用到两个循环，一个for循环，for..in循环

   var ary=[1,2,3,5,6,7,8,89,4,3,12,1,1,2,3,4,54,65,2];
    var obj={};
    for (i=0;i<ary.length;i++){
        if (obj[ary[i]]){
            obj[ary[i]]+=1;
        }
        else {
            obj[ary[i]]=1;
        }
    }
    var sum=[];
    for (var item in obj){
        sum.push(Number(item));
    }

算法

数组排序（三种方法）

快排（利用取中间值的方法快速排序）

1：先拿到中间的索引，通过中间索引找到他对应的项
- 这个中间项，是从数组中拎出来，即数组中没有他了，所以，只能用splice；
- splice的返回值，是被删除的内容以新数组的形式返回，因为我们删除了一项，所以，要去数字必须用[0];
2：创建两个新数组left，right；
3：用ary数组跟中间项比较，比他小的放left数组，比他大的放right数组
4： return quciksort(left).concat([center],quciksort(right));
- 函数自己调用自己，属于"递归"
5：停止拆分的条件 if(ary.length<=1){return ary;}
- return 1）有阻断程序执行的功能 2）返回值；

 var ary=[1,6,4,2,9,12,34,67,89,54];
    function quicksort(ary) {
        if (ary.length<=1){
            return ary;
        }
        var middle=Math.floor(ary.length/2);
        var  centermiddle=ary.splice(middle,1)[0];
        var left=[];
        var right=[];
        for(var i=0;i<ary.length;i++){
            if (ary[i]>centermiddle){
                right.push(ary[i]);
            }
            else {
                left.push(ary[i]);
            }
        }
        return quicksort(left).concat(centermiddle,quicksort(right));
    }
    var res=quicksort(ary);
    document.write(res);

插排

1、先从ary中取出来一个数字，单独是个数组 splice
2、遍历ary的数组，跟left数组，从后往前的比较，如果比left的数字小，继续往前比，如果比某个值大，就插入到这个值的下一项的前面；(必须break，否则就会出错) ；如果比所有的都小，那就插入到left数组的第一个；

 ary = [23, 45, 32, 12, 9, 0, 5, 4, 3, 1];
    function search(ary) {
        var left = ary.splice(0, 1);
        for (i = 0; i < ary.length; i++) {
            var cur = ary[i];
            for (j = left.length - 1; j >= 0;) {
                if (cur < left[j]) {
                    j--;
                    if (j == -1) {
                        left.unshift(cur);
                    }
                }
                else {
                    left.splice(j+1,0,cur);
                    break;
                }
            }
        }
        return left;
    }
  var ser=search(ary);
    document.write(ser);

冒泡排序

1、两重循环，第一重循环代表的是轮数，第二重循环代表的次数，比较的次数在一次次的减少；
2、每次比较的时候，都拿当前项跟后一项进行比较，如果比他大，交换位置；

 var ary=[23,21,12,6,1,32,8];
    /*
    *第一轮 最多可以比6次 已经把最大值放在最后了
         * [21,23,12,6,1,32,8]
         * [21,12,23,6,1,32,8]
         * [21,12,6,23,1,32,8]
         * [21,12,6,1,23,32,8]
         * [21,12,6,1,23,32,8]
         * [21,12,6,1,23,8,32]
    *第二轮 最多可以比5次， 可以把次大值和最大值，放在后面
        * [12,21,6,1,23,8,32]
        * [12,6,21,1,23,8,32]
        * [12,6,1,21,23,8,32]
        * [12,6,1,21,23,8,32]
        * [12,6,1,21,8,23,32]
    *第三轮 最多可以比4次 已经把最大的三个值放在后面
        * [6,12,1,21,8,23,32]
        * [6,1,12,21,8,23,32]
        * [6,1,12,21,8,23,32]
        * [6,1,12,8,21,23,32]
    *第四轮 最多可以比3次 已经最大的四个值放在侯民啊
        *[1,6,12,8,21,23,32]
        *[1,6,12,8,21,23,32]
        *[1,6,8,12,21,23,32]
    *第五轮  最多可以比2次
    * [1,6,8,12,21,23,32]
    * 第六轮 最多可以1次；
    * 第七轮 最多可以比0次；
    *
    * */

    //外面的循环应该是比较的"轮数"
    for(var i=0; i<ary.length; i++){
        //里面比较的是次数
        for(var j=0; j<ary.length-1-i; j++){
            if(ary[j]>ary[j+1]){
                //找了一个临时的空容器
                var tmp=ary[j];
                ary[j]=ary[j+1];
                ary[j+1]=tmp;
            }
        }
    }

验证码的两种方式

利用while循环

 var strcude='asdfghjkloiuy789SDRTBYH';
    var ary=[];
    while (ary.length<4){
        var num=Math.round(Math.random()*22);
        if (ary.indexOf(strcude[num])==-1){
            ary.push(strcude[num]);
        }
    }
    document.write(ary);

利用for循环

var strcude='asdfghjkloiuy789SDRTBYH';
    var ary=[];
 for(var i=0;i<4;i++){
     var num=Math.round(Math.random()*22);
     if(ary.indexOf(strcude[num])==-1){
     ary.push(strcude[num]);
     }
     else {
     i--;
     }
     }
     document.write(ary);

跟函数相关的

阻断函数的执行 return；

跟循环相关的

break 阻断循环的执行
continue 本次不执行，以后继续，不能用在while循环中；

Math常用的方法

Math.ceil() 向上取整
Math.floor() 向下取整
Math.random() 取0～1之间的随机小数，不包含1；
- Math.round(Math.random()*(m-n)+n); 取n~m之间的随机整数，包含m
Math.round() 四舍五入，取整数
Math.pow(2,3) 幂次方
Math.sqrt() 开平发
Math.abs() 取绝对值

数组

从数组末尾删除一项，有哪些方法？
- ary.length--
- ary.length-=1; ary.length=ary.lengty-1;
- ary.pop()
- ary.splice(ary.length-1,1)
给数组末尾增加一项
- ary[ary.length]=xxx;
- ary.push()
- ary.splice(ary.length,'xxx')
数组的克隆
- slice()/ slice(0)
- ary.concat();
- ary.splice(0)

选项卡封装

功能：
1）可以让一个页面中多个容器都有选项卡的功能
2）通过第二个参数，设置默认点亮项
如果参数可有可无 ||的思想 var selectIndex=selectIndex%aBtn.length||0;
%的思想；

0711-JS基础（数组去重，排序）