Object.is()
判断两个值是否是相同的值
下列任何一项成立,则两个值相同:
- 两个值都是 undefined
- 两个值都是 null
- 两个值都是 true,false
- 两个值是由相同个数的字符按照相同的顺序组成的字符串
- 两个值指向同一个对象
- 两个值都是数字并且 都是 +0, -0, NaN, 都是除零和NaN外的其他同一个数字
Object.is('foo', 'foo') // true
Object.is(window, window) // true
Object.is([], []) // false
let foo = {a; 1};
let bar = {a: 1};
object.is(foo, bar); // false
Object.is(null, null); // true
Object.is(0, -0); // false
Object.is(-0, -0); // true
Object.is(NaN, 0/0); // true
Object.isExtensible()
判断一个对象是否是可扩展的(即是否可在它上面添加新的属性)
标记对象为不可扩展
- Object.preventExtensions
- Object.seal
- Object.freeze
Object.isFrozen()
判断一个对象是否冻结 【不可扩展,不可配置,不可写】
console.log(Object.isFrozen({})); // false
// 不可扩展的空对想同时也是一个冻结对象
let vacuouslyFrozen = Object.preventExtensions({});
console.log(Object.isFrozen(vacuouslyFrozen)); // true
// 一个非空对象默认也是非冻结的
let oneProp = {p: 42};
console.log(Object.isFrozen(oneProp)); // false
// 对象不可扩展,并不意味是冻结对象/。因为对象可以是配置的
Object.preventExtensions(oneProp);
console.log(Object.isFrozen(oneProp)); // false
// 若此时删除该对象,则变成一个冻结对象
delete oneProp.p;
console.log(Object.isFrozen(oneProp)); // true
// 一个不可扩展对象,但拥有不可写但可配置的属性,则它仍然是非冻结的
let nonWritable = {e: 'plep'};
Object.preventExtensions(nonWritable);
Object.defineProperty(nonWritable, 'e', {
writable: false, // 不可写
});
console.log(Object.isFrozen(nonWritable)); // false
// 当把这个属性改成不可配置,会让这个对象那个成为冻结对象
Object.defineProperty(nonWritable, 'e', {
configurable: false, // 不可配置
});
console.log(Object.isFrozen(nonWritable)); // true
// 一个不可扩展对象那个,值拥有一个访问属性,则它仍然是非冻结的
let accessor = {
get food() {
return 'yum'
}
};
Object.preventExtensions(accessor);
console.log(Object.isFrozen(accessor)); // false
// 但把这个属性改为不可配置,会热昂这个对象那个成为冻结对象
Object.defineProperty(accessor, 'food', {
configurable: false,
});
console.log(Object.isFrozen(accessor)); // true
// 使用Object.frozen 是冻结一个对象最方便的方法
let frozen = {1: 21};
console.log(Object.isFrozen(frozen)); // false
Object.freeze(frozen);
console.log(Object.isFrozen(frozen)); // true
// 一个冻结对象也是一个密封对象
console.log(Object.isSealed(frozen)); // true
// 一个冻结对象也是一个不可扩展对象
console.log(Object.isExtensible(frozen)); // false
Object.isSealed()
判断一个对象是否被密封
密封对象是指那些不可扩展的,且所有自身属性都不可配置、不可删除的对象。
// 新建对象默认不是密封的
let empty = {};
console.log(Object.isSealed(empty)); // false
// 把一个空对象变得不可扩展,则它同时也会变成密封对象
Object.preventExtensions(empty);
console.log(Object.isSealed(empty)); // true
// 若不是空对象,则它不会变成密封对象,因为密封对象的所有自身属性必须是不可配置的
let hasProp = {fee: 'fie foe fum'};
Object.preventExtensions(hasProp);
console.log(Object.isSealed(hasProp)); // false
// 如果把这个属性变成不可配置,则这个对象也就成了密封对象
Object.defineProperty(hasProp, 'fee', {
configurable: false,
});
console.log(Object.isSealed(hasProp)); // true
// 最简单生存密封对象,是使用Object.seal
let sealed = {};
Object.seal(sealed);
console.log(Object.isSealed(sealed)); // true
// 一个密封对象也是不可扩展的
console.log(Object.isExtensible(sealed)); // false
hasOwnProperty()
判断对象中是否具有指定属性
let obj = {};
obj.name = '张无忌';
obj.age = 18;
obj.sex = null;
console.log(obj.hasOwnProperty('name')); // true
console.log(obj.hasOwnProperty('age')); // true
console.log(obj.hasOwnProperty('sex')); // true
delete obj.sex;
console.log(obj.hasOwnProperty('sex')); // false
isPrototypeOf()
测试一个对象是否在另个对象的原型链上
function Foo() {}
function Bar() {}
function Baz() {}
// Bar 继承 Foo, Baz 继承Bar
Bar.prototype = Object.create(Foo.prototype);
Baz.prototype = Object.create(Bar.prototype);
let baz = new Baz();
console.log(Baz.prototype.isPrototypeOf(baz)); // true
console.log(Bar.prototype.isPrototypeOf(baz)); // true
console.log(Foo.prototype.isPrototypeOf(baz)); // true
console.log(Object.prototype.isPrototypeOf(baz)); // true
propertyIsEnumerable()
判断指定属性是否可枚举
let enumObj = {};
let enumA = {};
enumObj.prop = 'is enumerable';
enumA[0] = 'is enumerable';
Object.defineProperty(enumObj, 'prop', {
enumerable: false
});
console.log(enumObj.propertyIsEnumerable('prop')); // true
console.log(enumA.propertyIsEnumerable(0)); // true
Object.getOwnPropertyDescirptor()
返回指定对象上一个自有属性对应的属性描述符。
let o = {
get foo() {
return 17;
}
};
console.log(Object.getOwnPropertyDescriptor(o, 'foo'));
let a = {bar: 42};
console.log(Object.getOwnPropertyDescriptors(a, 'bar'));
Object.getOwnPropertyDescriptors()
获取一个对象的所有自身属性的描述符
返回值: 所指定对象的所有自身属性的描述符,如果没有任何自身属性,则返回空对象。
let person = {
age: 18,
name: '张三'
};
Object.defineProperty(person, 'name', {
writable: false
});
console.log(Object.getOwnPropertyDescriptors(person));
console.log(Object.getOwnPropertyDescriptors({}));
Object.getOwnPropertyNames()
返回指定对象的所有自身属性的属性名组成的数组,包括可枚举属性但不包括Symbol值作为名称的属性。
let arr = ['a', 'b', 'c'];
console.log(Object.getOwnPropertyNames(arr).sort()); // ["0", "1", "2", "length"]
let obj = { 0: "a", 1: "b", 2: "c"};
console.log(Object.getOwnPropertyNames(obj).sort()); // ["0", "1", "2"]
Object.getOwnPropertySymbols()
返回对象自身的所有Symbol属性的数组
let symObj = {};
let a = Symbol('a');
let b = Symbol('b');
symObj[a] = 'localSymbol';
symObj[b] = 'globalSymbol';
console.log(Object.getOwnPropertySymbols(symObj));
Object.getPrototypeOf()
返回指定对象的原型
let proto = {};
let proObj = Object.create(proto);
console.log(Object.getPrototypeOf(proObj)); // {}
let reg = /a/;
console.log(Object.getPrototypeOf(reg));