JavaScript对象：
1、术语
<1>、对象的描述：
ECMA-262 把对象（object）定义为“属性的无序集合，每个属性存放一个原始值、对象或函数”，对象是无特定顺序的值的数组。对象是JavaScript的基础数据类型。除了字符串、数字、true，false，null，undefined之外，JavaScript中的所有事物都是对象。
对象不仅是字符到值的映射，除了保持自身的属性，还可以从原型的对象继承属性，对象的方法常是继承的属性，这种“原型继承”
是JavaScript的核心特征。
<2>、类的描述：
每个对象都由类定义，可以把类看做对象的配方。类不仅要定义对象的接口（interface）（开发者访问的属性和方法），还要定义对象的内部工作（使属性和方法发挥作用的代码）。
编译器和解释程序都根据类的说明构建对象。
<3>、实例的描述：
程序使用类创建对象时，生成的对象叫作类的实例（instance）。对类生成的对象的个数的唯一限制来自于运行代码的机器的物理内存。每个实例的行为相同，但实例处理一组独立的数据。由类创建对象实例的过程叫做实例化（instantiation）
ECMAScript 并没有正式的类。相反，ECMA-262 把对象定义描述为对象的配方，因为对象定义实际上是对象自身。即使类并不真正存
在，我们也把对象定义叫做类
2、对象的创建：
可以通过对象直接量、关键字new和（ECMAScript）Object.create()函数来创建对象<1>、对象直接量创建对象：
对象直接量是一个表达式，每次运算都会创建并初始化一个新的对象，是由若干名/值对组成的映射表，名/值对中间冒号分隔，名/值对之间用逗号分隔，整个映射表用花括号包含起来。
-> 属性名是可以说JavaScript标识符或者字符直接量（包括空字符串）。
-> 属性值可以为任意类型的JavaScript的表达式，表达式的值，可以说原始值也可以是对象值。
var o = {}; //没有任何属性的对象
var object = {x: 0, y: 0}; //有两个属性的对象
var a = {x: object.x, y: object + 1}; //复杂的对象
var people = {
man: { //这个属性值是一个对象
"make money": " yes", //属性名有空格，必须用字符串表示
eat: "ye so"//注意这里的属性名没有用引号
},
"for": "buy things" //for是保留字，因此必须用引号
}不带引号的保留字作为属性名，而且对象的最后一个属性名会自动忽略最后的逗号。
<2>、通过new创建对象：
new运算符创建新对象时，关键字new后面会跟着一个构造函数来初始化一个新创建的对象。注：如果创建的对象的构造函数无参数，可以省略后面的括号。即var o=new Object和var o=new Object()。都是创建了一个对象，
尽管括号不是必需的，但是为了避免混乱，最好使用括号。
var o = new Object(); //创建一个空对象，代码创建了Object类的一个实例，并把它存储到变量o中，和{}一样
var a = new Array(); //创建一个空数组，代码创建了Array类的一个实例，并把它存储到变量a中，和[]一样
var d = new Date(); //创建一个date对象，代码创建了Date类的一个实例，并把它存储到变量d中，表示当前时间
var r = new RegExp("js");//创建一个模式匹配的RegExp对象<3>、原型创建对象：
每一个对象（null除外）都从另外一个对象相关联，每一个对象都是从原型继承属性。所有通过对象直接量创建的对象都具有同一个原型对象，通过Object.prototype获取原型对象的引用、通过关键字new和构造函数创
建的对象的原型就就是该对象构造函数的prototype属性的值。
故：new Object()的原型是Object.prototype等所有内置构造函数都具有一个Object.prototype的原型。
故：new Date()创建的对象的属性继承自Date.prototype和Object.prototype，这就叫原型链接。
<4>、Object.create()创建对象：（ECMAScript 5标准）
Object.create(prototype,attr)是一个静态函数，有两个参数，第一个参数是这个要创建对象的原型，第二个可选参数是用来描述对象的属性。所以，只需要传入对象的原型即可，可以通过任意原型创建对象：
var object = Object.create({x: 1, y: 2}); //object继承了第一个参数原型的属性x和y
var object = Object.create(null); //object不继承任何属性和方法。
var o = Object.create(Object.prototype);//创建一个普通的空对象，和{}和new Object()创建对象一样不是向上面那样直接将对象作为参数传入函数demo()，而是将他继承的对象p传入函数，当函数读取继承对象p的属性时，实际读取的
是继承对象f的值，如果给继承对象的属性赋值时只会影响继承的对象f本身，而不会影响原始的对象p;
function demo(p) {
if (p == null) {//p是一个对象，但是不能为null，
throw TypeError();
}
if (object.create) {//如果object.create()对象存在，则直接使用它创建对象
return Object.create(p);
}
var t = typeof p;//如果p不是对象，也不是function，则抛出异常；
if (t !== "object" && t !== "function") {
throw TypeError();
}
function f() {
};//定义一个空构造函数
f.prototype = p;//将其原型属性设为p
return new f();//使用new f()创建p的继承对象。
}
var pro = {"id": "1001", "name": "zhangsan"};
var obj = demo(pro);//demo返回的demo内部新创建的对象f切f继承传入的pro的原型属性，可以防止对原本对象pro意外修改3、对象属性的操作：
<1>、设置或获取属性：
通过(.)或者([])运算符来获取或者设置属性的值：--在ECMAScript 3中，点运算符后的标识符保留字是非法的，比如o.for或者o.class是非法的；因为for是关键字，.class是保留字。
--在ECMAScript 5中，可以直接使用无影响。
//可以认为JavaScript对象都是关联的数组，通过字符串索引来获取属性。
var person = {"id": "1001", "name": "zhangsan"};
var id = person.id;//id=1001, 获取person的id属性
var name = person["name"];//name=zhangsan, 获取person的name属性
person.id = "1000";//设置person的id的属性为1000
person["name"] = "lisi";//设置person的name的属性为lisi<2>、原型链：
如果查询o的x属性,o的x属性不存在，会继续找o继承的原型对象中找到属性x，如果找不到会继续在原型对象的原型查询，一直到返回原型是null的对象为止。可以看到对象的属性构成了一个“链”，通过这个“链”实现属性的继承。在JavaScript中只会在查询属性时，
才能体会到原型链的存在，而设置属性与继承无关，让程序员有选择覆盖继承的属性，这是JavaScript的重要特性。
--假设给o的属性x赋值，属性赋值先会检查原型链，是否允许赋值操作。
--(1)、如果o继承自一个只读属性x，那么赋值不允许。
--(2)、如果o继承的属性不是只读的，允许赋值，也会只在原始对象的基础上创建属性x或者对已有的属性x赋值，而不会改变原型链。
--(3)、如果o已有属性x（这个属性不是继承来的），那么赋值操作只会改变已有属性x的值。
--(4)、如果o中不存在属性x，则赋值会给o新添加一个属性x，如果o继承原型的属性x，则继承的属性被新属性x所覆盖
var o = {};//o继承的是Object.prototype的属性
o.x = 1;//给o定义一个属性x
var p = demo(o);//p继承o和Object.prototype的属性x
p.y = 2;//给p定义一个属性y
var q = demo(p);//q继承p、o、Object。prototype的属性x和y；
q.z = 3;//给q定义一个属性z
var s = q.toString();//toString方法继承自Object.prototype
var r = q.x + q.y;//r=3,q的属性x和y分别继承自o和p；
q.x = 3;//q的x的属性值会覆盖继承的属性值。
var ox = o.x;//ox=1;q.x=3,没有修改继承自o的属性x的值。<3>、属性访问：
属性访问并不总是返回或设置一个值。如果查询对象中并存在的属性不会报错，如果在o自身的属性中和继承的原型属性中没有找到属性x，则返回undefined。如果对象不存在，去访问对象的属性，就会报错。只读属性，不能赋值。
注：undefined和null不存在任何属性，访问undefined和null的属性，会抛出异常，设置或者查询都会抛出异常。
var name = book.name;//name=undefined,表示属性name在对象o和继承的属性中不存在。
//在ECMAScript 5标准中，任何失败的属性操作都会抛出一个类型错误异常。
var name = book.name.length;//抛出一个错误异常，undefined没有length属性。因为o.name=undefined,undefined不存在任何属性。
//一种冗余，但是易懂的方法，
var len = undefined;
if (book) {
if (book.name) {
len = book.name.length;
}
}
//更加简练的方法，用来获取获取book对象的name属性的length属性或者undefined,利用运算符&&短路的来取出值。
var len = book && book.name && book.name.length;<4>、删除属性：
delete运算符可以删除对象的属性，只是断开属性和对象之间的关联，而不会操作属性中的属性。var book={"id":"191","name":"平凡的世界"};
//--delete运算符只能删除自身属性，不能删除继承属性。delete删除成功后会返回true。
delete book.name;//删除属性name，返回true
delete book.name;//属性name在上面已经删除，在book对象中不存在，此时delete什么都没做，返回true；
delete book.toString;//属性toString是继承来的，不能删除继承属性，此时delete什么都没做，返回true；
delete 1;//无意思，返回true；
//--delete不能删除那些可配置性为false的属性，在非严格情况下会返回false，在ECMAScript 5标准中，严格下会抛出类型错误。
delete Object.prototype;//不能删除。属性是不可配置的。
//--通过变量声明或者函数声明床架的全局对象的属性实不可删除的
var x = 1;//声明一个全局变量
delete this.x;//不能删除全局变量。
function fun() {};//声明一个全局函数
delete this.fun;//不能删除全局函数
//--创建一个可配置的全局属性。没有用var声明
this.y=1;
delete this.y;//删除成功，严格删除。
delete y;//非严格删除，在严格模式下，会报语法错误。<5>、判断属性是否存在：
对象可以看做属性的集合，可以通过in运算符、hashOwnProperty()和propertyIsEnumerable()方法，判断属性是否存在对象中，或者通过属性查询判断属性是否在对象中。
//(1).in运算符：左侧是属性名,右侧是对象，如果对象自身属性或者继承属性中存在，则返回true；
var book = {"name": "诛仙", id: undefined};
name in book;//返回true, name不是book的属性
code in book;//返回false，code不是book的属性
"toString" in book;//返回true；toString继承自Object.prototype属性
//(2).hashOwnProperty()方法,检测对象自身是否有属性，如果是继承的属性将返回false;
book.hashOwnProperty("name");//返回true。name是本身属性
book.hashOwnProperty("toString");//返回false,toString是继承属性
//(3).propertyIsEnumerable()方法是hashOwnProperty()的增强版，只有检测到自身属性且这个属性可枚举性为true时他才会返回true
var p = demo(book);
p.x = 1;
p.propertyIsEnumerable("name");//返回false,name是继承来的。
p.propertyIsEnumerable("x");//返回true，x是可枚举的自有属性
Object.prototype.propertyIsEnumerable("toString");//返回false，不可枚举。
//(4).用"!=="判断一个属性是否为undefined
book.code !== undefined;//返回false，属性中没有code
book.id !== undefined;//返回false，属性存在，但是值为undefined，这种情况下只能用in
/**
* 注："!=="、"!="、"=="、"===" 的区别：
* == 和 != 比较若类型不同，先偿试转换类型，再作值比较，最后返回值比较结果。而 === 和 !== 只有在相同类型下,才会比较其值。
*/
var num = 1;
var str = "1";
var test = 1;
test == num //true 相同类型 相同值
test === num //true 相同类型 相同值
test !== num //false test与num类型相同，其值也相同, 非运算肯定是false
num == str //true 把str转换为数字，检查其是否相等。
num != str //false == 的非运算
num === str //false 类型不同，直接返回false
num !== str //true num 与 str类型不同意味着其两者不等、非运算自然是true<6>、枚举属性：
for/in循环可以在循环体中遍历对象中所有可以枚举的属性。对象继承的内置方法是不可枚举的，代码中添加的属性是可以枚举的var book = {"name": "诛仙", "code": "1001"};
for (b in book) {
if (!book.hashOwnProperty(b)) continue;//跳过继承的属性
if (typeof book[p] === "function") continue;//跳过方法
}
/**
* 把obj中可以枚举的属性复制到book中,并返回book， 如果book中含有同名属性，则覆盖book中的属性，
* 这个函数并不处理getter和setter以及复制属性。
* @param book 被赋值属性的对象
* @param obj 复制属性的对象
* @returns {*} book对象
*/
function extend(book, obj) {
for (o in obj) {//遍历obj的所有属性
book[o] = obj[o];//把obj的属性复制到book中。如果不存在同名属性则添加，如果存在同名属性，则覆盖
}
return book;
}
/**
* 将obj中可以枚举的属性赋复制到book中，并返回book， 如果obj和book中有同名的属性，book的属性将不受影响
* 这个函数并不处理getter和setter以及复制属性。
* @param book 被赋值属性的对象
* @param obj 复制属性的对象
* @returns {*} book对象
*/
function merge(book, obj) {
for (o in obj) {//遍历obj的所有属性
if (book.hashOwnProperty(o)) continue;//如果book中含有属性o，不是继承来的，则跳过。
book[o] = obj[o];//把obj的属性复制到book中。如果不存在同名属性则添加，如果存在同名属性，则覆盖
}
return book;
}
/**
* 删除同名属性
* 如果book中含有和obj一样的属性，删除book中的属性
* @param book 被赋值属性的对象
* @param obj 复制属性的对象
* @returns {*} book对象
*/
function restict(book, obj) {
for (o in obj) {//遍历obj的所有属性
delete book(o);//删除同名属性
}
return book;
}<7>、属性getter和setter：
在ECMAScript 5标准中，属性值可以用方法代替，getter和setter，由getter和setter定义的属性称为“存取器属性”。--setter方法：将赋值表达式右侧的值当做参数传入setter，设置属性值；
--getter方法：查询属性的值时，调用getter方法（无参数），返回的值就是属性存取表达式的值。
--读写属性：属性同时具有getter和setter方法，
--只读属性：属性只有getter方法
定义存取器属性：
/**
* 创建一个对象book
* 注：函数体内的this指向表示这个点的对象，JavaScript把this.name当做book对象的方法来使用了。
* @type {{name: string, article: string, r, r, t}}
*/
var book = {
name: "诛仙",
article: "第一章",
//r为可读写存取器属性，它有getter和setter
get r() {
return this.name + this.article;
},
set r(newvalue) {
this.article = newvalue；
},
//t是只读存取器属性，只有getter方法
get t() {
return this.name + this.article;
}
};
var bname = book.r;//诛仙第一章
book.r("第二章").t;//诛仙第二章
/**
* 对象random可以有返回随机数的属性
* 方法1：Math.floor()向下取整，
* 方法2：Math.random()生成一个大于0小于等于1.0的随机数
* @type {{octet, uint16, int16}}
*/
var random = {
get octet() {
return Math.floor(Math.random() * 256);
},
get uint16() {
return Math.floor(Math.random() * 65536);
},
get int16() {
return Math.floor(Math.random() * 65536) - 32768;
}
};<8>、属性特性：
一个属性包含一个属性名字和四个特性：值(value)、可写性(writable)、可枚举性(enumerable)和可配置性(configurable), 存取器属性不具有value和writable，因为他有get和set方法，所以只有enumerable和configurable;
//设置属性的特性：Object.definePropertyOf(),不允许操作的属性会报类型错误异常 Object.definePropertyOf(o, x, {value: "张三", writable: true, enumerable: true, configurable: true});
<9>、属性描述符：
通过调用Object.getOwnPropertyDescriptor(),可以获得某个对象特定属性描述符。//返回{value:"张三",writable:true,enumerable:true,configurable:true}
Object.getOwnPropertyDescriptor({name: "张三"}, "name");
//返回{get:/*func*/,set:undefined,enumerable:true,configurable:true}
Object.getOwnPropertyDescriptor(random, "octet");
//对于自身和不存在的属性则返回undefined
Object.getOwnPropertyDescriptor({}, "toString");//undefined，继承属性
Object.getOwnPropertyDescriptor({}, "x");//undefined，自身不存在<10>、对象三个属性：
//--(1).原型属性：是用来继承属性，通常把对象的原型属性称为对象的原型。
//通过Object.getPrototypeOf()查询对象的原型，通过isPrototypeOf()查询是否原型；
var book = {name: "张三"};//创建一个对象book
var obj = Object.create(book);//根据book创建对象obj，obj继承自book的属性
book.isPrototypeOf(obj);//返回true，判断book是否为obj的原型。
Object.prototype.isPrototypeOf(book);//返回true，book继承自原型Object.prototype
//--(2).类属性：class attribute是一个字符串，表示对象的类型信息，默认是toString()方法返回格式字符串"[object class]"
/**
* 获取对象的类属性
* call([thisObj[,arg1[, arg2[, [,.argN]]]]])方法：
* 参数：thisObj可选项。将被用作当前对象的对象。arg1, arg2, , argN可选项。将被传递方法参数序列。
* call方法可以用来代替另一个对象调用一个方法。call方法可将一个函数的对象上下文从初始的上下文改为由thisObj指定的新对象。
* 如果没有提供 thisObj 参数，那么 Global 对象被用作 thisObj。
* slice(start,end)方法,从尾部开始截取，start是从字符串尾部开始算起的位置，end如果为负数，则直接从截取到尾部。
* @param o 对象
* @returns {*} 对象的类属性
*/
function classof(o) {
if (o === null) return "Null";
if (o === undefined) return "Undefined";
//如果用传入对象o代替Object.prototype执行toString();返回值是"[object class]"
return Object.prototype.toString().call(o).slice(8, -1);
}
//使用
classof(null);//Null;
classof(1);//Number;
classof("string");//String
//--(3).可扩展性属性：可以给对象添加新属性，所有内置对象都是显示可扩展的，宿主的可扩展性由JavaScript引擎定义的。
Object.isExtensibel();//判断对象是否可扩展
Object.preventExtensibel();//设置对象不可扩展。
Object.seal();//设置对象不可扩展，对象自身的属性不可设置，不能添加删除配置，只能可写可赋值可读。
Object.isSealed();//判断对象是否封闭。
Object.freeze();//冻结对象，对象不可扩展，所有属性设为只读的（setter方法除外）
Object.isForzen();//判断对象是否冻结。
//创建一个封闭对象，包括一个原型，和一个不可枚举的属性。
Object.seal(Object.create(Object.freeze({x: 1}), {y: {value: 2, writable: true}}));4、序列化对象：
对象序列化是指将对象转换为字符串，也可以将字符串还原为对象。对象、数组、字符串、无穷大数字、true、false和null、都可以序列化和还原。函数、RegExp、Error对象和undefined值不能序列化和还原。
JSON对象：JSON全称"JavaScript Object Notation"-即JavaScript对象表示法
ECMAScript5提供了内置的JSON.Stringify()和JSON.parse()用来序列化和还原JavaScript的JSON对象或JSON字符串。
可以引入http://json.org/json2.js模块在ECMAScript 3环境中使用ECMAScript 5的JSON的函数。
5、对象方法：
(1).toString()方法：没有参数，返回调用对象的字符串。很多类都带有自定义的toString()方法。(2).toLocalString()方法：返回对象本地化的字符串。
(3).toJSON()方法：Object.prototype没有定义toJSON()方法，是JSON.stringify()内部调用的toJSON()方法,返回序列化的结果。
(4).valueOf()方法：将对象转换为原始值会调用。
952
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
