js1

    创建数组：
        var a = new Array();
        var b = [];    


    数组长度：a.length;

    两个数组合并：a.concat(b);

    join方法：返回一个字符串
            var a=[1,2,3,4];
            var b=a.join("#")
            b为1#2#3#4
            
            a.join();//默认之间使用空格连接
            a,join("");//之间什么也没有
            a.join(" ");//之间用空格连接
    console.log();
    console.error();//错误
    console.warn();//警告
    document.write();//页面输出内容并且可以识别标签        
    
    NaN：
        number和其他类型数据操作，结果都是number类型，除了'+'运算和String类型操作结果是String类型。
        NaN也是number类型，NaN和任何数都不相等，自身也不相等。

    isNaN:
        任何不能转化为数字的值，都会导致这个结果为true    
        如果是数字返回结果是false
            alert(isNaN("1A"))//true
            alert(isNaN("123"))//false
            alert(isNaN(123))//false
            alert(isNaN(true))//false

    null == undefined的结果(true)
    null ===undefined的结果(false)
    10 + null结果为：10；
    10 + undefined结果为：NaN。

    变量.toSting()     
    注意：undefined和null不可以

    parseInt是取整，
        123.1asb//123
        123abc//123

        两个参数就是进制转换:是任意进制转换为十进制。
        parseInt(10101,2);
            就是讲10101转化是10进制，2表示10101是2进制

    toString多个参数，就是十进制转化为任意进制     
        var num=10;
        var n=num.toString(4);
            将num转换为4进制

    parseFloat是取小数
        123.1asb//123.1
        123abc//123

    number();取所有前面的数字
        123.1asb//123.1
        123abc//123

    js没有方法重载    
    js函数，参数匹配正常执行。


    参数多了也执行，多余的参数是underfine，对之进行操作会报错。
    参数少了，也会执行，不会报错。


    JS加载的时候，只加载函数名，不加载函数体。所以如果想使用内部的成员变量，需要调用函数。

    全局变量（成员变量）
        哪里都可以访问到的变量,进入script立即定义的变量和没有var的变量。


    隐式全局变量
    隐式全局变量就是隐藏的全局变量不好被发现。
        function  fn（）{
            var  a  =  b  =  c  =  1;   // b和c就是隐式全局变量
        }
        注意:
        function  fn（）{
            var  a  =  b  =  c  =  1;   // b和c就是隐式全局变量（等号）
            var  a = 1;  b = 2;  c = 3;     // b和c就是隐式全局变量（分号）
            var  a = 1 ,  b = 2 ,  c = 3;    // b和c就不是隐式全局变量（逗号）
        }
    

    在不同的scripe中函数得先写出来 再去使用，规则定义在使用前。
        fn1();//报错
            var fn1=function(){
                alert("..");
            }

        fn2();//报错
            var fn2=new function(alert("..."););
    同一个script中函数可以先使用再定义

    数组是公用一个内存，数组作为参数，如果在方法中对参数有修改，相当于对数组在修改。
    复杂对象同数组一样都是共用一个内存。
    只有简单数据类型才不会共用一个数据类型。


    构造函数：
        var stu =new Stu("zs");
        function Stu(name){
            this.name=name;
            alert("...");
        }

    json和对象的区别是：json中的key必须是String，带有引号"";
    json是大括号{},数组是中括号[];
    json是对象，没有长度,所以不能用for循环遍历，不能用length；
    json遍历：用for...in...循环
        var json={"name":"tom","age":"12","arr":[12,13,14]   };
        for(var key in json){
            console.log(json[key]);
        }
        结果是：
            tom
            12
            Array [ 12, 13, 14 ]
        json.key
            就是underfine
        console.log(key);
            就是键：name age  arr

    制造json
        var json={};
        for(var i=0;i<3;i++){
            json[i]=i*10;
        }        
        clonsole.log(json);
        生成的json为{0:0;1:10;2:20};

    比较是否是目标对象
        1.可以为任意类型
            var arr =[1,2,3];
            console.log(arr instanceof Array);    
        2.只能比较数组
            Array.isArray(arr);
    数组转换字符
        arr.toString();
            -->数组转化为字符串每一项用逗号隔开   
            -->结果是1,2,3
        arr.valueOf();
        
    arguments只在函数中使用，是实参的数组，伪数组
        伪数组：不能修改长短的数组，但是可以修改元素的值
            arguments.push(1);会报错
        fn1(1);
        fn1(1,2);
        fn1(1,2,3);//即使参数多了也会被arguments接受
        fn1(1,2,3,4);
        function fn1(a,b){
            console.log(arguments);//即使函数的参数个数少，该数组也可以全部接受传递的形参个数
            console.log(arguments.length);//形参的个数，调用传递了几个参数，可变
            console.log(fn1.length);//实参的个数，就是函数有几个参数，不可变
            console.log(arguments.callee);//打印整个函数，包括注释
        }

    栈操作：先进后出
        push();//在最后插入元素，返回插入后的数组大小
        pop();//取出最后一项，返回第一个元素值并且在数组中删除

    队列操作：先进先出
        shift();//取出第一个元素，返回第一个元素值并且在数组中删除
        unshift();//在数组最前面插入，返回插入后数组的长度。

    排序方法：
        reverse();//反转数组
        sort();//从小到大排序
        alert(arr.sort(function (a,b){return a-b}));//由小到大排序
        alert(arr.sort(function (a,b){return a-b}));//由大到小排序        

    数组的连接concat-->重新生成一个新数组
        var arr1=[1,2,3];
        var arr2=[4,5,6];
        var arr3=arr1.concat(arr2);
            //[1,2,3,4,5,6];

    slice数组的截取：截取生成一个新的数组 （索引到索引）
        var arr1=[1,2,3,4,5,6];
        var arr2=arr1.slice(a);    
            截取的新的数组，索引从2开始到最后一个
        var arr2=arr1.slice(-a);    
            截取新的数组，截取最后a个数
        var arr2=arr.slice(a,b);
            截取新的数组索引a到索引b之间的数  包左不包右
            如果啊a>b则新数组为空数组

    splice（索引到后几个）,替换或删除当前数组的某些项目,操作和截取原数组生成一个新的数组，原数组改变
        var arr1=[1,2,3,4,5,6];
        var arr2=arr1.splice(开始截取位置的索引,截取多少个);
            arr1会改变（少数），arr2为新截取的数组

        var arr3=arr1.splice(开始截取位置的索引,截取多少个,数组A);    
            将截取的数组用新数组替代，在arr1中，arr3为截取的数组

    indexOf("数组里的值");给元素查索引，返回索引，只查找最近的一个。没有就返回-1
        

    lastIndexOf("数组里的值");从后往前给元素查索引,返回的是索引。没有就返回-1
    

    迭代方法，不会修改原数组
        every:对数组中的每一项都进行以下函数，如果所有的返回为true则返回true，如果一项为false则停止遍历返回false
                如果在里面对数组可以新的赋值改变原有的数组
            var arr1=[1,2,3,4,5,6];
            arr1.every(function(item-元素,index-索引,arr1-数组){
                ...//参数名字随便取
            })

        filter:对数组array每一项进行函数内的操作，返回结果为true的项。组成一个新的数组arr。
            var arr=array.filter(function(item-元素,index-索引,array-数组){
                ...
            })
        
        forEach:遍历数组,无返回值，纯粹操作数组的元素
            array.forEach(function(item.key,array){
                ...
            })
        
        map:对数组中的每一项都进行以下函数,返回函数的结果组成一个新的数组。
            array.map(function(item.key,array){
                ...
            })

    统计各个字符出现的个数：
        var arr =["1","s","d","3","1","2","s","g","h","f","a","6","2","3"]    ;
        var json={};
        for(var i=0;i<arr.length;i++){
            for(var k in json){
                if(json[arr[i]]!=undefined){
                    //if(json[arr[i]]!=undefined)等价于if(json[arr[i]])
                    json[arr[i]=json[arr[i]+1;
                }else{
                    json[arr[i]]=1;
                }
            }
            
        }