JavaScript的进阶之路（四）理解对象2

最新推荐文章于 2024-11-09 12:22:36 发布

diken1935

最新推荐文章于 2024-11-09 12:22:36 发布

阅读量88

点赞数

文章标签： json javascript ViewUI

原文链接：http://www.cnblogs.com/wow1314/p/8399723.html

版权

对象的三个属性

原型属性

1、var v={}的原型是Object.prototype;继承了一个constructor属性指代Object()构造函数，实际的原型是constructor.prototype
2、var v = new Person()的原型是构造函数Person()的prototype属性;继承了一个constructor属性指代构造函数Person();
3、Object.create()创建的对象使用第一个参数（也可以是null）作为对象的原型;也继承了一个constructor属性指代Object()构造函数，但真正原型往往不是。
4、通过原型继承创建一个新对象原型为p

//通过原型继承创建一个新对象  原型为p
            function inherit(p){
                if(p==null){
                    throw TypeError();
                }
                if(Object.create){
                    return Object.create(p);
                }else{
                    var t= typeof(p);
                    if(t!=="object" && t!== "function"){
                        throw TypeError();
                    }else{
                        function f(){};
                        f.prototype=p;
                        return new f();
                    }
                }                
            }

5、在ECMAScript5中，使用Object.getPrototypeOf(obj)查询对象的原型; 在ECMAScript3中，使用obj.constructor.prototype来检测对象的原型;
6、 isPrototypeOf() 检测对象是否是另一个对象的原型（或处于原型链中）。_proto_属性并不推荐使用，有诸多限制。

var o={x:1};
var o1 = Object.create(o);
console.log(o.isPrototypeOf(o1)); //true
console.log(Object.prototype.isPrototypeOf(o1)); //true

类属性

对象的类属性是一个字符串，用以标识对象的类型信息。不能设置，可以通过toString()方法查询（这个方法继承自Object.prototype），然后提取第8个到倒数第2个位置之间的字符。
但是，由于很多toString()方法都被重写了，因此需要调用call()方法返回该对象的类。

//写一个处理函数
            function classof(o){
                if(o===null) return "Null";
                if(o===undefined) return "Undefined";
                return Object.prototype.toString.call(o).slice(8,-1);
            }
            console.log(classof(null)); // Null
            console.log(classof(1));    // Number
            console.log(classof(""));   // String
            console.log(classof(false));// Boolean
            console.log(classof({}));   // Object
            console.log(classof([]));   // Array
            console.log(classof(/./));  //RegExp
            console.log(classof(new Date())); // Date
            console.log(classof(window));  //Window客户端宿主对象
            function f(){}; //自定义构造函数
            console.log(classof(new f())); // Object

可扩展性

1、对象的可扩展性用以表示是否可以给对象添加新属性。所有内置对象和自定义对象都是可扩展的，宿主对象的可扩展性是由JavaScript引擎定义的。
2、通过Object.isExtensible(obj)来判断该对象是够可以扩展。
   通过Object.preventExtensions(obj)将对象转换为不可以扩展，但可以通过原型继续继承
  （意思是给该对象的原型添加属性，该对象同样会继承这些新属性）。
3、可扩展的目的是将对象进行锁定，避免外界干扰。通常与对象对象的可配值性和可写性配合使用。
4、通过Object.seal()方法封闭对象，使用Object.isSealed()检测对象是否封闭。
5、通过Object.freeze()方法更严格的冻结对象，使用Object.isFrozen()方法来检测对象是否冻结。冻结对setter方法无效。
6、Object.preventExtensions()、Object.seal()、Object.freeze()均返回传入的对象 可以通过函数嵌套的方式调用他们。

var o = Object.seal(Object.create(Object.freeze({x:1}),{y:{value:2,writable:true}})); 
console.log(o);  //{y:2}

序列化对象

对象的序列化是指将对象的状态转换为字符串，也可以将字符串还原为对象。

//序列化对象在ECMA3中实现需要引入json2.js文件
            var o = {x:1,y:{z:[false,null,""]}};//定义一个测试对象
            var s = JSON.stringify(o);          //序列化对象 ，只能搞定对象可枚举的自有属性，不能序列化的将忽略掉
            var p = JSON.parse(s);              //反序列化 p是o的深拷贝

对象的方法:除了自定义，主要来自继承自Object.prototype里的对象方法
- toString()方法：返回表示调用这个方法的对象值得字符串。默认的toString()方法返回值信息量很少，大部分需要自定义类重写这个方法。
- toLocaleString()方法：返回表示这个对象的本地化字符串。Object中默认的toLocaleString()方法不做任何本地化自身的操作，仅调用toString()，象数字、日期、时间有本地化的转换。数组中的每个元素会调用toLocaleString()方法转换为字符串。
- toJSON()方法：一般没用，只是在执行序列化方法JSON.stringify()方法的时候调用了一下toJSON();返回值是序列化的结果。参见Date.toJSON();
- valueOf()方法：基本和toString()方法类似，需要将对象转换为某种原始值而非字符串的时候调用，如转为数字的时候。很多内置类自定义了这个方法，如Date.valueOf();

总结：

            //定义一个测试对象
            var o = {x:1,y:{z:[false,null,""]}};
            //instanceof表示是否是某个构造函数的实例
            console.log(o instanceof Object);
            //获得对象的原型
            console.log(Object.getPrototypeOf(o));
            //设置对象的原型，返回一个新对象
            //参数第一个是现有对象，第二个是原型对象。等同于var b = {__proto__: o};
            var b = Object.setPrototypeOf({}, o);
            //检测自有属性的方法
            console.log(o.hasOwnProperty("x"));   
            //检测可枚举的自有属性的方法
            console.log(o.propertyIsEnumerable("x")); 
            //返回一个数组，由对象中可枚举的自有属性的名称组成
            console.log(Object.keys(o)); 
            //返回一个数组，由对象中所有自有属性的名称组成
            console.log(Object.getOwnPropertyNames(o)); 
            //获得自有属性的特性
            console.log(Object.getOwnPropertyDescriptor(o,"x"));  
            //设置属性的特性Object.defineProperty Object.defineProperties()
            Object.defineProperty(o,"x",{value:"欧红",writable:true,numerable:false,configurable:true});    
            Object.defineProperties(o,
                {
                    "x":{value:"欧红",writable:true,numerable:false,configurable:true},
                    "y":{value:18,writable:true,numerable:false,configurable:true}
                }
            );
            //封闭对象的属性:可以修改但是不能删除和扩展
            Object.seal(o);
            //冻结对象的属性：不能修改 删除 扩展
            Object.freeze(o);
            //Object构造函数里定义的静态函数 创建一个新对象
            var o1 = Object.create(o);
            //true  判断是否是原型
            console.log(o.isPrototypeOf(o1)); 
            console.log(Object.prototype.isPrototypeOf(o1));
            //判断是否能扩展
            console.log(Object.isExtensible(o)); 
            //将对象转换为不可扩展
            Object.preventExtensions(o);  
             //序列化对象 ，只能搞定对象可枚举的自有属性，不能序列化的将忽略掉
            var s = JSON.stringify(o);  
            //反序列化 p是o的深拷贝
            var p = JSON.parse(s);                  
            //获取对象的类属性
            function classof(o){
                if(o===null) return "Null";
                if(o===undefined) return "Undefined";
                return Object.prototype.toString.call(o).slice(8,-1);
            }