属性的getter和setter
JavaScript的属性值可以用getter和setter方法代替，由getter和setter定义的属性称为存取器属性。存取器属性是可以继承的。
用例子说明：
var p = {
//x和y是普通的可读写的数据属性
x: 1.0,
y: 1.0,
// r是可读写的存取器属性，它有getter和setter
// 函数体结束后不要忘记带上逗号
get r(){ return Math.sqrt(this.x*this.x + this.y*this.y) },
set r(newValue){
var oldValue = Math.sqrt(this.x*this.x + this.y*this.y);
var ratio = newValue/oldValue;
this.x *= ratio;
this.y *= ratio;
},
// theta是只读存取器属性，它只有getter方法
get theta(){return Math.atan2(this.y,this.x)},
};
console.log(p); // ==> (1,1) r = 1.41421356 theta = 0.785398
p.r = 2;
console.log(p); // ==> (1.41421356,1.41421356) r = 2 theta = 0.785398
属性特性
数据属性特性分为：值（value），可写性（writable），可枚举性，可配置性。
存取器属性特性分为：读取（get），写入（set），可枚举性，可配置性。
我们创建的属性默认都是可写、可枚举、可配置的。
我们通过例子来介绍一个方法（Object.definePeoperty()）:
// 我们可以调用Object.definePeoperty()来设置对象属性的特性
// 我们可以调用Object.definePeoperty()来设置对象属性的特性
/*
*参数1：传入的对象 （Object）
*参数2：要创建或者修改的属性的名称 (String)
*参数3：属性的特性(对于新创建的自有属性四个属性默认都为false或者undefined,对于已有属性来说，默认的特性值是没有做任何修改的)
*（注意：此方法 只能修改自有属性或者是创建自有属性，但是不能修改继承属性）。
*/
//----看点1
// 简单介绍一下 方法的使用
var obj = {};
Object.defineProperty(obj,"x",{value:2017,
writable:true,
enumerable:true,
configurable:true});
document.write(obj.x+"<br/>"); // ==> 2017
// 这个方法同样是有返回值的，是将修改的对象返回
var obj1 = Object.defineProperty({},"x",{value:2017,
writable:true,
enumerable:true,
configurable:true});
document.write(obj1.x+"<br/>"); // ==> 2017
//-----------------------------------------------------------
//----看点2
// 对于新创建的自有属性，四个属性的默认值都为false或者undefined
var obj2 = Object.defineProperty({},"x",{});
document.write(obj2.x+"<br/>"); // ==> undefined
obj2.x = 2017;
document.write(obj2.x+"<br/>"); // ==> undefined
//-----------------------------------------------------------
//----看点3
// 对于已有属性来说，默认的特性值是没有做任何修改的
var obj3 = {x:2017}; // x 属性是可写、可枚举、可配置的
Object.defineProperty(obj3,"x",{}); // 属性描述中没有做任何修改
obj3.x = 2000;
document.write(obj3.x+"<br/>"); // ==> 2000 说明x属性依然是可写的
//-----------------------------------------------------------
//----看点4
// 此方法 只能修改自有属性或者是创建自有属性，但是不能修改继承属性
var obj4 = Object.create(obj3);
var obj4_x = obj4.x; // 用一个对象来引用obj4.x属性
document.write(obj4.hasOwnProperty("x")+ "<br/>"); //==> false x不是自有属性
Object.defineProperty(obj4,"x",{}); // 创建x属性并且覆盖继承的属性
document.write(obj4.hasOwnProperty("x")+ "<br/>"); //==> ture
// 从上面可以看出，通过此方法，obj4 创建了x属性，并且覆盖了继承的x属性
document.write(obj4.x+"---"+obj4_x+ "<br/>");//undefined---2000
obj4.x = 123123; // 尝试修改x自有属性，发现无效，原因是writable 为false
document.write(obj4.x+"---"+obj4_x+ "<br/>");//undefined---2000
// 从上面可以看出，新创建的自有属性x，属性描述都是默认值，所以value为undefined
//-----------------------------------------------------------
//----看点5
// 看看 数据类型属性，是可以修改成存取器属性的
var obj5 = {x:888};
Object.defineProperty(obj5,"x",{get:function(){return 2017}});
document.write(obj5.x + "<br/>"); // ==> 2017
obj5.x = 123; // 由于存储器属性没有set方法，所以是只读属性，不能进行修改
document.write(obj5.x + "<br/>"); // ==> 2017
//-----------------------------------------------------------
//----看点6
/*
*Object.defineProperties() 可以修改一个对象的多个属性描述
*参数1：对象
*参数2：一个映射列表（也成对象，字典），包括属性名，属性描述
*/
var obj6 = Object.defineProperties({},{x:{value:100,writable:true,enumerable:true,configurable:true},
"y":{value:200}});
document.write(obj6.x +"---"+ obj6.y + "<br/>"); // ==> 2017
我们来看看如果给Object复制属性，而且这些属性的特性也一并复制。
// 复制属性的特性
/*
*给Object.prototype(原型)添加一个不可枚举的extend()方法。
*这个方法继承自调用它的对象，将作为参数传入的对象的属性一一复制，
*除了值之外，也要复制属性的所有特性，除非在目标对象中存在同名的属性，
*参数对象的所有自有对象（包括不可枚举的属性）也要意义复制。
*/
Object.defineProperty(Object.prototype,
"extend",
{
writable:true,
enumerable:false, // 不可枚举
configurable:true,
value:function(obj){ // 值为一个函数
//获取所有的自有属性，包括不可枚举的
var names = Object.getOwnPropertyNames(obj);
// 遍历
for(var i = 0; i < names.length; i++){
// 如果属性中已经存在，则跳过
if(names[i] in this) continue;
// 获取obj中的属性的描述符
var desc = Object.getOwnPropertyDescriptor(obj,names[i]);
// 用它给this创建一个属性
Object.defineProperty(this,names[i],desc);
}
}
});
对象的三个属性
对象的三个属性是原型(prototype)、类(class)和可扩展性(extensible)。
-
原型属性
原型属性是在实例对象创建之初就设置好的，之前我们提到的，通过对象直接量创建的对象，原型是Object.prototype。通过new创建的对象，原型是构造函数的prototype。通过Object.create()创建的对象，原型是第一个参数。可以通过Object.getPrototypeOf()来查询它的原型。也可以通过isPrototypeOf()方法来检测一个对象是否是另一个对象的原型（或处于原型链中）,例如p.isPrototypeOf(o)来检测p是否是o的原型。 -
类属性
对象的类属性(class)是一个字符串，用来表示对象的类型信息。
因为JS没有提供设置这个属性的方法，我们只能通过间接的方法来查询它，默认的toString()方法（继承自Object.prototype）返回[object class]这种格式的字符串，所以我们需要提取返回来的字符串的第8个位置到倒数第二个位置之间的字符串。（有个棘手的问题是，很多对象重写了toString()方法，为了能够调用正确toString()版本，必须简介地调用Function.call()方法）。看例子：
//这个函数用来获取对象的class属性
function classof(obj){
if(obj === null) return "Null";
if(obj ===undefined) return "Undefined";
return Object.prototype.toString.call(obj).slice(8,-1);
}
// 简单的输出函数
function printClassName(obj){
document.write(classof(obj)+"<br/>");
}
printClassName(null); //==>Null
printClassName(1); //==>Number
printClassName(""); //==>String
printClassName(false); //==>Boolean
printClassName({}); //==>Object
printClassName([]); //==>Array
printClassName(/./); //==>RegExp
printClassName(new Date());//==>Date
printClassName(window); //==>Window
function f(){} // 定义一个自定义构造函数
printClassName(new f()); //==>Object
-
可扩展性
对象的可扩展性用以表示是否可以给对象添加新属性。所有的内置对象和自定义对象都是现实可扩展的。我们可以通过(Object.esExtensible())来判断该对象是否是可扩展的。如果我们想将一个对象转为不可扩展的，需要调用Object.preventExtensions()。需要注意的是，一旦对象转成不可扩展的，就无法再将其转化回可扩展的了，而且这个方法只影响对象本身的可扩展性。
Object.seal()方法是将对象设置成不可扩展的，同时还将对象的所有自有属性设置成不可配置的，但是不更改对象属性的可写属性，也就是将对象封闭。
Object.isSeal()方法是来检测对象是否封闭。Object.freeze()`是严格锁定对象，不仅将对象设置为不可扩展的和将其属性设置成不可配置的之外，还可以将它自有的所有数据属性设置成只读的（读取器属性的不受影响）。
序列化对象
对象序列化是指将对象的状态转换为字符串，也可以将字符串还原为对象。
Json.stringify()用来序列化JS对象的。
Json.parse()用来还原JS对象。
注意：JSON的语法是JavaScript语法的子集，它并不能代表JavaScript里的所有值。支持对象、数组、字符串、无穷大数字、true、false、null，并且它们可以序列化和还原。NaN、Infinity和- Infinity序列化的结果是null。而函数、RegExp、Error对象和undefined值不能序列化和还原。序列化只能序列化对象可枚举的自有属性，对于不能序列化的属性会将属性省略。这两个方法接受第二个参数和第三个参数，大家可以看看文档。
var mObj = {
x:1,
y:{z:[false,null,"string"]},
func:function(){document.write("这是一个函数func")}
};
var sObj = JSON.stringify(mObj);
document.write(sObj +"<br/>"); // ==> {"x":1,"y":{"z":[false,null,"string"]}} 对象中的方法给省略掉了
var oObj = JSON.parse(sObj); // ==> {x:1,y:{z:[false,null,"string"]}}
对象方法
所有JS对象都从Object.prototype继承属性，这些继承属性主要是方法，因为我们对方法更加感兴趣。这些方法也可以被重写。
之前提到过很多对象方法了。这里就不具体讲解了。
