JS-2

1.流程控制语句
     1) if语句
        if(condition){
            statement1
        }else{
            statement2
        }
        condition表示任意表达式，该表达式求值的结果不一定是布尔类型，如果不是布尔类型，ECMAScript会调用Boolean() 转换函数将这个表达式结果转换为一个布尔类型，如果condition求值结果为true,执行statement1。如果求值结果为false，执行statement2
        
        var a = "hello";
        if(a!=null){
            //...
        }
        或者直接写
        if(a){        
            //        
        }

        
     2) switch语句
        switch(expression){
            case val:

                break;
            case val2:

                break;
            default:
        }

        等价于

        switch(expression){
            case val:{

                break;
            }
            case val2:{
                break;
            }
            default:
        }

      可以在switch语句中使用任何数据类型。

      例如:
        var day = new Date().getDay();
        var x = "";
        switch (day){
            case 0:
              x="Today it's Sunday";
              break;
            case 1:
              x="Today it's Monday";
              break;
            case 2:
              x="Today it's Tuesday";
              break;
            case 3:
              x="Today it's Wednesday";
              break;
            case 4:
              x="Today it's Thursday";
              break;
            case 5:
              x="Today it's Friday";
              break;
            case 6:
              x="Today it's Saturday";
              break;
            default:
              x="error!!!";
        }


     3) 循环语句    
        for语句
        for循环是一种前测试循环语句，但它具有在执行循环之前初始化变量和定义循环后要执行的代码的能力。以下是for循环的语法：
        初始化表达式，控制表达式，循环后表达式
        for(initialization;expression;post-loop-expression){
            //loop option
        }
        例如:
        var sum = 0;
        for(var i=0;i<10;i++){
            sum +=i;
        }
        console.log(i); //10  

        ECMAScript不存在块级作用域，在循环内部定义的变量也可以在外部访问到,但是在函数内部定义的局部变量,在函数外部是不能访问的
    
        
        ----------
        死循环
        for(;;){
            //当for中的表达式省略的时候，会创建一个死循环
        }
        while(true){
        
        }

        
        ----------
        do-while语句  
        do{
        
        }while(condition);
        后测试循环语句，即只有在循环体中的代码执行之后，才会测试出口条件。循环体内的代码最少被执行一次。
        

        ----------
        while语句    
        while(condition){
        
        }
        前测试循环语句，即在循环体内的代码被执行之前，就会对出口条件求值。因此，循环体内的代码有可能永远不会被执行。
        while(false){
            //
        }

        
        ----------
        for-in 语句
        是一种精准的迭代语句，可以用来枚举对象的属性
        
        for(property in expression){
            statement
        }
        例如:
        打印出window对象中所有的属性
            for(var propName in window){
                console.log(propName+":"+window[propName]);
            }
        
        var person = new Object();
        person.name = "tom";
        person.age = 20;
        person.sayHello=function(){....}
        或者简写为:
        var person = {
                name:"tom",
                age:20,
                sayHello:function(){
                    alert("hello world");
                }
        };
        console.log(person.name);
        console.log(person.age);
        person.sayHello();
        for(var key in person){
            console.log(key+" - "+person[key]);
        }

        ----------
        label 语句
            使用label可以在代码中添加标签，以便将来使用
            label : for(int i=0;i<10;i++){
                if(i == 5){
                    break label;
                }
            }
        循环关键字
           break    跳出循环体
           continue 结束本次循环，进行下一次循环

     4) 特殊语句
        with语句
        主要作用是将代码的作用域设置在一个特定的对象中，定义with语句的主要目的是为了简化多次访问同一个对象的工作，但是大量使用with语句会导致性能下降，并且难以维护，所以不建议使用。
            例如：
            var person = {
                name:'briup',
                age:12,
                gender:'男'
            }
            要想访问person对象中的属性需要：
                console.log(person.name);
                console.log(person.age);
                console.log(person.gender);
            但是还可以通过with语句来实现
                with(person){
                    console.log(name);
                    console.log(age);
                    console.log(gender);
                }


2.javascript中的函数
    函数实际上是对象，每个函数都是Function类型的实例，函数名实际上是指向函数对象的指针。
    1) 表示方法:
        1.函数声明
        function sum(a,b){
            return a+b;
        }
        2.函数表达式
        var sum = function(a,b){
                return a+b;
        }
        解析器在向执行环境中加载数据时，会率先读取函数声明，并使其在执行任何代码之前可用；当执行器执行到函数表达式的代码的时候才会真正的解释执行
    2) 函数的参数
        ECMAScript函数的参数与大多数其他语言中的函数的参数有所不同，ECMAScript函数不介意传递参数的个数以及参数类型，这是因为函数的参数在函数内部是使用一个数组对象来表示的。这个数组对象就是arguments
        例如:
        function test(){
            for (i = 0; i < arguments.length; i++) {
                console.log(arguments[i]);
            }
        }
        test(15,"hello");

    3) 函数的调用
        在JS中，函数没有重载的概念，两个函数的函数名相同即是同样一个函数，但是Java中不是,java中判断方法是否是同一个是看方法名和参数列表
        
        js中函数可以先调用后定义
        例如:
            <script type="text/javascript">
                test();
                function test(){
                    alert("hello world");
                }
                test();
            </script>
    
    4) 函数对象
        javascript中的函数也是对象,它是Function类型的对象,用java中的概念理解就是,javascript中的每个函数都是Function类型的实例,就像java中的每个方法都是Method类的实例一样。


    5) 匿名函数
        //定义一个函数test,其参数需要接收另一个函数,注意js中的函数也是对象,就是这个Function类型的对象,函数对象也有自己的方法和属性,其中call就是Function类型中的一个方法,所有的函数对象就可以调用这个call方法来让自己本身执行(类似java中的反射)
        function test(f){
            //表示f这个函数要执行,执行f函数的对象是null,参数是"briup"
            //执行f函数的对象设置为null的话会默认变成window对象
            f.call(null,"briup");

            //同时,javascript中还支持如下直接调用
            //f("briup");
        }
        
        //调用test函数,并把一个匿名函数对象作为参数传给test
        test(function(name){
            console.log("hello! "+name);
        });


3.Array类型
    ECMAScript数组和其他语言中的数组都是有序列表，但是有以下特性：
    a.每一项都可以保存任何类型的数据。
    b.数组的大小是可以动态调整。
    c.数组的length属性：可读可写，可以通过设置length的值从数组的末尾移除项或向数组中添加新项

    1) 创建方法
       1. 使用Array构造函数
          var arr = new Array();
          var arr = new Array(20);  // 预先指定数组的大小
          var arr = new Array("tom","zs","lisi"); //传入参数
          注意：new 关键字也可以省略，但是尽量不要省略
       2. 使用数组字面量
          由一对包含数组项的方括号表示，多个数组项之间用逗号分隔
          var arr = ["tom","zs","lisi"];
          var arr = []            //空数组

    2) 访问数组元素
       数组变量名[索引]
        1.如果索引小于数组的长度，返回对应项的值
            var arr = ["tom","zs","lisi"];
            arr[0] ;            //访问数组中第一个元素,返回值为tom
        2.如果索引大于数组的长度，数组自动增加到该索引值加1的长度
            var arr = ["tom","zs","lisi"];
            arr[3] ="jacky";    //添加元素,数组长度变为4

        数组最多可以包含4 294 967 295个项

    3) 检查数组
        var arr = [];
        //输出object
        console.log(typeof(arr));    
        //判断arr是否是数组类型
        console.log(Array.isArray(arr));

    4) 转换数组为字符串
        数组继承Object方法，并且对这些方法进行了重写
        toString();        在默认情况下都会以逗号分隔字符串的形式返回数组项
            例如：
            var arr = ["tom","zs","lisi"];    
            arr.toString()        //tom,zs,lisi

        valueOf(); 在默认情况下以数组字面量的方式显示
            console.log(arr.valueOf());
            console.log(arr);
            俩个输出的结果一样:
                ["tom","zs","lisi"];

        join();    使用指定的字符串用来分隔数组字符串
            例如：
            arr.join("||");        //tom||zs||lisi

    5) 栈，队列方法
        1.栈  LIFO (Last-In-First-Out)
            push() 可接受任意类型的参数，将它们逐个添加到数组的末尾，并返回数组的长度
            pop()     从数组的末尾移除最后一项，减少数组的length值，返回移除的项
        2.队列    FIFO (First-In-First-Out)
            shift()  移除数组中的第一个项并且返回该项，同时将数组的长度减一。
            unshift() 在数组的前端添加任意个项，并返回新数组的长度。

    6) 排序
       reverse()  反转数组项的顺序
       sort()      
         1.默认排序：该方法会调用每个数组项的toString() 转型方法，然后排序
         2.自定义排序：
            a.该方法可以接受一个比较函数作为参数，比较函数有两个参数
            b.如果第一个参数位于第二个参数之前，返回负数
            c.如果第一个参数位于第二个参数之后，返回正数
            var arr = [11,5,23,7,4,1,9,1];
            console.log(arr.sort(compare));

            //该比较函数适合于大多数数据类型
            console.log(arr.sort(function(v1,v2){
                return v1-v2;
            }));

    7) 操作方法
        concat()    :先创建当前数组的一个副本，然后将接收到的参数添加到这个副本的末尾，返回副本
            var arr = ["aa","bb","cc","dd"];
            var arr_new = arr.concat("ee","ff");
            // arr_new = ["aa", "bb", "cc", "dd", "ee", "ff"]
            // arr不改变

        slice()    :可接受一个或者两个参数（返回项的起始位置，结束位置）
            当接受一个参数，从该参数指定的位置开始，到当前数组末尾的所有项
            当接受两个参数，起始到结束之间的项，但是不包含结束位置的项
            例如：
            var arr = ["aa","bb","cc","dd"];
            1.接受一个参数时
              var arr_new = arr.slice(1);
                // arr_new = ["bb", "cc", "dd"];
                // arr 不改变
            2.接受两个参数时
              var arr_new = arr.slice(1,2);    
                // arr_new = ["bb"];
                // arr不改变

        splice()    : 向数组的中插入数据并返回一个数组，该数组中包含从原始数组中删除的项。
            删除：指定两个参数(删除的起始位置，要删除的项数)
            插入：指定三个参数(起始位置，0，要插入的项任意数量的项)
            替换：指定三个参数(起始位置，要删除的项，要插入的任意数量的项)

            例如：
            var arr = ["aa","bb","cc","dd"];
            1.删除
              var del_arr = arr.splice(1,2);
                // arr = ["aa","dd"];     在原数组进行了删除操作
                // del_arr = ["bb","cc"];返回删除的元素数组
            2.插入
              var del_arr = arr.splice(1,0,"ee","ff");
                // arr =  ["aa", "ee", "ff", "bb", "cc", "dd"] 将指定项插入到1位置处
                //del_arr = [], 返回空数组
            3.替换
              var del_arr = arr.splice(1,2,"ee","ff");
                // arr =  ["aa", "ee", "ff", "dd"] 将"bb","cc" 替换成了"ee","ff"
                //del_arr = ["bb", "cc"], 返回删除的元素数组

        indexOf()(要查找的项，开始查找的位置(可选)) 从数组开头向后查找，使用全等操作符，找不到该元素返回-1
            var arr = ["22","11","cc","dd","11"];
            arr.indexOf(11); //返回-1，因为内部使用"==="进行匹配
            arr.indexOf("11"); //返回1，默认从下标为0往后匹配，返回第一个匹配元素的位置
            arr.indexOf("11",2); //返回4，从下标为2开始往后匹配，返回第一个匹配元素的位置
        lastIndexOf()(要查找的项，开始查找的位置(可选)) 从数组末尾向前查找，使用全等操作符，找不到该元素返回-1
            var arr = ["22","11","cc","dd","11"];
            arr.lastIndexOf("11"); //返回4，默认从下标为4往前匹配，返回第一个匹配元素的位置
            arr.lastIndexOf("11",2); //返回1，从下标为2往前匹配，返回第一个匹配元素的位置