Object - 下

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));