js的对象

//1 创建变量坑 会将局部变量暴露为全局变量
        function foo(){
            var aa=bb=2;//这种创建方法导致bb是一个全局变量
            console.log(aa,bb);
        }
        foo();
        console.log(typeof aa);//undefined
        console.log(typeof bb);//number

        //8  函数声明和函数表达式的不同
        // func1();//函数声明会预先被处理 所以可以在前面调用
        // func2();//函数表达式预先不会被处理 所以不可以在前面调用 会报错
        // function func1(){

        // }

        // var func2=function(){

        // }
        //

        //2  检验对象上的属性
        var obj = Object.create({x:11});//说明创建一个原型链上的对象
        console.log(obj.hasOwnProperty("x"));//false
        console.log("x" in obj);//true

        function Cat(){

        }
        var cat1=new Cat();
        console.log(Cat.prototype.__proto__.__proto__);//null
        cat1.legs="4";
        cat1.mouse="1";
        //for...in语句以任意顺序遍历一个对象的可枚举属性。对于每个不同的属性，语句都会被执行。
        //使用hasOwnProperty方法会筛选出原型对象的属性 
        for (const key in cat1) {
            if (cat1.hasOwnProperty(key)) {
                const element = cat1[key];
                console.log(element);
            }
        } 

     

        //3
        function foo(){

        };
        Object.defineProperty(foo,"z",{
            value:100,
            writable:true //设置为true就是可写的 可修改 设置为false就是不可写 不可修改 默认是false
        })
        var obj=new foo();
        obj.z=1
        console.log(obj.z);

        //4 使用Object.create创建对象 是prototype
       var t=Object.create({name:"tom"});
       console.log(t.__proto__.name);//tom

       var ttt={
           $age:111,
           get age(){
               return this.$age
           },

           set age(val){
               return this.$age=val
           }
       }

       console.log(ttt.age);//111
       ttt.age=10;
       console.log(ttt.age);//10
       //14 js的属性标签
       var tt={};
       Object.defineProperty(tt,"name",{
           value:"张三",
           enumerable:false,  //可枚举属性 是否可以被for in循环得到默认是false 
           configurable:false,//是否可以被delete运算符删除 默认是false
           writable:false     //是否可修改 默认是false
       });
       //可以同时定义多个属性
       Object.defineProperties(tt,{
           age:{value:11},
           ishuman:{value:false},
           salary:{value:100000,writable:true},
           promote:{
               set:function(level){
                   this.salary*=1+level*0.1 
               }
           },
       })
       console.log(tt.salary+"====");//100000
       tt.promote=10 //把salary属性加上writable:true标签后 这个属性才可以被修改
       console.log(tt.salary);//200000 
       console.log(tt.hasOwnProperty("name"));//true 说明通过defineProperty创建的对象属性不是prototype属性
       //使用getOwnPropertyDescriptor可以得到一个对象的属性的详细标签情况 
       console.log(Object.getOwnPropertyDescriptor(tt,"name"));//{value: "张三", writable: false, enumerable: false, configurable: false}
    

       var tttt={name:"tom",age:"s11"};
       console.log(Object.getOwnPropertyDescriptor(tttt,"name"));//{value: "tom", writable: true, enumerable: true, configurable: true}
       Object.freeze(tttt);
       console.log(Object.getOwnPropertyDescriptor(tttt,"name"));//{value: "tom", writable: false, enumerable: true, configurable: false}
                                                                 //此时的writable和configurable属性变成false 这个属性不可修改和删除
    
                                                                      
       //5 对象的序列化和可定制化
       var json={
           x:"x",
           y:"y",
           o:{
               o1:"o1",
               o2:"02"
           }
       }

       console.log(JSON.stringify(json));//{"x":"x","y":"y","o":{"o1":"o1","o2":"02"}}
       json={
           x:"x",
           y:"y",
           o:{
               o1:"o1",
               o2:"02",
               toJSON:function(){  //固定表达 只能是toJSON
                   return this.o1+this.o2
               }
           }
       }
       console.log(JSON.stringify(json));//{"x":"x","y":"y","o":"o102"}