Object.is()

判断两个值是否是相同的值

下列任何一项成立,则两个值相同:

  • 两个值都是 undefined
  • 两个值都是 null
  • 两个值都是 true,false
  • 两个值是由相同个数的字符按照相同的顺序组成的字符串
  • 两个值指向同一个对象
  • 两个值都是数字并且 都是 +0, -0, NaN, 都是除零和NaN外的其他同一个数字
  1. Object.is('foo', 'foo') // true
  2. Object.is(window, window) // true
  3. Object.is([], []) // false
  4. let foo = {a; 1};
  5. let bar = {a: 1};
  6. object.is(foo, bar); // false
  7. Object.is(null, null); // true
  8. Object.is(0, -0); // false
  9. Object.is(-0, -0); // true
  10. Object.is(NaN, 0/0); // true

Object.isExtensible()

判断一个对象是否是可扩展的(即是否可在它上面添加新的属性)

标记对象为不可扩展

  • Object.preventExtensions
  • Object.seal
  • Object.freeze

Object.isFrozen()

判断一个对象是否冻结 【不可扩展,不可配置,不可写】

  1. console.log(Object.isFrozen({})); // false
  2. // 不可扩展的空对想同时也是一个冻结对象
  3. let vacuouslyFrozen = Object.preventExtensions({});
  4. console.log(Object.isFrozen(vacuouslyFrozen)); // true
  5. // 一个非空对象默认也是非冻结的
  6. let oneProp = {p: 42};
  7. console.log(Object.isFrozen(oneProp)); // false
  8. // 对象不可扩展,并不意味是冻结对象/。因为对象可以是配置的
  9. Object.preventExtensions(oneProp);
  10. console.log(Object.isFrozen(oneProp)); // false
  11. // 若此时删除该对象,则变成一个冻结对象
  12. delete oneProp.p;
  13. console.log(Object.isFrozen(oneProp)); // true
  14. // 一个不可扩展对象,但拥有不可写但可配置的属性,则它仍然是非冻结的
  15. let nonWritable = {e: 'plep'};
  16. Object.preventExtensions(nonWritable);
  17. Object.defineProperty(nonWritable, 'e', {
  18. writable: false, // 不可写
  19. });
  20. console.log(Object.isFrozen(nonWritable)); // false
  21. // 当把这个属性改成不可配置,会让这个对象那个成为冻结对象
  22. Object.defineProperty(nonWritable, 'e', {
  23. configurable: false, // 不可配置
  24. });
  25. console.log(Object.isFrozen(nonWritable)); // true
  26. // 一个不可扩展对象那个,值拥有一个访问属性,则它仍然是非冻结的
  27. let accessor = {
  28. get food() {
  29. return 'yum'
  30. }
  31. };
  32. Object.preventExtensions(accessor);
  33. console.log(Object.isFrozen(accessor)); // false
  34. // 但把这个属性改为不可配置,会热昂这个对象那个成为冻结对象
  35. Object.defineProperty(accessor, 'food', {
  36. configurable: false,
  37. });
  38. console.log(Object.isFrozen(accessor)); // true
  39. // 使用Object.frozen 是冻结一个对象最方便的方法
  40. let frozen = {1: 21};
  41. console.log(Object.isFrozen(frozen)); // false
  42. Object.freeze(frozen);
  43. console.log(Object.isFrozen(frozen)); // true
  44. // 一个冻结对象也是一个密封对象
  45. console.log(Object.isSealed(frozen)); // true
  46. // 一个冻结对象也是一个不可扩展对象
  47. console.log(Object.isExtensible(frozen)); // false

Object.isSealed()

判断一个对象是否被密封
密封对象是指那些不可扩展的,且所有自身属性都不可配置、不可删除的对象。

  1. // 新建对象默认不是密封的
  2. let empty = {};
  3. console.log(Object.isSealed(empty)); // false
  4. // 把一个空对象变得不可扩展,则它同时也会变成密封对象
  5. Object.preventExtensions(empty);
  6. console.log(Object.isSealed(empty)); // true
  7. // 若不是空对象,则它不会变成密封对象,因为密封对象的所有自身属性必须是不可配置的
  8. let hasProp = {fee: 'fie foe fum'};
  9. Object.preventExtensions(hasProp);
  10. console.log(Object.isSealed(hasProp)); // false
  11. // 如果把这个属性变成不可配置,则这个对象也就成了密封对象
  12. Object.defineProperty(hasProp, 'fee', {
  13. configurable: false,
  14. });
  15. console.log(Object.isSealed(hasProp)); // true
  16. // 最简单生存密封对象,是使用Object.seal
  17. let sealed = {};
  18. Object.seal(sealed);
  19. console.log(Object.isSealed(sealed)); // true
  20. // 一个密封对象也是不可扩展的
  21. console.log(Object.isExtensible(sealed)); // false

hasOwnProperty()

判断对象中是否具有指定属性

  1. let obj = {};
  2. obj.name = '张无忌';
  3. obj.age = 18;
  4. obj.sex = null;
  5. console.log(obj.hasOwnProperty('name')); // true
  6. console.log(obj.hasOwnProperty('age')); // true
  7. console.log(obj.hasOwnProperty('sex')); // true
  8. delete obj.sex;
  9. console.log(obj.hasOwnProperty('sex')); // false

isPrototypeOf()

测试一个对象是否在另个对象的原型链上

  1. function Foo() {}
  2. function Bar() {}
  3. function Baz() {}
  4. // Bar 继承 Foo, Baz 继承Bar
  5. Bar.prototype = Object.create(Foo.prototype);
  6. Baz.prototype = Object.create(Bar.prototype);
  7. let baz = new Baz();
  8. console.log(Baz.prototype.isPrototypeOf(baz)); // true
  9. console.log(Bar.prototype.isPrototypeOf(baz)); // true
  10. console.log(Foo.prototype.isPrototypeOf(baz)); // true
  11. console.log(Object.prototype.isPrototypeOf(baz)); // true

propertyIsEnumerable()

判断指定属性是否可枚举

  1. let enumObj = {};
  2. let enumA = {};
  3. enumObj.prop = 'is enumerable';
  4. enumA[0] = 'is enumerable';
  5. Object.defineProperty(enumObj, 'prop', {
  6. enumerable: false
  7. });
  8. console.log(enumObj.propertyIsEnumerable('prop')); // true
  9. console.log(enumA.propertyIsEnumerable(0)); // true

Object.getOwnPropertyDescirptor()

返回指定对象上一个自有属性对应的属性描述符。

  1. let o = {
  2. get foo() {
  3. return 17;
  4. }
  5. };
  6. console.log(Object.getOwnPropertyDescriptor(o, 'foo'));
  7. let a = {bar: 42};
  8. console.log(Object.getOwnPropertyDescriptors(a, 'bar'));

Object.getOwnPropertyDescriptors()

获取一个对象的所有自身属性的描述符

返回值: 所指定对象的所有自身属性的描述符,如果没有任何自身属性,则返回空对象。

  1. let person = {
  2. age: 18,
  3. name: '张三'
  4. };
  5. Object.defineProperty(person, 'name', {
  6. writable: false
  7. });
  8. console.log(Object.getOwnPropertyDescriptors(person));
  9. console.log(Object.getOwnPropertyDescriptors({}));

Object.getOwnPropertyNames()

返回指定对象的所有自身属性的属性名组成的数组,包括可枚举属性但不包括Symbol值作为名称的属性。

  1. let arr = ['a', 'b', 'c'];
  2. console.log(Object.getOwnPropertyNames(arr).sort()); // ["0", "1", "2", "length"]
  3. let obj = { 0: "a", 1: "b", 2: "c"};
  4. console.log(Object.getOwnPropertyNames(obj).sort()); // ["0", "1", "2"]

Object.getOwnPropertySymbols()

返回对象自身的所有Symbol属性的数组

  1. let symObj = {};
  2. let a = Symbol('a');
  3. let b = Symbol('b');
  4. symObj[a] = 'localSymbol';
  5. symObj[b] = 'globalSymbol';
  6. console.log(Object.getOwnPropertySymbols(symObj));

Object.getPrototypeOf()

返回指定对象的原型

  1. let proto = {};
  2. let proObj = Object.create(proto);
  3. console.log(Object.getPrototypeOf(proObj)); // {}
  4. let reg = /a/;
  5. console.log(Object.getPrototypeOf(reg));