对象
对象是动态的——可以新增属性也可以删除属性，但是对象经常用来模拟静态对象以及静态类型语言中的“结构体”。对象的属性是可以增加和删除的。
对象特性
* 对象原型（prototype）：指向另外一个对象，本对象的属性继承自它的原型对象。
* 对象的类（class）：是一个表示对象类型的字符串。
*对象的扩展标记（extensible flag）：指明是否可以向该对象添加新属性。
属性特性
* 可写 （是否可以设置属性值）
* 可枚举 （是否可以通过for in 循环返回该属性）
* 可配置 （是否可以删除或者修改属性）
对象的创建
对象直接量
创建对象最简单的方法是通过对象直接量。
var empty = {}; //没有任何属性的对象
var point = {x:0, y:0}; // 两个属性
var point2 = {x:point.x, y:point.y+1};
var student = {
name:"Allen", //属性名可以不用引号
age:23,
school:{ //这个属性值是一个对象，
"primary school" :"试验小学",//属性名中有空格，必须字符串
"middle-school" :"育才中学" ,//属性名中有连接符，必须用字符串
}
}
/*最后注意一点，属性名尽量避免使用空格、连接符、或者关键字，如果必须使用的话，尽量用引号引起来*/通过new 创建对象
var mObj = new Object(); // 创建一个空对象，和{}一样
var arr = new Array(); // 创建一个空数组，和[]一样
var mDate = new Date(); // 创建一个表示当前时间的Date对象通过 Object.create()
在这里，我们先弄清楚一个名词——原型，每一个JS对象（除了null）都和另一个对象相关联。“另一个”对象就是我们所说的原型，每一个对象都从原型继承属性。
所有通过对象直接量创建的对象都具有同一个原型对象，并可以通过JS代码Object.prototype获得对原型对象的引用。通过关键字new和构造函数调用创建的对象的原型就是构造函数的prototype属性的值。因此，同使用{}创建对象一样，通过new Object()创建对象也继承自Object.prototype。
ECMAScript 5 定义了一个名为Object.create()的方法，它创建一个新的对象，其中第一个参数就是对象原型，第二个参数是可选参数，用以对对象的属性进行进一步描述。
Object.create()是静态函数，而不是提供给某一个对象调用的方法。
var obj = Object.create({x:1,y:2}); // obj继承了属性x,y
var obj2 = Object.create(obj); //obj2的原型是obj，继承了属性x,y;
// 如果想创建一个普通的空对象（比如通过{}或者new Object()创建的对象 ），需要传入Object.prototype
var obj3 = Object.create(Object.prototype);//obj3和{}和new Object()一样现在我们来看看如何自己写一个函数来通过原型来创建对象，看例子
function createObject(obj){
// 先对obj对象进行判断，看是否为null,如果是抛出异常
if(obj == null) throw TypeError();
// Object.create是否可用，可用则返回
if(Object.create) return Object.create(obj);
// 不可用时，检测对象的类型
var objType = typeof obj;
// 如果对象类型不是Object 也不是函数的话，抛出异常
if(objType !=="object" && objType !=="function")
throw TypeError();
// 定义一个空构造函数 并且将函数的原型设置成obj
function mfunc(){};
mfunc.prototype = obj;
return new mfunc();
}属性
对象访问属性的方法有两个，通过（.）和（[]）运算符来获取属性值。这里不做解释。
下来我们详细讲解一下通过([])获取属性值，这种获取属性值的方法很像数组，只是数组的索引是数字，而它的索引是字符串。这种数组就是我们将要说明的关联数组，也成散列、映射或字典。由于JS是弱类型语言，在任何对象中程序都可以创建任意数量的属性。通过([])来访问对象的属性时，属性名是字符串，这样更利于我们在程序运行时进行修改和创建属性。
我们举个例子来说明它的灵活性吧，假设我们去超市购买东西，我们把需要买的东西放入购物车，这辆购物车的作用就是显示我们放入的商品名称，以及商品的单价和数量。你有没有思路呢？学过类似C语言的同学，可以想想如何来实现。简单说一下我的思路吧（用类似C语言的方式的思路，大神勿喷，可以留下你的思路），此处的购物车我们用一个类似字典的对象来表示，字典的Key就是我们的商品名称，Value则是一个对象，对象中的属性包含：商品价格、数量。现在想想用JavaScript如何，思路其实同我上面说的类似，直接看代码吧。
var shoppingCart = {};//这里是购物车
// 添加商品的方法
function addGoods(name,price,count){
shoppingCart[name] = {m_price:price,m_count:count};
}(一)继承（属性的查询和设置）
JS对象有自有属性和继承属性，我觉得通过举例更容易说明这两个属性的关系。
查询对象的属性举例：
假设要查询对象obj的属性x，如果obj中不存在x，那么将会继续在obj的的原型对象中查询属性x，如果原型对象也没有x，但是这个原型对象也有原型（原型不为null），那么继续在这个原型对象的原型上执行查询，直到找到x或者查找到一个原型为null的对象为止。
给对象的属性赋值举例：
假设给对象obj的属性x赋值，如果obj中已经有属性x（这个属性不是继承来的），那么这个赋值操作只改变这个已有属性x的值。如果obj中不存在属性x，那么赋值操作给obj添加一个新属性x。如果之前obj继承自属性x，那么这个继承的属性就会被新创建的同名属性覆盖。
小总结：对象的属性赋值，不会修改原型的属性值的，只会创建属性或者对自有属性赋值。但是需要注意的是，属性赋值操作首先是检查原型链，以此判断是否允许赋值，如果继承的属性是只读的，则赋值操作是不允许的
看一个例子：
var obj = {x:1,y:2};
var obj2 = Object.create(obj);
console.log(obj); // ==> {x:1,y:2}
console.log(obj2); // ==> {x:1,y:2}
//----看点 1-----
// 现在对obj2 属性x值进行修改，看看obj 和 obj2的变化
obj2.x = 100;
console.log(obj); // ==> {x:1,y:2}
console.log(obj2); // ==> {x:100,y:2}
/*可以看出————对象的属性不会修改原型的属性*/
// -------------------------------------------------------
//----看点 2-----
// 这个时候我们对obj 属性x进行修改，看看变化
obj.x = 111;
console.log(obj); // ==> {x:111,y:2}
console.log(obj2); // ==> {x:100,y:2}
/*可以看出————对象属性赋值的时候只会创建属性或者对自有属性进行赋值，因为在之间对obj2的x属性进行赋值的时候，obj2的自有属性中没有x属性，所以obj2会创建新的属性x并赋值，同时覆盖掉继承属性x的值*/
// -------------------------------------------------------
//----看点 3-----
// 我们现在对obj 属性y进行修改，看看变化
obj.y = 222;
console.log(obj); // ==> {x:111,y:222}
console.log(obj2); // ==> {x:100,y:222}
/*这里就可以体现我们上面说到的对象属性的查询过程，因为obj的y属性修改为222，当我们查询obj2的y属性的时候，obj2的自有属性中没有y值，所以obj2就会到它的原型(obj)中查找，原型中的y属性经过修改变成222，所以查询的obj2属性y的结果就是222*/
// -------------------------------------------------------
//----看点 4-----
// 我们来看看访问一个不存在的属性，
console.log(obj2.m_string); // ==> undefined
console.log(obj2.m_string.length); // ==> 这里会报错
/*当访问的属性不存在的时候，系统会返回一个undefined，而null和undefined值是没有属性的，因此上述第二行代码会报错。*/
// 我们可以通过判断的方法来避免错误的出现
var strLength;
if(obj2 && obj2.m_string) strLength = obj2.m_string.length;
//还有一种更简练的方法
strLength = obj2 && obj2.m_string && obj2.m_string.length;经过上面的例子，你是否搞懂继承了？
(二)属性的删除、检测、枚举
删除属性
说先我们来了解一下delete运算符，该运算符可以删除对象的属性。但是delete只是断开属性和宿主对象的关系，而不会去操作属性中的属性。delete表达式删除成功时会返回true。
需要注意的是，delete运算符只能删除自有属性，不能删除继承属性，也不能删除不可配置的属性。
// 删除属性的操作
var mframe = {point:{x:11,y:22},size:{width:100,heght:50}};
// 这里用p对象引用mfram的point属性
var p = mframe.point;
// 当我们执行删除操作之后，来打印p看看结果
delete mframe.point;
console.log(p); // ==> {x:11,y:22};
/*执行代码之后，我们知道mframe已经没有了point属性，但是由于已经删除的属性的引用依然存在，因此在JS的某些实现中，可能因为这种不严谨的代码而造成内存泄漏，所以在销毁对象的时候，要遍历属性中的属性，依次删除*/检测属性
检测属性主要是来判断某属性是否存在于某个对象中，我们用代码来介绍一下检测属性。
// in运算符来检测属性，左侧是 属性名（字符串），右侧是对象
var mpoint = {x:1,y:2};
console.log("x" in mpoint); //==> true
console.log("z" in mpoint); //==> false
console.log("toString" in mpoint); //==> true,toString是继承属性；
// -------------------------------------------------------
// hasOwnProperty()方法用来检测给定的名字是否是对象的自有属性，对于继承属性它将返回false。
console.log(mpoint.hasOwnProperty("x")); //==> true
console.log(mpoint.hasOwnProperty("z")); //==> false
console.log(mpoint.hasOwnProperty("toString")); //==> false
// -------------------------------------------------------
// propertyIsEnumerable()是hasOwnProperty()的加强版，只有检测到是自有属性且这个属性是可枚举的才会返回ture.这里就不做举例了枚举属性
我们经常会遍历对象的属性，通常使用for/in循环来遍历。for/in 循环可以遍历对象中所有可枚举的属性（包括自有属性和继承属性）。
有许多实用工具库给Object.prototype添加了新的方法或属性，这些属性可以被所有对象继承并使用，但是在ECMAScript 5标准之前，这些新添加的方法是不能定义为不可枚举的，因此使用for/in循环进行枚举的时候，这些属性会被枚举出来。为了避免这种情况，我们需要在for/in 中进行过滤，有两种常见的方法：
for(p in obj){
if(!obj.hasOwnProperty(p)) continue; // 跳过继承的属性
}
//---------------------------------
for(p in obj){
if(typeof obj[p] === "function") continue; // 跳过方法
}除了for/in循环之外，ECMAScript 5 定义了两个用以枚举属性名称的函数。
* Object.keys(),它返回一个数组，这个数组由对象中可枚举的自有属性的名称组成。
* Object.getOwnPropertyNames(),它返回对象的所有自有属性的名称（包括自有属性中的可枚举属性和不可枚举属性）.
属性的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()方法是来检测对象是否封闭。
序列化对象
对象序列化是指将对象的状态转换为字符串，也可以将字符串还原为对象。
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继承属性，这些继承属性主要是方法，因为我们对方法更加感兴趣。这些方法也可以被重写。
之前提到过很多对象方法了。这里就不具体讲解了。