创建对象

var a = {},
 b = {x: 0, y: 1},
 c = {x: b.x, y: b.y},
 d = {
 name: 'UMEI',
 year: 2,
 member: {
 'CEO': 'xu',
 'CTO': 'yonnie'
 }
 }

var a = new Object(),
 b = new Array(),
 c = new Date()

var a = Object.create({x: 1, y: 1});
a继承了x和y属性

//inherit()返回了一个继承自原型对像p的属性的新对象
//这里使用es5中的Object.create()函数
//如果不存在Object.create()则使用其他方法
function inherit(p){
 if(p == null) throw TypeError(); //p如果是null或者undefined 抛出类型错误
 if(Object.create) //如果存在create方法,则使用create
 return Object.create(p);
 var t = typeof p;
 if(t !== "object" && t !== "function"){
 throw TypeError();
 }
 function f(){};
 f.prototype = p;
 return new f();
}

属性的查询和设置

继承

var o = {};
o.x = 1;
var p = inherit(o);
p.y = 2;
var q = inherit(p);
p.z = 3;
var s = q.toString();//toString继承自Object.prototype
q.x + q.y; //--> 3, x和y分别继承自o和p
q.x = 4; //会覆盖q继承的x属性,o的x属性不会变

属性访问错误

Object.prototype = 1; //不会报错,但是没被修改为1

删除属性

var a = {p: {x: 1}},
 b = a.p;
 
delete a.p;
console.log(b.x); //--> 删除了a.p属性,但是b.x的值还是1

delete Object.prototype //不能删除,属性不可配置
var x = 1;
delete this.x; //返回false
delete x; //返回false
function f(){
}
delete this.f; //不能删除全局函数

检测属性

var o = {x: 1};
'x' in o; //true
'y' in o; //false
'toString' in o; //true 继承的属性

var o = {x: 1}
o.hasOwnProperty('x'); //true
o.hasOwnProperty('y'); //false
o.hasOwnProperty('toString'); //false

var o = inherit({y: 2});
o.x = 1;
o.propertyIsEnumerable('y'); //false
o.propertyIsEnumerable('x'); //true
Object.prototype.propertyIsEnumerable('toString'); //false toString不可枚举

var o = {x: 1, y: undefined};
'x' in o; //true
'y' in o; //true
'z' in o; //false
delete o.x
'x' in o; //false

枚举属性

var o = {
 x: 1,
 y: 2,
 z: 3,
 test: function(){
 console.log('test')
 }
},
 p = Object.create(o);
 
for(i in p){
 console.log(i); //--> x,y,z,test; 继承自o的属性都是可枚举的, 没有toString
}
 

function extend(o, p){
 for (prop in p){
 o[prop] = p[prop]; //遍历p中的所有属性,将属性添加至o中
 }
 return o;
}
/*
*将p中的可枚举属性复制到o中,并返回o
*如果o和p中有同名的属性,o中的属性将不受影响。
*这个函数并不处理getter和setter以及复制属性
*
*/
function merge(o, p){
 for(prop in p){
 if(o.hasOwnProperty(prop)) continue; //过滤掉已经在o中存在的属性
 o[prop] = p[prop]
 }
 
 return o
}
/*
*如果o中的属性在p中没有同名属性,则从o中删除这个 属性
*返回o
*/
function restrict(o, p){
 for(prop in o){
 if(!(prop in p)) delete o[prop]; //如果在p中不存在,则删除之
 }
 return o;
}
/*
*如果o中的属性在p中存在同名属性,则从o中删除这个属性
*返回o
*/
function(o, p){
 for(prop in p){
 delete o[prop]
 }
 return o;
}
/*
*返回一个新对象,这个对象同时拥有o的属性和p的属性
*如果o和p有重名属性,使用p中的属性值
*/
function union(o, p){
 return extend(extend({}, o), p);
}
/*
*返回一个新对象, 这个对象拥有同时再o和p中竖线的属性
*很想求o和p的交集,但p中属性的值被忽略
*/
function intersection(o, p){
 return restrict(extend({}, o), p);
}
/*
*返回一个数组,这个数组包含的是o中可枚举的自有属性的名字
*/
function keys(o){
 if(typeof o !== 'object') throw TypeError();
 var result = [];
 for(var prop in o){
 if(o.hasOwnProperty(prop))
 result.push(prop);
 }
 return result;
}

属性getter和setter

var o = {
 //普通的数据属性
 data_drop: 1,
 
 //存取器属性
 get accessor_prop(){
 //函数体
 },
 
 set accessor_prop(value){
 //函数体
 }
 
}

var p = {
 x: 1.0,
 y: 1.0,
 
 get r(){
 return Math.sqrt(this.x*this.x + this.y*this.y)
 },
 set r(new_value){
 var old_value = this.x*this.x + this.y*this.y,
 ratio = new_value/old_value;
 this.x *= ratio;
 this.y *= ratio;
 },
 
 get theta(){
 return Math.atan2(this.y, this.x);
 }
}

var q = inherit(p);
q.x = 1, q.y = 1;
console.log(q.r); //可以使用继承的存取器属性

属性的特性

//返回{value: 1, writable: true, enumerable: true, configurable: true}
Object.getOwnPropertyDescriptor({x: 1}, 'x');
var a = {
 get random(){
 return Math.random()
 }
}
//{get: function random(), set: undefined, configurable: true, enumerable: true}
Object.getOwnPropertyDescriptor(a, 'random');
//对于继承属性没返回undefined
Object.getOwnPropertyDescriptor({}, 'toString'); //undefined

var o = {};
Object.defineProperty(o, 'x', {
 value: 1,
 writable: true,
 enumerable: false,
 configurable: true
});
o.x; //-->1 属性存在
Object.keys(o); //--> [] 但是不可枚举
//设置属性只读
Object.defineProperty(o, 'x', {
 writable: false
});
o.x = 2 //操作失败,在严格模式中会报错
//虽然属性只读,但是依然可以通过配置来修改属性的值
Object.defineProperty(o, 'x', {
 value: 2
});
o.x; //2
//将x从数据属性修改成存取器属性
Object.defineProperty(o, 'x', {
 get: function(){
 return 0;
 }
});

var p = Object.defineProperties({}, {
 x: {
 value: 1,
 writable: true,
 enumerable: true,
 configurable: true
 },
 y: {
 value: 1,
 writable: true,
 enumerable: true,
 configurable: true
 },
 r: {
 get: function(){
 return Math.sqrt(this.x*this.x + this.y*this.y)
 },
 enumerable: true,
 configurable: true
 }
})

对象的三个属性

var p = {x: 1},
 o = Object.create(p);
 
p.isPrototypeOf(o); //true
Object.prototype.isPrototypeOf(o) //true

序列化对象

对象方法