关于javascript:一篇文章带你了解JavaScript对象

JavaScript 中的所有事物都是对象：字符串、数值、数组、函数 … 此外，JavaScript 容许自定义对象。心愿本篇文章能给你带来帮忙

创建对象

对象间接量
对象间接量是由若干名 / 值对组成的映射表，名 / 值对两头用冒号分隔，名 / 值对之间用逗号分隔，整个映射表用花括号括起来。

var empty = {};
var point = {x:0, y:0};
var point2 = {x:point.x, y:point.y+1};
var book = {
    "main title":"JavaScript",
    // 属性名字里有空格，必须用字符串示意
    "sub-title":"The",
    // 属性名字里有连字符，必须用字符串示意
    "for":"all",
    //"for" 是保留字，必须用字符串示意
    author:{
    // 这个属性的值是一个对象
        name:"123"
        // 留神，在里的属性名都没有引号
    }
};

通过 new 创建对象

var o = new Object();
// 创立一个空对象，和 {} 一样
var a = new Array();
// 创立一个空数组，和 [] 一样
var d = new Date();
// 创立一个示意以后工夫的 Date 对象
var r = new RegExp("js");
// 创立一个能够进行匹配的 RegExp 对象

原型
所有通过对象间接量创立的对象都具备同一个原型对象，并能够通过 JavaScript 代码 Object.prototype 取得对原型对象的援用。通过关键字 new 和结构函数调用创立的对象的原型就是构造函数的 prototype 属性的值。因而，同应用 {} 创建对象一样，通过 new Object（）创立的对象也继承自 Object.prototype。同样，通过 new Array（）创立的对象的原型就是 Array.prototype，通过 new Date（）创立的对象的原型就是 Date.prototype。

没有原型的对象为数不多，Object.prototype 就是其中之一。它不继承任何属性。其余原型对象都是一般对象，一般对象都具备原型。所有的内置构造函数（以及大部分自定义的构造函数）都具备一个继承自 Object.prototype 的原型。例如，Date.prototype 的属性继承自 Object.prototype，因而由 new Date（）创立的 Date 对象的属性同时继承自 Date.prototype 和 Object.prototype。这一系列链接的原型对象就是所谓的“原型链”（prototype chain）。

Object.create（）
创立一个新对象，其中第一个参数是这个对象的原型。Object.create（）提供第二个可选参数，用以对对象的属性进行进一步形容。

Object.create（）是一个动态函数，而不是提供给某个对象调用的办法。应用它的办法很简略，只须传入所需的原型对象即可：

var AB = Object.create({x:1,y:2});

属性的查问和设置

var a = book.author;
// 失去 book 的 "author" 属性
book.edition = 6;
// 给 book 创立一个名为 "edition" 的属性并赋值
book["main title"] = "123"
// 给 "main title" 属性赋值

继承
假如要查问对象 o 的属性 x，如果 o 中不存在 x，那么将会持续在 o 的原型对象中查问属性 x。如果原型对象中也没有 x，但这个原型对象也有原型，那么持续在这个原型对象的原型上执行查问，直到找到 x 或者查找到一个原型是 null 的对象为止。

var o = {}
o.x = 1;// 给 o 定义一个属性 x
var p = inherit(o);// p 继承 o
p.y = 2;// 给 p 定义一个属性 y
var q = inherit(p);// q 继承 p
q.z = 3;// 给 q 定义一个属性 z
q.x + q.y // 3 x 和 y 别离继承自 o 和 p 

属性赋值操作首先查看原型链，以此断定是否容许赋值操作。如果容许属性赋值操作，它也总是在原始对象上创立属性或对已有的属性赋值，而不会去批改原型链。

var u = {r:1};
var c = inherit(u);
c.x = 1; c.y =1;
c.r =2;
u.r;  // 1 原型对象没有批改

属性拜访谬误
当 book 没有 a 属性

book.a // undefined
var l = book.a.length;
// 抛出一个类型谬误异样，undefined 没有属性

删除属性
delete 运算符能够删除对象的属性。

delete book.author;
//book 不再有属性 author
delete book["main title"];
//book 不再有属性 "main title"

delete 运算符只能删除自有属性，不能删除继承属性（要删除继承属性必须从定义这个属性的原型对象上删除它，而且这会影响到所有继承自这个原型的对象）。

当 delete 表达式删除胜利或没有任何副作用（比方删除不存在的属性）时，它返回 true。如果 delete 后不是一个属性拜访表达式，delete 同样返回 true：

o = {x:1};
delete o.x; // 删除 x，返回 true
delete o.x; // 什么都没做（x 曾经不存在了），返回 true
delete  o.toString; // 什么也没做（toString 是继承来的），返回 true
delete 1; // 无意义，返回 true

delete 不能删除那些可配置性为 false 的属性
在这些状况下的 delete 操作会返回 false：

delete Object.prototype;// 不能删除，属性是不可配置的
var x = 1; // 申明一个全局变量
delete this.x; // 不能删除这个属性
function f (){}// 申明一个全局函数
delete this.f; // 也不能删除全局函数

检测属性
in 运算符的左侧是属性名（字符串），右侧是对象。如果对象的自有属性或继承属性中蕴含这个属性则返回 true：

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

对象的 hasOwnProperty（）办法用来检测给定的名字是否是对象的自有属性。对于继承属性它将返回 false：

var o = {x:1}
o.hasOwnProperty("x");//true o 有一个自有属性 x
o.hasOwnProperty("y");//false o 中不存在属性 y
o.hasOwnProperty("toString");//false toString 是继承属性

propertyIsEnumerable()是 hasOwnProperty（）的增强版，只有检测到是自有属性且这个属性的可枚举性（enumerable attribute）为 true 时它才返回 true。

var o = inherit({y:2});
o.x = 1;
o.propertyIsEnumerable("x"); //true o 有一个可枚举的自有属性 x
o.propertyIsEnumerable("y"); //false y 是继承来的
Object.propertyIsEnumerable("toString"); //false 不可枚举

除了应用 in 运算符之外，另一种更简便的办法是应用“!==”判断一个属性是否是 undefined：

var o = {x:1}
o.x !== undefined; //true o 中有属性 x
o.y !== undefined; //false o 中没有属性 y
o.toString !== undefined; //true o 继承了 toString 属性

序列化对象
对象序列化（serialization）是指将对象的状态转换为字符串，也可将字符串还原为对象。ECMAScript 5 提供了内置函数 JSON.stringify（）和 JSON.parse（）用来序列化和还原 JavaScript 对象。这些办法都应用 JSON 作为数据交换格局，JSON 的全称是“JavaScript Object Notation”

o = {x:1, y:{z:[false,null,""]}};
s = JSON.stringify(o);
// s 是 '{"x":1,"y":{"z":[false,null,""]}}'
p = JSON.parse(s);
// p == o