JavaScript Object 构造函数方法

野性酷女 2022-11-16 13:52 210阅读 0赞

（1）Object.assign()

Object.assign() 方法用于将所有可枚举属性的值从一个或多个源对象分配到目标对象。它将返回目标对象。

语法：

  1. Object.assign(target, ...sources)

参数：

  • target 目标对象
  • sources 源对象

示例：复制一个对象

  1. const obj = {  a: 1 };
  2. const copy = Object.assign({ }, obj);
  3. console.log(copy); // { a: 1 }

（2）Object.create()

Object.create() 方法创建一个新对象，使用现有的对象来提供新创建的对象的 __proto__。

语法：

  1. Object.create(proto，[propertiesObject])

参数：

  • proto 新创建对象的原型对象。
  • propertiesObject
    可选。需要传入一个对象，该对象的属性类型参照Object.defineProperties()的第二个参数。如果该参数被指定且不为 undefined，该传入对象的自有可枚举属性(即其自身定义的属性，而不是其原型链上的枚举属性)将为新创建的对象添加指定的属性值和对应的属性描述符。

返回值：
一个新对象，带着指定的原型对象和属性。

示例：用 Object.create 实现类式继承

  1. // Shape - 父类(superclass)
  2. function Shape() { 
  3.   this.x = 0;
  4.   this.y = 0;
  5. }
  7. // 父类的方法
  8. Shape.prototype.move = function(x, y) { 
  9.   this.x += x;
  10.   this.y += y;
  11.   console.info('Shape moved.');
  12. };
  14. // Rectangle - 子类(subclass)
  15. function Rectangle() { 
  16.   Shape.call(this); // call super constructor.
  17. }
  19. // 子类续承父类
  20. Rectangle.prototype = Object.create(Shape.prototype);
  21. Rectangle.prototype.constructor = Rectangle;
  23. var rect = new Rectangle();
  25. console.log('Is rect an instance of Rectangle?',
  26.   rect instanceof Rectangle); // true
  27. console.log('Is rect an instance of Shape?',
  28.   rect instanceof Shape); // true
  29. rect.move(1, 1); // Outputs, 'Shape moved.'

（3）Object.defineProperty()

Object.defineProperty() 方法会直接在一个对象上定义一个新属性，或者修改一个对象的现有属性，并返回此对象。

语法：

  1. Object.defineProperty(obj, prop, descriptor)

参数：

  • obj 要定义属性的对象。
  • prop 要定义或修改的属性的名称或 Symbol。
  • descriptor 要定义或修改的属性描述符。

返回值：
被传递给函数的对象。

示例：创建属性

如果对象中不存在指定的属性，Object.defineProperty() 会创建这个属性。当描述符中省略某些字段时，这些字段将使用它们的默认值。

  1. var o = { }; // 创建一个新对象
  3. // 在对象中添加一个属性与数据描述符的示例
  4. Object.defineProperty(o, "a", { 
  5.   value : 37,
  6.   writable : true,
  7.   enumerable : true,
  8.   configurable : true
  9. });
  11. // 对象 o 拥有了属性 a，值为 37
  13. // 在对象中添加一个设置了存取描述符属性的示例
  14. var bValue = 38;
  15. Object.defineProperty(o, "b", { 
  16.   // 使用了方法名称缩写（ES2015 特性）
  17.   // 下面两个缩写等价于：
  18.   // get : function() { return bValue; },
  19.   // set : function(newValue) { bValue = newValue; },
  20.   get() {  return bValue; },
  21.   set(newValue) {  bValue = newValue; },
  22.   enumerable : true,
  23.   configurable : true
  24. });
  26. o.b; // 38
  27. // 对象 o 拥有了属性 b，值为 38
  28. // 现在，除非重新定义 o.b，o.b 的值总是与 bValue 相同
  30. // 数据描述符和存取描述符不能混合使用
  31. Object.defineProperty(o, "conflict", { 
  32.   value: 0x9f91102,
  33.   get() {  return 0xdeadbeef; }
  34. });
  35. // 抛出错误 TypeError: value appears only in data descriptors, get appears only in accessor descriptors

（4）Object.defineProperties()

Object.defineProperties() 方法直接在一个对象上定义新的属性或修改现有属性，并返回该对象。

语法：

  1. Object.defineProperties(obj, props)

参数：

  • obj 在其上定义或修改属性的对象。
  • props 要定义其可枚举属性或修改的属性描述符的对象。对象中存在的属性描述符主要有两种：数据描述符和访问器描述符。

返回值：
传递给函数的对象。

示例：

Object.defineProperties 本质上定义了obj 对象上props的可枚举属性相对应的所有属性。

  1. var obj = { };
  2. Object.defineProperties(obj, { 
  3.     'property1': { 
  4.      value: true,
  5.      writable: true
  6.     },
  7.     'property2': { 
  8.      value: 'Hello',
  9.      writable: false
  10.     }
  11.      // etc. etc.
  12. });

（5）Object.entries()

Object.entries() 方法返回一个给定对象自身可枚举属性的键值对数组，其排列与使用 for...in 循环遍历该对象时返回的顺序一致（区别在于 for-in 循环还会枚举原型链中的属性）。

语法：

  1. Object.entries(obj)

参数：

  • obj 可以返回其可枚举属性的键值对的对象。

返回值：
给定对象自身可枚举属性的键值对数组。

示例：

  1. const obj = {  foo: 'bar', baz: 42 };
  2. console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]
  4. // array like object
  5. const obj = {  0: 'a', 1: 'b', 2: 'c' };
  6. console.log(Object.entries(obj)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ]
  8. // array like object with random key ordering
  9. const anObj = {  100: 'a', 2: 'b', 7: 'c' };
  10. console.log(Object.entries(anObj)); // [ ['2', 'b'], ['7', 'c'], ['100', 'a'] ]
  12. // getFoo is property which isn't enumerable
  13. const myObj = Object.create({ }, {  getFoo: {  value() {  return this.foo; } } });
  14. myObj.foo = 'bar';
  15. console.log(Object.entries(myObj)); // [ ['foo', 'bar'] ]
  17. // non-object argument will be coerced to an object
  18. console.log(Object.entries('foo')); // [ ['0', 'f'], ['1', 'o'], ['2', 'o'] ]
  20. // iterate through key-value gracefully
  21. const obj = {  a: 5, b: 7, c: 9 };
  22. for (const [key, value] of Object.entries(obj)) { 
  23.   console.log(`${ key} ${ value}`); // "a 5", "b 7", "c 9"
  24. }
  26. // Or, using array extras
  27. Object.entries(obj).forEach(([key, value]) => { 
  28. console.log(`${ key} ${ value}`); // "a 5", "b 7", "c 9"
  29. });

（6）Object.freeze()

Object.freeze() 方法可以冻结一个对象。一个被冻结的对象再也不能被修改；freeze() 返回和传入的参数相同的对象。

语法：

  1. Object.freeze(obj)

参数：

  • obj 要被冻结的对象。

返回值：
被冻结的对象。

示例：冻结对象

  1. var obj = { 
  2.   prop: function() { },
  3.   foo: 'bar'
  4. };
  6. // 新的属性会被添加, 已存在的属性可能
  7. // 会被修改或移除
  8. obj.foo = 'baz';
  9. obj.lumpy = 'woof';
  10. delete obj.prop;
  12. // 作为参数传递的对象与返回的对象都被冻结
  13. // 所以不必保存返回的对象（因为两个对象全等）
  14. var o = Object.freeze(obj);
  16. o === obj; // true
  17. Object.isFrozen(obj); // === true
  19. // 现在任何改变都会失效
  20. obj.foo = 'quux'; // 静默地不做任何事
  21. // 静默地不添加此属性
  22. obj.quaxxor = 'the friendly duck';
  24. // 在严格模式，如此行为将抛出 TypeErrors
  25. function fail(){ 
  26.   'use strict';
  27.   obj.foo = 'sparky'; // throws a TypeError
  28.   delete obj.quaxxor; // 返回true，因为quaxxor属性从来未被添加
  29.   obj.sparky = 'arf'; // throws a TypeError
  30. }
  32. fail();
  34. // 试图通过 Object.defineProperty 更改属性
  35. // 下面两个语句都会抛出 TypeError.
  36. Object.defineProperty(obj, 'ohai', {  value: 17 });
  37. Object.defineProperty(obj, 'foo', {  value: 'eit' });
  39. // 也不能更改原型
  40. // 下面两个语句都会抛出 TypeError.
  41. Object.setPrototypeOf(obj, {  x: 20 })
  42. obj.__proto__ = {  x: 20 }

（7）Object.getOwnPropertyDescriptor()

Object.getOwnPropertyDescriptor() 方法返回指定对象上一个自有属性对应的属性描述符。

语法：

  1. Object.getOwnPropertyDescriptor(obj, prop)

参数：

  • obj 需要查找的目标对象。
  • prop 目标对象内属性名称。

返回值：
如果指定的属性存在于对象上，则返回其属性描述符对象（property descriptor），否则返回 undefined。

示例：

  1. var o, d;
  3. o = {  get foo() {  return 17; } };
  4. d = Object.getOwnPropertyDescriptor(o, "foo");
  5. // d { 
  6. // configurable: true,
  7. // enumerable: true,
  8. // get: /*the getter function*/,
  9. // set: undefined
  10. // }
  12. o = {  bar: 42 };
  13. d = Object.getOwnPropertyDescriptor(o, "bar");
  14. // d { 
  15. // configurable: true,
  16. // enumerable: true,
  17. // value: 42,
  18. // writable: true
  19. // }
  21. o = { };
  22. Object.defineProperty(o, "baz", { 
  23.   value: 8675309,
  24.   writable: false,
  25.   enumerable: false
  26. });
  27. d = Object.getOwnPropertyDescriptor(o, "baz");
  28. // d { 
  29. // value: 8675309,
  30. // writable: false,
  31. // enumerable: false,
  32. // configurable: false
  33. // }

（8）Object.getOwnPropertyNames()

Object.getOwnPropertyNames() 方法返回一个由指定对象的所有自身属性的属性名（包括不可枚举属性但不包括Symbol值作为名称的属性）组成的数组。

语法：

  1. Object.getOwnPropertyNames(obj)

参数：

  • obj 一个对象，其自身的可枚举和不可枚举属性的名称被返回。

返回值：
在给定对象上找到的自身属性对应的字符串数组。

示例：

  1. var arr = ["a", "b", "c"];
  2. console.log(Object.getOwnPropertyNames(arr).sort()); // ["0", "1", "2", "length"]
  4. // 类数组对象
  5. var obj = {  0: "a", 1: "b", 2: "c"};
  6. console.log(Object.getOwnPropertyNames(obj).sort()); // ["0", "1", "2"]
  8. // 使用Array.forEach输出属性名和属性值
  9. Object.getOwnPropertyNames(obj).forEach(function(val, idx, array) { 
  10.   console.log(val + " -> " + obj[val]);
  11. });
  12. // 输出
  13. // 0 -> a
  14. // 1 -> b
  15. // 2 -> c
  17. //不可枚举属性
  18. var my_obj = Object.create({ }, { 
  19.   getFoo: { 
  20.     value: function() {  return this.foo; },
  21.     enumerable: false
  22.   }
  23. });
  24. my_obj.foo = 1;
  26. console.log(Object.getOwnPropertyNames(my_obj).sort()); // ["foo", "getFoo"]

（9）Object.getOwnPropertySymbols()

Object.getOwnPropertySymbols() 方法返回一个给定对象自身的所有 Symbol 属性的数组。

语法：

  1. Object.getOwnPropertySymbols(obj)

参数：

  • obj 要返回 Symbol 属性的对象。

返回值：
在给定对象自身上找到的所有 Symbol 属性的数组。

示例：

  1. var obj = { };
  2. var a = Symbol("a");
  3. var b = Symbol.for("b");
  5. obj[a] = "localSymbol";
  6. obj[b] = "globalSymbol";
  8. var objectSymbols = Object.getOwnPropertySymbols(obj);
  10. console.log(objectSymbols.length); // 2
  11. console.log(objectSymbols)         // [Symbol(a), Symbol(b)]
  12. console.log(objectSymbols[0])      // Symbol(a)

（10）Object.getPrototypeOf()

Object.getPrototypeOf() 方法返回指定对象的原型。

语法：

  1. Object.getPrototypeOf(object)

参数：

  • obj 要返回其原型的对象。

返回值：
给定对象的原型。如果没有继承属性，则返回 null。

示例：

  1. var proto = { };
  2. var obj = Object.create(proto);
  3. Object.getPrototypeOf(obj) === proto; // true
  5. var reg = /a/;
  6. Object.getPrototypeOf(reg) === RegExp.prototype; // true

（11）Object.is()

Object.is() 方法判断两个值是否为同一个值。

语法：

  1. Object.is(value1, value2);

参数：

  • value1 被比较的第一个值。
  • value2 被比较的第二个值。

返回值：
一个 Boolean 类型标示两个参数是否是同一个值。

示例：

  1. if (!Object.is) { 
  2.   Object.is = function(x, y) { 
  3.     // SameValue algorithm
  4.     if (x === y) {  // Steps 1-5, 7-10
  5.       // Steps 6.b-6.e: +0 != -0
  6.       return x !== 0 || 1 / x === 1 / y;
  7.     } else { 
  8.       // Step 6.a: NaN == NaN
  9.       return x !== x && y !== y;
  10.     }
  11.   };
  12. }

（12）Object.isExtensible()

Object.isExtensible() 方法判断一个对象是否是可扩展的（是否可以在它上面添加新的属性）。

语法：

  1. Object.isExtensible(obj)

参数：

  • obj 需要检测的对象

返回值：
表示给定对象是否可扩展的一个Boolean。

示例：

  1. // 新对象默认是可扩展的.
  2. var empty = { };
  3. Object.isExtensible(empty); // === true
  5. // ...可以变的不可扩展.
  6. Object.preventExtensions(empty);
  7. Object.isExtensible(empty); // === false
  9. // 密封对象是不可扩展的.
  10. var sealed = Object.seal({ });
  11. Object.isExtensible(sealed); // === false
  13. // 冻结对象也是不可扩展.
  14. var frozen = Object.freeze({ });
  15. Object.isExtensible(frozen); // === false

（13）Object.isFrozen()
Object.isFrozen()方法判断一个对象是否被冻结。

语法：

  1. Object.isFrozen(obj)

参数：

  • obj 被检测的对象。

返回值：
表示给定对象是否被冻结的Boolean。

示例：

  1. // 一个对象默认是可扩展的,所以它也是非冻结的.
  2. Object.isFrozen({ }); // === false
  4. // 一个不可扩展的空对象同时也是一个冻结对象.
  5. var vacuouslyFrozen = Object.preventExtensions({ });
  6. Object.isFrozen(vacuouslyFrozen) //=== true;
  8. // 一个非空对象默认也是非冻结的.
  9. var oneProp = {  p: 42 };
  10. Object.isFrozen(oneProp) //=== false
  12. // 让这个对象变的不可扩展,并不意味着这个对象变成了冻结对象,
  13. // 因为p属性仍然是可以配置的(而且可写的).
  14. Object.preventExtensions(oneProp);
  15. Object.isFrozen(oneProp) //=== false
  17. // 此时,如果删除了这个属性,则它会成为一个冻结对象.
  18. delete oneProp.p;
  19. Object.isFrozen(oneProp) //=== true
  21. // 一个不可扩展的对象,拥有一个不可写但可配置的属性,则它仍然是非冻结的.
  22. var nonWritable = {  e: "plep" };
  23. Object.preventExtensions(nonWritable);
  24. Object.defineProperty(nonWritable, "e", {  writable: false }); // 变得不可写
  25. Object.isFrozen(nonWritable) //=== false
  27. // 把这个属性改为不可配置,会让这个对象成为冻结对象.
  28. Object.defineProperty(nonWritable, "e", {  configurable: false }); // 变得不可配置
  29. Object.isFrozen(nonWritable) //=== true
  31. // 一个不可扩展的对象,拥有一个不可配置但可写的属性,则它仍然是非冻结的.
  32. var nonConfigurable = {  release: "the kraken!" };
  33. Object.preventExtensions(nonConfigurable);
  34. Object.defineProperty(nonConfigurable, "release", {  configurable: false });
  35. Object.isFrozen(nonConfigurable) //=== false
  37. // 把这个属性改为不可写,会让这个对象成为冻结对象.
  38. Object.defineProperty(nonConfigurable, "release", {  writable: false });
  39. Object.isFrozen(nonConfigurable) //=== true
  41. // 一个不可扩展的对象,值拥有一个访问器属性,则它仍然是非冻结的.
  42. var accessor = {  get food() {  return "yum"; } };
  43. Object.preventExtensions(accessor);
  44. Object.isFrozen(accessor) //=== false
  46. // ...但把这个属性改为不可配置,会让这个对象成为冻结对象.
  47. Object.defineProperty(accessor, "food", {  configurable: false });
  48. Object.isFrozen(accessor) //=== true
  50. // 使用Object.freeze是冻结一个对象最方便的方法.
  51. var frozen = {  1: 81 };
  52. Object.isFrozen(frozen) //=== false
  53. Object.freeze(frozen);
  54. Object.isFrozen(frozen) //=== true
  56. // 一个冻结对象也是一个密封对象.
  57. Object.isSealed(frozen) //=== true
  59. // 当然,更是一个不可扩展的对象.
  60. Object.isExtensible(frozen) //=== false

（14）Object.isSealed()

Object.isSealed() 方法判断一个对象是否被密封。

语法：

  1. Object.isSealed(obj)

参数：

  • obj 要被检查的对象。

返回值：
表示给定对象是否被密封的一个Boolean 。

示例：

  1. // 新建的对象默认不是密封的.
  2. var empty = { };
  3. Object.isSealed(empty); // === false
  5. // 如果你把一个空对象变的不可扩展,则它同时也会变成个密封对象.
  6. Object.preventExtensions(empty);
  7. Object.isSealed(empty); // === true
  9. // 但如果这个对象不是空对象,则它不会变成密封对象,因为密封对象的所有自身属性必须是不可配置的.
  10. var hasProp = {  fee: "fie foe fum" };
  11. Object.preventExtensions(hasProp);
  12. Object.isSealed(hasProp); // === false
  14. // 如果把这个属性变的不可配置,则这个属性也就成了密封对象.
  15. Object.defineProperty(hasProp, "fee", {  configurable: false });
  16. Object.isSealed(hasProp); // === false
  17. Object.isSealed(hasProp.fee); // === true
  19. // 最简单的方法来生成一个密封对象,当然是使用Object.seal.
  20. var sealed = { };
  21. Object.seal(sealed);
  22. Object.isSealed(sealed); // === true
  24. // 一个密封对象同时也是不可扩展的.
  25. Object.isExtensible(sealed); // === false
  27. // 一个密封对象也可以是一个冻结对象,但不是必须的.
  28. Object.isFrozen(sealed); // === true ，所有的属性都是不可写的
  29. var s2 = Object.seal({  p: 3 });
  30. Object.isFrozen(s2); // === false， 属性"p"可写
  32. var s3 = Object.seal({  get p() {  return 0; } });
  33. Object.isFrozen(s3); // === true ，访问器属性不考虑可写不可写,只考虑是否可配置

（15）Object.keys()

Object.keys() 方法会返回一个由一个给定对象的自身可枚举属性组成的数组，数组中属性名的排列顺序和正常循环遍历该对象时返回的顺序一致 。

语法：

  1. Object.keys(obj)

参数：

  • obj 要返回其枚举自身属性的对象。

返回值：
一个表示给定对象的所有可枚举属性的字符串数组。

示例：

  1. // simple array
  2. var arr = ['a', 'b', 'c'];
  3. console.log(Object.keys(arr)); // console: ['0', '1', '2']
  5. // array like object
  6. var obj = {  0: 'a', 1: 'b', 2: 'c' };
  7. console.log(Object.keys(obj)); // console: ['0', '1', '2']
  9. // array like object with random key ordering
  10. var anObj = {  100: 'a', 2: 'b', 7: 'c' };
  11. console.log(Object.keys(anObj)); // console: ['2', '7', '100']
  13. // getFoo is a property which isn't enumerable
  14. var myObj = Object.create({ }, { 
  15.   getFoo: { 
  16.     value: function () {  return this.foo; }
  17.   }
  18. });
  19. myObj.foo = 1;
  20. console.log(Object.keys(myObj)); // console: ['foo']

（16）Object.preventExtensions()

Object.preventExtensions() 方法让一个对象变的不可扩展，也就是永远不能再添加新的属性。

语法：

  1. Object.preventExtensions(obj)

参数：

  • obj 将要变得不可扩展的对象。

返回值：
已经不可扩展的对象。

示例：

  1. // Object.preventExtensions将原对象变的不可扩展,并且返回原对象.
  2. var obj = { };
  3. var obj2 = Object.preventExtensions(obj);
  4. obj === obj2;  // true
  6. // 字面量方式定义的对象默认是可扩展的.
  7. var empty = { };
  8. Object.isExtensible(empty) //=== true
  10. // ...但可以改变.
  11. Object.preventExtensions(empty);
  12. Object.isExtensible(empty) //=== false
  14. // 使用Object.defineProperty方法为一个不可扩展的对象添加新属性会抛出异常.
  15. var nonExtensible = {  removable: true };
  16. Object.preventExtensions(nonExtensible);
  17. Object.defineProperty(nonExtensible, "new", {  value: 8675309 }); // 抛出TypeError异常
  19. // 在严格模式中,为一个不可扩展对象的新属性赋值会抛出TypeError异常.
  20. function fail()
  21. { 
  22.   "use strict";
  23.   nonExtensible.newProperty = "FAIL"; // throws a TypeError
  24. }
  25. fail();

（17）Object.seal()

Object.seal()方法封闭一个对象，阻止添加新属性并将所有现有属性标记为不可配置。当前属性的值只要原来是可写的就可以改变。

语法：

  1. Object.seal(obj)

参数：

  • obj 将要被密封的对象。

返回值：
被密封的对象。

示例：

  1. var obj = { 
  2.   prop: function() { },
  3.   foo: 'bar'
  4. };
  6. // 可以添加新的属性
  7. // 可以更改或删除现有的属性
  8. obj.foo = 'baz';
  9. obj.lumpy = 'woof';
  10. delete obj.prop;
  12. var o = Object.seal(obj);
  14. o === obj; // true
  15. Object.isSealed(obj); // === true
  17. // 仍然可以修改密封对象的属性值
  18. obj.foo = 'quux';
  21. // 但是你不能将属性重新定义成为访问器属性
  22. // 反之亦然
  23. Object.defineProperty(obj, 'foo', { 
  24.   get: function() {  return 'g'; }
  25. }); // throws a TypeError
  27. // 除了属性值以外的任何变化，都会失败.
  28. obj.quaxxor = 'the friendly duck';
  29. // 添加属性将会失败
  30. delete obj.foo;
  31. // 删除属性将会失败
  33. // 在严格模式下，这样的尝试将会抛出错误
  34. function fail() { 
  35.   'use strict';
  36.   delete obj.foo; // throws a TypeError
  37.   obj.sparky = 'arf'; // throws a TypeError
  38. }
  39. fail();
  41. // 通过Object.defineProperty添加属性将会报错
  42. Object.defineProperty(obj, 'ohai', { 
  43.   value: 17
  44. }); // throws a TypeError
  45. Object.defineProperty(obj, 'foo', { 
  46.   value: 'eit'
  47. }); // 通过Object.defineProperty修改属性值

（18）Object.setPrototypeOf()

Object.setPrototypeOf() 方法设置一个指定的对象的原型 ( 即, 内部[[Prototype]]属性）到另一个对象或 null。

语法：

  1. Object.setPrototypeOf(obj, prototype)

参数：

  • obj 要设置其原型的对象。
  • prototype 该对象的新原型(一个对象 或 null)。

示例：

  1. var dict = Object.setPrototypeOf({ }, null);

（19）Object.values()

Object.values()方法返回一个给定对象自身的所有可枚举属性值的数组，值的顺序与使用 for...in 循环的顺序相同 ( 区别在于 for-in 循环枚举原型链中的属性 )。

语法：

  1. Object.values(obj)

参数：

  • obj 被返回可枚举属性值的对象。

返回值：
一个包含对象自身的所有可枚举属性值的数组。

示例：

  1. var obj = {  foo: 'bar', baz: 42 };
  2. console.log(Object.values(obj)); // ['bar', 42]
  4. // array like object
  5. var obj = {  0: 'a', 1: 'b', 2: 'c' };
  6. console.log(Object.values(obj)); // ['a', 'b', 'c']
  8. // array like object with random key ordering
  9. // when we use numeric keys, the value returned in a numerical order according to the keys
  10. var an_obj = {  100: 'a', 2: 'b', 7: 'c' };
  11. console.log(Object.values(an_obj)); // ['b', 'c', 'a']
  13. // getFoo is property which isn't enumerable
  14. var my_obj = Object.create({ }, {  getFoo: {  value: function() {  return this.foo; } } });
  15. my_obj.foo = 'bar';
  16. console.log(Object.values(my_obj)); // ['bar']
  18. // non-object argument will be coerced to an object
  19. console.log(Object.values('foo')); // ['f', 'o', 'o']

发表评论

表情：
评论列表 （有 0 条评论，210人围观）

还没有评论，来说两句吧...

相关阅读

    相关 JavaScript构造函数

    JavaScript构造函数是一种特殊类型的函数，用于创建和初始化对象。它们通常用于定义自定义对象类型，以便在实例化对象时可以对其属性和方法进行初始化。构造函数通常以大写字母开

    一时失言乱红尘一时失言乱红尘/ 0 赞/ 100 阅读

    相关 javascript（二）构造函数

    前一小节讲述的对象创建方法都有一个弱点，就是创建对象的代码是一次性的。如果我们想创建多个规划好的对象，有若干个固定的属性、方法，并能够初始化，就像 C++ 语言中的对象一样，J

    超、凢脫俗超、凢脫俗/ 0 赞/ 280 阅读

    相关 java构造函数（构造方法）

    构造方法是类里的一个特殊的方法，他不能有返回值（包括void）。所谓构造方法，就是这个类在被实例化时（创建对象时）就要执行的方法，方法名为类的名字，一般的目的是为了给类进行一些

    Myth丶恋晨Myth丶恋晨/ 0 赞/ 432 阅读