4-复杂数据类型和函数

1. 复杂数据类型 Object（对象）
    ECMAScript中的对象其实就是一组数据(属性)和功能(方法)的集合。
    1) 创建（对象）Object实例：
        1.使用构造函数创建，new Object()
            var person = new Object();
            person.name = "briup";
            person.age = 22;

        2.使用对象字面量表示法
            不同的属性之间用','分割，属性名和属性值之间用':'分割
            var person = {
                name : "briup",
                age : 22
            };  （最后一定要加分号结束）
    2) 访问对象属性
        1.点表示法，右侧必须是以属性名称命名的简单标识符
            person.name
        2.中括号表示法，中括号中必须是一个计算结果为字符串的表达式，可以通过变量访问属性，如果属性名中包含语法错误的字符，或者属性名使用的是关键字或保留字，可以使用中括号    person["first name"]
            var a = "name";
            person[a];    //既person["name"]
            person["first name"]
            
    3) 删除属性
        delete只是断开了属性和宿主对象的联系，而不会操作属性中的属性，并且delete只会删除自有属性，不能删除继承属性。在销毁对象时，为了防止内存泄露，遍历对象中的属性，依次删除所有属性。
         语法：delete 属性访问表达式
            例如：
            delete stu.name  //删除学生对象中的name属性
    4) 检测属性
        in 检测某属性是否是某对象的自有属性或者是继承属性
            "toString" in student
        hasOwnProperty()检测给定的属性是否是对象的自有属性，对于继承属性将返回false
            var o = {
                x:1
            }
            o.hasOwnProperty("x");    //true, x 为o的自有属性
            o.hasOwnProperty("y");    //false,o 中不存在属性y
            o.hasOwnProperty("toString");    //toString为继承属性
        propertyIsEnumerable() 检测给定的属性是否是该对象的自有属性，并且该属性是可枚举的通常由JS代码创建的属性都是可枚举的，但是可以使用特殊的方法改变可枚举性。
            student.propertyIsEnumerable("toString")    //false 不可枚举
    5) Object属性及方法
       Object 类型所具有的任何属性和方法也同样存在于其他对象中，任何对象继承于Object对象
       Object中常用的方法：
            hasOwnProperty(propertyName);    
                检查给定的属性名是否是对象的自有属性，
            toString();        
                返回对象的字符串表示
            valueOf();        
                返回对象的字符串，数值，布尔值的表示。
            propertyIsEnumerable(propertyName);    
                检查给定的属性在当前对象实例中是否存在
            constructor:            
                保存用户创建当前对象的函数
            isPrototypeOf(object);        
                检查传入的对象是否是原型
            toLocaleString();    
                返回对象的字符串表示，该字符串与执行环境的地区对应
    6) 对象序列化
        对象序列化是指将对象的状态转换为字符串，也可以反序列化，将字符串还原为对象函数，RegExp,Error对象，undefined值不能序列化和反序列化。
        JSON.stringify(obj)  
            将对象序列化为Json字符串,只能序列化对象可枚举的自有属性。
        JSON.parse(jsonStr)  
            反序列化   JSON.parse将字符串解析为对象

2. 函数（第二部分）
    1) 作为值的函数
        由于函数名本身就是变量，所以函数可以当做值来使用（参数，返回值）。
        function callOther(fun,args){
            return fun(args);
        }
        function show(msg){
            alert(msg);
        }
        callOther(show,"哈哈"); //show为参数
    2) 作为返回值的函数
        eg:多功能自定义排序函数
        function myCompare(pro){
            //函数将作为返回值返回
            return function(obj1,obj2){
                var val1 = obj1[pro];
                var val2 = obj2[pro];
                if(val1<val2){
                    return -1;
                }else if(val1>val2){
                    return 1;
                }else {
                    return 0;
                }
            }
        }
        var data = [
            {
                name : "aaa",
                age :12
            },{
                name:"ccc",
                age : 8
            },{
                name :"bbb",
                age : 71
            }
        ];
        console.log(data);
        data.sort(myCompare("age"));
        console.log(data);
    3) 函数内部属性
        1. arguments :是类数组对象，包含着传入函数中参数，arguments对象还有一个callee的属性，用来指向拥有这个arguments对象的函数
            
            例如：
            num的阶乘，使用递归函数
            function factorial(num){
                if(num<=1){
                    return 1;
                }else{
                    //return num * factorial(num-1);
                    return num * arguments.callee(num-1);
                }
            }
        2. this: 指向的是函数赖以执行的环境（上下文）对象  this指向widow
          window.color = "window";
          var person = {
            color:"person"
          };

          function sayColor(){
            alert(this.color);
          }
          sayColor();  //window对象调用，所以弹出 "window"
          person.sayColor = sayColor; //将该方法赋给person对象
          person.sayColor();//使用person对象调用该方法，弹出"window"
    4) 函数的属性
        length: 表示函数希望接受的命名参数的个数
        function say(msg){} //say.length 1 希望接受一个参数
        function add(m,n){} //add.length 2 希望接受两个参数
        prototype: 保存实例方法的真正所在。在自定义引用数据类型以及继承时非常重要。
    5) 函数的方法
        this->该函数所在的环境对象
        <script>
            var person = {
                name:"terry",
                add:function(){
                    
                }
            }
            person.add();

            function add(a,b){
                alert(a+b);
            }
            add(1,2);// this->window
            =>
            add.call(window,1,2);
        </script>
        

        所有的构造函数首字母大写  （一定！！）
        apply ： 参数（在其中运行函数的作用域，参数数组（Array,arguments））；
        call  ： 参数（在其中运行函数的作用域，参数列表）
        这两个方法作用都是在特定的作用域中调用函数，实际上等于设置函数内部的this的值

        用法一：
            function sum(m,n){
                return m+n;
            }
            function call(m,n){
                //return sum.apply(this,arguments);
                return sum.call(this,m,n);
            }
            alert(call(1,2));    
        用法二：
           扩充函数赖以运行的作用域
           window.color = "window";
           var person = {
            color:"person"
           };

           function sayColor(){
            alert(this.color);
           }
           sayColor.call(this);
           sayColor.call(window);
           sayColor.call(person);
    核心对象 ：Object  Date Function Array   等等

3. 基本数据类型，引用数据类型
    基本数据类型的变量：
        可以直接操作保存在变量中的实际的值
        参数传递的时候传递的是实际值
    引用数据类型的变量：  
        不能直接操作对象的内存空间，实际上是在操作对象的引用。
        可以为引用类型变量天极爱属性和方法，也可以改变和删除其属性和方法
        参数传递的时候传递的是引用地址。
    值传递
        值的拷贝
    引用传递

        引用地址的拷贝

******************************************************************

JS基础语句

1. 分支语句
    if(condition){
        
    }

    if(condition){
        
    }else{
        
    }
    => condition?s1:s2

    if(){
    
    }else if(){
    
    }else if(){
    
    }else{
    
    }

    switch(condition){
        case val1:
            //s1
        break;
        case val2:
            //s2
        break;
        case val3:
            //s3
        break;
        default:
            
    }
    比较方式  ===   condition === val1
    default   可以位于任意位置，不管位于哪里，都表示其他case不满足的情况下，执行default,如果default不是位于代码尾，必须加break


2. 循环语句
    初始化条件
    结束判断条件
    迭代条件
    1)for循环
        for(var i = 0;i<=100;i++){
            console.log(i);
        }
    2)while循环
        while(结束判断条件){
            
        }
        while(true){
            break;
        }
    3)do-while循环
        do{
        
        }while();

    4)for-in循环
        用于循环对象的属性
        var person= {
            name:"terry",
            age: 12
        }
        for(var a in person){
            var b = person[a];
            console.log(a);
        }
    continue    
    break
    a:while(true){
        break a;
    }



3. 对象
    所有对象都直接间接继承Object
        Object{
            toString();
            valueOf();
            hasOwnProperty();
            propertyIsEnumerable();
        }
    1. 对象的定义
        对象是属性和方法的集合
    2. 对象的表示
        1)构造函数法
            var p1 = new Object();
            p1.name = "terry";
            p1.age = 12;
            p1.gender ="男";
            p1.sayName = function(){
                alert("my name is:"+this.name);
            }
            p1.sayAge = function(){
                alert("my age is:"+this.age);
            }
            

        2)对象字面量法(JSON) 一个对象可以对应多个属性和方法！！！
            var p2 = {
                name:"larry",
                age:14,
                gender:"男",
                sayName:function(){
                    alert("my name is:"+this.name);
                },
                sayAge:function(){
                    alert("my age is:"+this.age);
                }
            };

    3. 对象的属性访问
        1)点访问法
            p1.name
            p1.age

            var a = "name";
            p1.a
        2)中括号访问法
            支持变量的访问
            p1["name"]
            ==>
            var a = "name";
            p1[a]

    4. 对象的方法访问
        1) 点访问法
            p1.sayName();
            p1.sayName.call(this,a,b);
            p2.sayName.apply(this,[a,b]);
    5. 动态删除和动态添加属性
        删除
            delete 对象名.属性名
    
    6. 对象的属性检测
        1) in   
            属性名 in 对象
            如果该属性存在于(自有以及继承)对象中，返回true
        2) hasOwnProperty()
            对象.hasOwnProperty(属性名)
            当属性名为自有属性的时候，返回true

        ===========================
        class Person{
            private String name;
            private int age;
            public void sayName(){
                syso(this.name);
            }
            public void sayAge(){
                syso(this.age);
            }
        }
        Person p = new Person();
        p.gender = "男";
        Java属性不支持动态添加和动态删除，而在JS中允许
        ===========================


4. 函数
    1.作用：封装实现过程
    2.定义方式：
        函数声明
            function 函数名(形式参数){
                函数体
            }
            <script>
                add(1,2);
                add();

                function add(a, b){
                    return a+b;
                }
                
            </script>

        函数表达式
            add();//报错
            var add = function(){
            
            }
            add();//只能写后面，不然报错
            
            
    3.函数调用
        1) 函数名(实参列表);

    4.函数的内部属性
        1）arugments.callee.  指向的是当前函数
            类数组对象，像数组
            自己属性  callee->指向当前arguments 的函数/任何函数都拥有arguments的函数

        function add(a,b){
            console.log(a,b);
            console.log(arguments);
        }
        add(1,2);
        add();

        数组：存放多个任何数据类型值的集合
        var arr = [10,9,8,7,0,4];
        
        2）this
            指向当前函数赖以生存的变量对象

    5. 作为值的函数
        函数可以当做参数使用  function-当做参数来使用
    6. 作为返回值的函数
        函数可以当做返回值来使用  function-当做返回值使用

    7. 函数的外部属性
        function add(){
        
        }
        add();
        add.length

        var person = {
            name:"terry"
        }
        person.name
        
        函数本质是一个对象，所有的对象直接或间接继承Object,Object中存在的方法，在所有的子对象中都存在
        Object:
            toString();
            valueOf();
            ...
    8. 函数方法
        add();