Object.defineProperty() 方法会直接在一个对象上定义一个新属性,或者修改一个对象的现有属性,并返回此对象。
const object1 = {};
var object2 = Object.defineProperty(object1, 'property1', {
value: 42,
writable: false
});
console.log(object1);
console.log(object2);
console.log(object1 === object2);
Object.defineProperty()语法说明
Object.defineProperty(obj, prop, desc)
- obj 需要定义属性的当前对象
- prop 当前需要定义的属性名
- desc 属性描述符
一般通过为对象的属性赋值的情况下,对象的属性可以修改也可以删除,但是通过Object.defineProperty()定义属性,通过描述符的设置可以进行更精准的控制对象属性。
属性的特性以及内部属性
javacript 有三种类型的属性
- 命名数据属性:拥有一个确定的值的属性。这也是最常见的属性
- 命名访问器属性:通过
getter
和setter
进行读取和赋值的属性 - 内部属性:由JavaScript引擎内部使用的属性,不能通过JavaScript代码直接访问到,不过可以通过一些方法间接的读取和设置。比如,每个对象都有一个内部属性
[[Prototype]]
,你不能直接访问这个属性,但可以通过Object.getPrototypeOf()
方法间接的读取到它的值。虽然内部属性通常用一个双吕括号包围的名称来表示,但实际上这并不是它们的名字,它们是一种抽象操作,是不可见的,根本没有上面两种属性有的那种字符串类型的属性
属性描述符
通过Object.defineProperty()为对象定义属性,有两种形式,且不能混合使用,分别为数据描述符,存取描述符,下面分别描述下两者的区别:
数据描述符 --特有的两个属性(value,writable)
let Person = {}
Object.defineProperty(Person, 'name', {
value: 'Jack',
writable: true // 是否可以改变
})
Person.name = 'Jane';
console.log(Person.name) // 'Jane'
let Person2 = {}
Object.defineProperty(Person2, 'name', {
value: 'Jack',
writable: true // 是否可以改变
})
Person2.name = 'Jane';
console.log(Person2.name) // 'Jack'
注意,如果描述符中的某些属性被省略,会使用以下默认规则:
属性名 | 默认值 |
---|---|
value | undefined |
get | undefined |
set | undefined |
writeable | false |
enumerable | false |
configurable | false |
存取描述符 --是由一对 getter、setter 函数功能来描述的属性
get
:一个给属性提供getter
的方法,如果没有getter
则为undefined
。该方法返回值被用作属性值。默认为undefined
。
set
:一个给属性提供setter
的方法,如果没有setter
则为undefined
。该方法将接受唯一参数,并将该参数的新值分配给该属性。默认值为undefined
。
let Person = {}
let temp = null
Object.defineProperty(Person, 'name', {
get: function () {
return temp
},
set: function (val) {
temp = val
}
})
console.log(Person.name); // null
Person.name = 'Jane';
console.log(Person.name) // 'Jane'
数据描述符和存取描述均具有以下描述符
- configrable 描述属性是否配置,以及可否删除
- enumerable 描述属性是否会出现在for in 或者 Object.keys()的遍历中
configrable 代码片段分析
let Person1 = {};
Object.defineProperty(Person1, 'name', {
value: 'Jack',
configurable: false,
writable: true,
enumerable: true,
})
delete Person1.name; // false
console.log(Person1.name); // 'Jack
let Person2 = {};
Object.defineProperty(Person2, 'name', {
value: 'Jack',
configurable: false,
})
try {
// 报错:Uncaught TypeError: Cannot redefine property: name
Object.defineProperty(Person2, 'name', {
value: 'Jane',
})
} catch(e) {
console.log(e);
}
console.log(Person2.name); // 'Jack'
let Person3 = {};
Object.defineProperty(Person3, 'name', {
value: 'Jack',
configurable: true,
writable: false,
});
Person3.name = 'Jane';
console.log(Person3.name); // 'Jack'
Object.defineProperty(Person3, 'name', {
value: 'Rose',
})
console.log(Person3.name); // Rose
let Person4 = {};
Object.defineProperty(Person4, 'name', {
value: 'Jack',
configurable: false,
writable: true,
});
Person4.name = 'Jane';
console.log(Person4.name); // 'Jack'
Object.defineProperty(Person4, 'name', {
value: 'Rose',
})
console.log(Person4.name); // Rose
let Person5 = {};
Object.defineProperty(Person5, 'name', {
value: 'Jack',
configurable: false,
writable: true,
});
Person5.name = 'Jane1';
console.log(Person5.name); // 'Jack'
Object.defineProperty(Person5, 'name', {
// value: 'Rose',
writable: false,
})
Person5.name = 'Jane2';
console.log(Person5.name); // Rose
let Person6 = {};
Object.defineProperty(Person6, 'name', {
value: 'Jack',
configurable: false,
writable: false,
});
Person6.name = 'Jane1';
console.log(Person6.name); // 'Jack'
// Uncaught TypeError: Cannot redefine property: name
Object.defineProperty(Person6, 'name', {
// value: 'Rose',
writable: true,
})
从以上代码运行结果分析总结可知:
- configurable: false 时,不能删除当前属性,且不能重新配置当前属性的描述符(有一个小小的意外:可以把writable的状态由true改为false,但是无法由false改为true),但是在writable: true的情况下,可以改变value的值
- configurable: true时,可以删除当前属性,可以配置当前属性所有描述符。
enumerable 代码片段分析
let Person1 = {};
Object.defineProperty(Person1, 'name', {
value: 'Jack',
enumerable: false,
});
Person1.gender = 'male';
Object.defineProperty(Person1, 'age', {
value: 26,
enumerable: true,
})
console.log(Object.keys(Person1)) // ['getnder', 'age']
for(let i in Person1) {
console.log(i) // 'getnder', 'age'
}
let Person2 = {};
Person2.gender = 'male'
// 等价于
Object.defineProperty(Person2, 'male', {
value: 'male',
configurable: true,
enumerable: true,
writable: true,
})
Object.defineProperty(Person2, 'age', {
value: 26,
})
// 等价于
Object.defineProperty(Person2, 'age', {
value: 26,
configurable: false,
enumerable: false,
writable: false,
})
不变性
- 对象常量
结合writable: false 和 configurable: false 就可以创建一个真正的常量属性(不可修改,不可重新定义或者删除)
let Person1 = {}
Object.defineProperty(Person1, 'name', {
value: 'Jack',
writable: false,
writable: false,
})
delete Person1.name;
Person1.name = 'Jane'
console.log(Person1.name);
Person1.gender = 'male'
console.log(Person1.gender);
// 不可重新定义 Uncaught TypeError: Cannot redefine property: name
Object.defineProperty(Person1, 'name', {
value: 'Rose',
})
- 禁止扩展
如果你想禁止一个对象添加新属性并且保留已有属性,就可以使用Object.preventExtensions(...)
let Person1 = {
name: 'Jack'
}
Object.preventExtensions(Person1)
Person1.gender = 'male'
Person1.name = 'Jane'
console.log(Person1.gender) // undefined
console.log(Person1.name) // 'Jane'
let Person2 = {
name: 'Jack'
}
Object.preventExtensions(Person2) // 禁止扩展
// 仍然可以进行配置
Object.defineProperty(Person2, 'name', {
value: 'Rose',
writable: false,
configurable: false,
});
console.log(Person2.name); // Rose
在非严格模式下,创建属性gender会静默失败,在严格模式下,将会抛出异常。
- 密封
Object.seal()
会创建一个密封的对象,这个方法实际上会在一个现有对象上调用Object.preventExtensions(...)
并把所有现有属性标记为configurable:false。
let Person1 = {
name: 'Jack'
};
Object.seal(Person1)
Person1.gender = 'male'
// 不能扩展属性
console.log(Person1.gender) // undefined
// 再次验证
console.log(Object.keys(Person1)) // ['name']
// 不能再次配置属性了 Uncaught TypeError: Cannot redefine property: name
Object.defineProperty(Person1, 'name', {
value: 'Rose',
configurable: true,
});
console.log(Person1.name); // 'Jack'
所以, 密封之后不仅不能添加新属性,也不能重新配置或者删除任何现有属性(虽然可以改属性的值)
- 冻结
Object.freeze()
会创建一个冻结对象,这个方法实际上会在一个现有对象上调用Object.seal()
,并把所有现有属性标记为writable: false,这样就无法修改它们的值。
let Person1 = {
name: 'Jack'
}
Object.freeze(Person1)
Person1.gender = 'male'
// 不能扩展属性
console.log(Person1.gender); // undefined
Person1.name = 'Tom'
// 不可以修改已有属性的值
console.log(Person1.name) // Jack
// 不能再次配置属性 Uncaught TypeError: Cannot redefine property: name
Object.defineProperty(Person1, 'name', {
value: 'Rose',
configurable: true,
})
这个方法是你可以应用在对象上级别最高的不可变性,它会禁止对于对象本身及其任意直接属性的修改(但是这个对象引用的其他对象是不受影响的)
你可以深度冻结一个对象,具体方法为,首先这个对象上调用Object.freeze()然后遍历它引用的所有对象,并在这些对象上调用Object.freeze()。但是一定要小心,因为这么做有可能会无意中冻结其他共享对象。
属性定义和属性赋值
最后一小节,总结一下上述内容
属性定义,通过Object.defineProperty()形式
- 如果Obj没有名为Prop的自身属性的话:如果Obj是可扩展的话,则创建Prop这个自身属性,否则拒绝
- 如果Obj已经有了名为Prop的自身属性:则按照下面的步骤重新配置这个属性
- 如果这个已有的属性是不可配置的,则进行下面的操作会被拒绝
1: 将一个数据属性转换成访问器属性,反之变然
2: 改变`[[Configurable]]`或`[[Enumerable]]`
3: 改变[[Writable]]由false变为true
4: 在`[[Writable]]`为`false`时改变`[[Value]]`
5: 改变[[Get]]或[[Set]]
- 否则这个已有的属性可以被重新配置
属性赋值,通过obj.prop = ''prop"形式
- 如果在原型链上存在一个名为P的只读属性(只读的数据属性或者没有setter的访问器属性),则拒绝
- 如果在原型链上存在一个名为P的且拥有setter的访问器属性,则调用这个setter
- 如果没有名为P的自身属性,则如果这个对象是可扩展的,就创建一个新属性,否则,如果这个对象是不可扩展的,则拒绝
- 如果已经存在一个可写的名为P的自身属性,则调用Object.defineProperty(),该操作只会更改P属性的值,其他的特性(比如可枚举性)都不会改变
作用以及影响
属性的定义操作和赋值操作各自有自己的作用和影响。
赋值可能会调用原型上的setter,定义会创建一个自身属性。
**原型链中的同名只读属性可能会阻止赋值操作,但不会阻止定义操作。**如果原型链中存在一个同名的只读属性,则无法通过赋值的方式在原对象上添加这个自身属性,必须使用定义操作才可以。这项限制是在ECMAScript 5.1中引入的
let proto = {
get bar() {
console.log('Getter!');
return 'a'
}
}
let obj = Object.create(proto)
obj.bar = 'hello'
console.log(obj.bar) // a
Object.defineProperty(obj, 'bar', {
value: 'hello'
})
console.log(obj.bar) // hello
console.log(proto.bar) // a
let proto2 = Object.defineProperties({}, {
foo: {
value: 'a',
writable: false,
configurable: true,
}
})
let obj2 = Object.create(proto2);
console.log(obj2) // {}
obj2.foo = 'hello'
console.log(obj2.foo) // a
let proto3 = Object.defineProperties({}, {
foo: {
value: 'a',
writable: false,
configurable: true,
}
})
let obj3 = Object.create(proto3);
console.log(obj3)
Object.defineProperty(obj3, 'foo', {
value: 'b'
})
console.log(obj3.foo) // b
console.log(proto3.foo) // a
obj3.foo = 'hello'
console.log(obj3.foo) // b
赋值运算符不会改变原型链上的属性
不能通过为obj.foo
赋值来改变proto.foo
的值。这种操作只会在obj上新建一个自身属性
let proto = {
foo: 'a'
}
let obj = Object.create(proto)
console.log(obj) // {}
obj.foo = 'b'
console.log(obj.foo) //b
console.log(proto.foo) // a
console.log(obj.hasOwnProperty('foo')) // true
对象字面量中的属性是通过定义操作添加的。
let obj = {
name: 'Jack'
}
// 等同于
let obj = new Object();
Object.defineProperties(obj, {
name: {
value: 'Jack',
configurable: true,
configurable: true,
writable: true,
}
})
再次啰嗦一次,记住以下两种形式的区别:
let obj = {}
obj.name = 'Jack'
// 等同于
let obj = {}
Object.defineProperty(obj, 'name', {
value: 'Jack',
writable: true,
configurable: true,
enumerable: true,
})
另一方面:
Object.defineProperty(obj, 'name', {
value: 'Jack'
})
// 上面的代码等同于
Object.defineProperty(obj, 'name', {
value: 'Jack',
writable: false,
configurable: false,
enumerable: false,
})