urn eat 保留 空数组 string 进行 ces 意义
1、创建对象
可以通过对象直接量,关键字 new,object.create() 三种方法来创建对象
对象直接量
- var empty = {}; //没有任何属性的对象
- var point = {
- x: 0,
- y: 0
- }; //两个属性
- var point2 = {
- x: point.x,
- y: point.y
- } //更复杂的值
- var book = {'main title': 'javascript',
- //属性名字里面有空格,必须用字符串表示
- sub - title': 'The Definitive Guide',
- //属性名字里面有连字符,必须用字符串表示
- '
- for': 'all audiences',
- //'for'是保留字,必须用引号
- author: { //这个属性的值是一个对象
- firstname: 'David',
- //注意,这里的属性名都没有引号
- surname: 'Flanagan'
- }
- }
通过 new 创建对象
new 运算符创建并初始化一个对象,关键字后面跟一个函数调用,这个函数称作构造函数,构造函数用于初始化一个新创建的对象
- var o = new Object(); //创建一个空对象,和{}一样
- var a = new Array(); //创建一个空数组,和[]一样
- var d = new Date(); //创建一个表示当前时间的Date对象
- var r = new RegExp('js'); //创建一个可以进行模式匹配的RegExp对象
原型
每个对象都会从原型对象继承属性
通过对象直接量创建的对象,会继承自原型 Object.prototype
通过 new Object(),继承自原型 Object.prototype
通过 new Date(), 继承原型 Date.prototype.
通过 new Array(), 继承原型 Array.prototype.
通过 new RegExp, 继承原型 RegExp.prototype
Date.prototype,Array.prototype,RegExp.prototype 继承自原型 Object.prototype
Object.prototype 是唯一一个没有原型的对象
object.create()
object.create() 创建了一个新对象,第一个参数是这个对象的原型,提供第二个可选参数,可以对对象的属性进行进一步的描述
object.create() 是一个静态函数,而不是提供给某个对象调用的方法。使用方法简单,只需传入所需的原型对象即可
- var o1 = Object.create({
- x: 1,
- y: 1
- }); //o1继承了属性x和y
- var o2 = Object.create(null); //不继承任何属性和方法
- var o3 = Object.create(Object.prototype); //o3和{}和new Object()一样,属于一个普通的空对象
2、属性的查询和设置
通过. 和 [] 用来获取和设置属性,点运算符是静态的,写死的,不能改变。[] 是动态的,在运行是可进行修改。
- var book = {'main title': 'javascript',
- 'sub - title': 'The Definitive Guide',
- '
- for': 'all audiences',
- author: {
- firstname: 'David',
- surname: 'Flanagan'
- }
- }
- var author = book.author; //得到book的'author'属性
- var name = author.surname; //Flanagan
- var title = book['main title']; //javascript
- book.edition = 6; //给book创建了一个名为'edition'的属性
- book['main title'] = 'ECMAScript'; //给'main title'属性赋值
继承
对象具体有自有属性,也有一些属性是从原型对象继承而来。
假设要查询对象 o 的属性 x,如果 o 中不存在 x,那么将会在 o 的原型对象中继续查找属性 x。如果原型对象中也没有 x,但这个原型对象也原型,那么继续这个原型对象的原型上继续查找,直到找到 x 或者查到到一个原型是 null 的对象为止。
只有在查找时才会体会到继续的存在,设置和赋值和继承无关
- var o = {}; //o从Objec.prototype 继承对象的方法
- o.x = 1; //给o定义一个属性x
- var p = inherit(o); //p继承o和Objec.prototype
- var p.y = 2; //给p定义一个属性y
- var q = inherit(p); //q继承p、o、Object.prototype
- q.z = 3; //给q定义一个属性z
- var s = q.toString(); //toString继承自Object.prototype
- q.x + q.y //3:x和y分别继承自o和p
- var unitcircle = {
- r: 1
- }; //一个用来继承的对象
- var c = inherit(unitcircle); //c继承属性r
- c.x = 1;
- c.y = 1; //c定义两个属性
- c.r = 2; //c覆盖继承来的属性
- unitcircle.r; //1:原型对象没有修改
3、删除属性
delete 运算符可以删除对象属性,只能删除自有属性,不能删除继承属性
- var book = {'main title': 'javascript',
- 'sub - title': 'The Definitive Guide',
- '
- for': 'all audiences',
- author: {
- firstname: 'David',
- surname: 'Flanagan'
- }
- }
- delete book.author; //book不再有属性author
- delete book['main title'] //book不再有属性'main title'
当 delete 表达式删除成功或者没有任何副作用的时候,返回 true
- var o = {
- x: 1
- }; //o有一个属性x,并继承属性toString
- delete o.x; //删除x,返回true
- delete o.x; //什么都没做(x已经不存在),返回true
- delete o.toString(); //什么都没做(toString是继承来的),返回true
- delete 1; //无意义,返回true
4、属性检测
四种方法:in 运算符,hasOwnPreperty(),propertyIsEnumberable(),属性查询
in 运算符
- 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:toSting 是继承属性
propertyIsEnumerable() 是 hasOwnProperty() 的增强版,只有检测到是自有属性且这个属性的可枚举性为 true 时才返回 true
- var o = inherit({
- y: 2
- });
- o.x = 1;
- o.propertyIsEnumerable('x'); //true:o有一个可枚举的只有属性x
- o.propertyIsEnumerable('y'); //false:y是继承来的
- o.propertyIsEnumerable('toString'); //false:不可枚举
通过'!=='进行判断
- var o = {
- x: 1
- };
- o.x !== undefined; //true:o中有属性x
- o.y !== undefined; //false:o中没有属性y
- o.toString() !== undefined; //true:o继承了toString属性
JavaScript 对象
来源: http://www.bubuko.com/infodetail-2159464.html