枚举对象的属性：通常用for(...in...)来循环遍历，由于 for in 总是要遍历整个原型链，因此如果一个对象的继承层次太深的话会影响性能
for(var i in foo){
if(foo.hasOwnProperty(i)){
console.log(i);
}
}
推荐总是在for in使用 hasOwnProperty，因为类库被包含在页面中时，不使用 hasOwnProperty 过滤的 for in循环难免会出问题。
p.hasOwnProperty('x') //检查对象p是否含有自有属性x，若x是继承属性则返回false
p.propertyIsEnmuerable('x') //检查属性x是否可被枚举
对象继承来的内置方法是不可枚举的，如：toString()
自行添加的属性均是可枚举的，除非被转为不可枚举；
Object.keys() 返回一个数组，一个由对象的所有可枚举属性的名字组成的数组；
Object.getOwnPropertyNames() 返回所有自有属性名称组成的数组；
function anotherKeys(o){
if(typeof o !== 'object') throw TypeError;
var result = [];
for(var prop in o){
if(o.hasOwnProperty(prop)) result.push(prop);
}
return result;
}
get和set：可将属性定义为只读、只写、可读可写，如：
var f = {
i:0,
get a(){
return this.i;
},
set a(newValue){
this.i = newValue;
}
}
数据属性、存取器属性
数据属性的4个特性：value、 writable、 enumerable、 configurable；
存取器属性的4个特性：get、 set、 enumerable、 configurable；
属性描述符对象( property descriptor)，它的属性名就是这4个特性名；
Object.getOwnPropertyDescriptor(p,'x') 返回p的自有属性x的描述符对象{value:3,writable:true,enumerable:true,configurable:true}
新建属性时，要想它同时具有某种特性，需要调用Object.defineProperty(p,'x',propotyDescriptor)
同时修改多个属性：Object.definePropoties(p,{x:propotyDecriptor,y:propotyDescriptor,....})
//为新对象p设置属性
var p = Object.defineProperties({},{
x:{value:1,writable:true,enumerable:true,configurable:true},
y:{value:3,writable:true,enumerable:true,configurable:true},
r:{
get:function(){return this.x},
set:function(value){this.x=value*2},
enumerable:true,
configurable:true
}
});
//给Object.prototype添加一个extend()方法,任何对象都是继承自Object,所以任何对象都能调用该方法
Object.defineProperty(Object.prototype,'extend',{
writable:true,
enumerable:false,
configurable:false,
value:function(o){
var names = Object.getOwnPropertyNames(o);
for(var i=0;i<names.length;i++){
if(names[i] in this) continue;
var desc = Object.getOwnPropertyDescriptor(o,names[i]);
Object.defineProperty(this,names[i],desc);
}
}
});
var p1 = {a:1,b:2};
var p2 = {};
p2.extend(p1);
console.log('a' in p2); //true
属性4个特性修改规则：
1.若对象不可扩展，则不能创建新属性，只能更改已有属性；
2.若属性为不可配置的，即configurable:false，则不能更改可配置性、可枚举性等所有特性，包括不能把数据属性和存取属性相互转换，但是唯一可以改的就是：将可写性从true改为false，相反则不行；
使用Object.definePropoty()或Object.definePropoties()时违反以上规则，会抛出类型错误异常；
对象的三个属性
每个对象都有与之相关的三个属性：原型属性prototype，类属性class，可扩展性extensible；
对象的原型属性prototype是用来继承属性的，通过对象直接量创建的对象的原型是Object.prototype，通过new创建的对象的原型是构造函数的prototype，通过Object.create(p)创建的对象使用参数p作为它的原型;
不管以何种方式创建的对象都有一个constructor属性，指代原型的构造函数，因此对象的真正原型是constructor.prototype;
Object.getPrototypeOf(p)可以查询对象p的原型，用p.isPrototypeOf(o)来检测对象p是否是对象o的原型；
对象的类属性为一个字符串，表示对象的类型信息，默认的toString()方法返回字符串[object class]，然后通过对字符串执行slice(8,-1)来提取对象的类型信息
function classOf(o){
return Object.prototype.toString.call(o).slice(8,-1);
}
classOf(null); //'Null'
classOf(1); //'Number'
classOf(''); //'String'
classOf(false); //'Boolean'
classOf({}); //'Object'
classOf([]); //'Array'
classOf(/./); //'Regexp'
classOf(new Date()); //'Date'
classOf(window); //'Window'
function f(){}
classOf(new f()); //'Object'
可扩展性：是否可以给对象添加新属性，默认均是可扩展的
判断对象p的可扩展性：Object.isExtensible(p); 转换为不可扩展：Object.preventExtensions(p); 此转换不可逆转，只影响对象p本身的可扩展性，对象p仍然可以继承在他的原型上新添加的属性，设为不可扩展目的是锁定对象，避免外界干扰，通常和属性的可配置性与可写性配合使用；
Object.seal(p)封闭对象p，让他的所有自有属性都设置为不可配置，Object.isSealed(p)检查是否封闭；
Object.freeze(p)冻结，更严格地锁定对象p，不可扩展、所有自有属性不可配置、所有数据属性设为只读（具有set方法的存取属性不受此影响），检测Object.isFrozen(p);
锁定、封闭、冻结方法均返回传入的对象；
var o = Object.seal(Object.create(Object.freeze({x:1}),{y:{value:2,writable:true}}));
创建一个封闭对象o，包含一个冻结的原型{x:1}和一个不可枚举的属性y
系列化对象：将对象的状态转换为字符串，也可将字符串还原为对象
JSON：JavaScript Object NOtation，（对象表示法）
其JSON.stringify(p)系列化对象p的可枚举的自有属性，JSON.parse(str)字符串还原为对象；
不能系列化的属性在输出字符串时会被省略掉；JSON的语法是JavaScript语法的子集，它只能表示：对象、数组、字符串、无穷大数字、true、false、null，其中NaN、Infinity系列化为null，日期对象系列化为日期字符串且不可还原；
不能系列化和还原：函数、RegExp、Error对象、undefined；
来源：https://www.cnblogs.com/susufufu/p/5705803.html