JavaScript 面向对象的学习记录（上）

内容预览

              1.对象的创建

              2.对象属性的查询和修改

              3.对象的数据属性和存储属性

              4.对象的原型

              5.对象的类型

              6.对象的扩展

【一】对象的创建

           1.通过对象字面量的形式创建对象      

         var obj2 = {
                'x':1,
                "y":2,
                username:'king',
                'for':'javacript关键字必须放到引号之间',
                'firsr-name':'quen',
                married:true,
                test:null,
                test1:undefined,
                person:{
                    username:'kingking',
                    age:23,
                    addr:'北京'
                }
           } 

         

           2.通过new Object 创建对象

          var obj3 = new Object();//创建空对象
          var arr = new Array();//创建数组对象
          var date = new Date();// 创建日期时间对象

         

           3.通过构造函数的形式创建对象

          //无参构造器
          function Test(){

          }
          var obj4 = new Test();

          //有参构造器
          function Test1(num1,num2){
            this.n1=num1;
            this.n2 = num2;
          }
          var obj5 = new Test1(5,6);
         
         //通过 instanceof 操作符检测一个对象是否由某个指定的构造器创建
         alert(obj5 instanceof Test1);

 

           4.通过 Object.create 创建对象

        var obj6 = Object.create({x:1});
        //传入null 创建无原型的对象，不继承任何其他对象
        var obj7 = Object.create(null);
        //创建一个普通的空对象
        var obj8 = Object.create(Object.prototype);

【二】对象属性的查询和修改            

       var person={
            username:'king',
            age:12,
            salary:12345,
            addr:'北京',
            sex:'男',
            saihi:function(){
                return 'say hi';
            },
            info:function(){
                return this.name;
            }
        }
        //两种方式查询属性 
        alert(person.username);
        alert(person['salary']);
        var key = 'age';
        alert(person.key);//错误的取值
        alert(person[key]);//这种情况下只能这样去取，如果属性不确定时需要[] 去取


        //两种方式添加或者修改属性
        person.test = 'test';
        person['test1']='test1';

        //通过 delete 删除指定属性
        delete.person.test;

        //通过for/in 遍历属性
        for (var p in person) {
            console.log(p+'\n');
        }
        
        //调对象的方法
        console.log(person.saihi());
        console.log(person.info());

【三】对象的数据属性和存储属性

          1.数据属性 （4个描述行为的特性）

             writable          表示是否能修改属性的值，默认为true
             Enumerable   表示能否通过 for in 循环返回属性，代表属性是否可以枚举
             configurable   表示是否能delete，能否把属性修改为访问器属性，
             value              属性的值

             

       var obj2 = {};
         Object.defineProperty(obj2,'y',{
             value:55,
             writable:true,//代表是否可写
             enumerable:false,//代表是否可枚举
             configurable:false//是否可配置
         });

         // 一次可定义多个属性
         Object.defineProperty(obj2,{
             'username':{
                value:'king',
                writable:true,//代表是否可写
                enumerable:false,//代表是否可枚举
                configurable:false//是否可配置
             },
             'age':{
                value:12,
                writable:true,//代表是否可写
             }
         });

 
         var obj9={
            _proto_:null,//保证没有继承而来的属性
            value:1
        }

        2.存储属性 

       var obj10= {
            x:1,
            y:2,
            z:3,
            get zhouchang(){
                  return this.x+this.y+this.z;
            },
            set fabzc(val){
                 this.x*=val;
                 this.y*=val;
                 this.z*=val;
            }
        }

【四】对象的原型

       // 通过对象字面量创建的对象使用Object.prototype作为他们的原型
       // 通过new 创建的对象使用构造函数的prototype属性作为他们的原型
       // 通过Object.create()创建d的对象使用第一个参数（也可以是null）作为 它们的原型

       //检测一个对象是否是另一个对象的原型（或者处于原型链中）
       var obj={x:1};
       var oo = Object.create(obj);
       console.log(obj.isPrototypeof(oo));
       console.log(Object.prototype.isPrototypeof(obj1));

【五】对象的类型

       var obj={}；
       console.log(obj.toString()); //结果输出：[Object Object]
       var arr=new Array();
       console.log(Object.prototype.toString.call(arr)); 
       //结果输出：[Object Array],注意这里,
       // 内建对象重写了toString方法，所以需要用原型的call方法去回调


       //获取对象类型
        function classof(obj){
            if (obj===null) {
              return 'null';
            }
            if (obj===undefined) {
              return 'Undefined';
            }
            return Object.prototype.toString.call(obj).slice(8,-1);
        }
    
        var x = null;
        x = undefined;
        x = 123;
        x = true;
        x = 'king';
        x = [];
        console.log(classof(x));//结果分别为 null/undefined/number/boolean/String/Array

【六】对象的扩展  

      //用isExtensible检测对象是否可扩展
      var d = new Date();
      console.log(Object.isExtensible(d));//输出 true

      //用 prevenExtensions 将对象变为不可扩展的(不可添加属性和方法)
      var obj={};
      obje1 = Object.prevenExtensions(obj);
      
      //Object.seal 和  Object.prevenExtensions 类似，除了能够设置为不可扩展的，还可以将对象的所有自身属性
      //都设置为不可配置的，也就说不能给这个对象添加属性且不能删除或者配置已有属性。
      //通过 Object.isSealed 可检测对象是否封闭 （一个对象被封闭之后不可解封）
      var  obj = {
        x:1,
        y:2,
        username:'king'
      }
      var o = Object.seal(obj);//通过 seal 方法封闭函数 
      console.log(Object.isSealed(o)); //检测对象是否封闭


      //Object.freeze() 将更严格的锁定对象--冻结，除了对象设置为不可扩展的和将其属性设置为不可配置之外，
      //还可以将它自身的所有数据属性设置为只读（如果对象的存储器属性具有setter方法，存取器属性将不受影响，仍
      //可以通过它给属性赋值）
      //通过Object.isFroze()来检测对象是否已经被冻结
      var obj = {
        prop:function(){},
        foo:'king'
      }
      obj.test='this is a test';
      delete obj.prop;
      var o = Object.freeze(obj); //通过 freeze 方法封闭函数 
      console.log(Object.isFroze(o)); //检测对象是否已冻结