JavaScript Object 构造函数方法

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

**（1）Object.assign()**

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

**语法**：

Object.assign(target, ...sources)

**参数**：

*  `target` 目标对象
 *  `sources` 源对象

**示例：复制一个对象**

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

**（2）Object.create()**

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

**语法**：

Object.create(proto，[propertiesObject])

**参数**：

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

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

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

// Shape - 父类(superclass)
    function Shape() { 
      this.x = 0;
      this.y = 0;
    }
    
    // 父类的方法
    Shape.prototype.move = function(x, y) { 
      this.x += x;
      this.y += y;
      console.info('Shape moved.');
    };
    
    // Rectangle - 子类(subclass)
    function Rectangle() { 
      Shape.call(this); // call super constructor.
    }
    
    // 子类续承父类
    Rectangle.prototype = Object.create(Shape.prototype);
    Rectangle.prototype.constructor = Rectangle;
    
    var rect = new Rectangle();
    
    console.log('Is rect an instance of Rectangle?',
      rect instanceof Rectangle); // true
    console.log('Is rect an instance of Shape?',
      rect instanceof Shape); // true
    rect.move(1, 1); // Outputs, 'Shape moved.'

**（3）Object.defineProperty()**

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

**语法**：

Object.defineProperty(obj, prop, descriptor)

**参数**：

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

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

**示例：创建属性**

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

**（4）Object.defineProperties()**

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

**语法**：

Object.defineProperties(obj, props)

**参数**：

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

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

**示例**：

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

var obj = { };
    Object.defineProperties(obj, { 
        'property1': { 
         value: true,
         writable: true
        },
        'property2': { 
         value: 'Hello',
         writable: false
        }
         // etc. etc.
    });

**（5）Object.entries()**

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

**语法**：

Object.entries(obj)

**参数**：

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

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

**示例**：

**（6）Object.freeze()**

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

**语法**：

Object.freeze(obj)

**参数**：

*  `obj` 要被冻结的对象。

**返回值**：  
被冻结的对象。

**示例：冻结对象**

**（7）Object.getOwnPropertyDescriptor()**

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

**语法**：

Object.getOwnPropertyDescriptor(obj, prop)

**参数**：

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

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

**示例**：

var o, d;
    
    o = {  get foo() {  return 17; } };
    d = Object.getOwnPropertyDescriptor(o, "foo");
    // d { 
    // configurable: true,
    // enumerable: true,
    // get: /*the getter function*/,
    // set: undefined
    // }
    
    o = {  bar: 42 };
    d = Object.getOwnPropertyDescriptor(o, "bar");
    // d { 
    // configurable: true,
    // enumerable: true,
    // value: 42,
    // writable: true
    // }
    
    o = { };
    Object.defineProperty(o, "baz", { 
      value: 8675309,
      writable: false,
      enumerable: false
    });
    d = Object.getOwnPropertyDescriptor(o, "baz");
    // d { 
    // value: 8675309,
    // writable: false,
    // enumerable: false,
    // configurable: false
    // }

**（8）Object.getOwnPropertyNames()**

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

**语法**：

Object.getOwnPropertyNames(obj)

**参数**：

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

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

**示例**：

**（9）Object.getOwnPropertySymbols()**

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

**语法**：

Object.getOwnPropertySymbols(obj)

**参数**：

*  `obj` 要返回 Symbol 属性的对象。

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

**示例**：

var obj = { };
    var a = Symbol("a");
    var b = Symbol.for("b");
    
    obj[a] = "localSymbol";
    obj[b] = "globalSymbol";
    
    var objectSymbols = Object.getOwnPropertySymbols(obj);
    
    console.log(objectSymbols.length); // 2
    console.log(objectSymbols)         // [Symbol(a), Symbol(b)]
    console.log(objectSymbols[0])      // Symbol(a)

**（10）Object.getPrototypeOf()**

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

**语法**：

Object.getPrototypeOf(object)

**参数**：

*  `obj` 要返回其原型的对象。

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

**示例**：

var proto = { };
    var obj = Object.create(proto);
    Object.getPrototypeOf(obj) === proto; // true
    
    var reg = /a/;
    Object.getPrototypeOf(reg) === RegExp.prototype; // true

**（11）Object.is()**

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

**语法**：

Object.is(value1, value2);

**参数**：

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

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

**示例**：

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

**（12）Object.isExtensible()**

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

**语法**：

Object.isExtensible(obj)

**参数**：

*  `obj` 需要检测的对象

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

**示例**：

// 新对象默认是可扩展的.
    var empty = { };
    Object.isExtensible(empty); // === true
    
    // ...可以变的不可扩展.
    Object.preventExtensions(empty);
    Object.isExtensible(empty); // === false
    
    // 密封对象是不可扩展的.
    var sealed = Object.seal({ });
    Object.isExtensible(sealed); // === false
    
    // 冻结对象也是不可扩展.
    var frozen = Object.freeze({ });
    Object.isExtensible(frozen); // === false

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

**语法**：

Object.isFrozen(obj)

**参数**：

*  `obj` 被检测的对象。

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

**示例**：

// 一个对象默认是可扩展的,所以它也是非冻结的.
    Object.isFrozen({ }); // === false
    
    // 一个不可扩展的空对象同时也是一个冻结对象.
    var vacuouslyFrozen = Object.preventExtensions({ });
    Object.isFrozen(vacuouslyFrozen) //=== true;
    
    // 一个非空对象默认也是非冻结的.
    var oneProp = {  p: 42 };
    Object.isFrozen(oneProp) //=== false
    
    // 让这个对象变的不可扩展,并不意味着这个对象变成了冻结对象,
    // 因为p属性仍然是可以配置的(而且可写的).
    Object.preventExtensions(oneProp);
    Object.isFrozen(oneProp) //=== false
    
    // 此时,如果删除了这个属性,则它会成为一个冻结对象.
    delete oneProp.p;
    Object.isFrozen(oneProp) //=== true
    
    // 一个不可扩展的对象,拥有一个不可写但可配置的属性,则它仍然是非冻结的.
    var nonWritable = {  e: "plep" };
    Object.preventExtensions(nonWritable);
    Object.defineProperty(nonWritable, "e", {  writable: false }); // 变得不可写
    Object.isFrozen(nonWritable) //=== false
    
    // 把这个属性改为不可配置,会让这个对象成为冻结对象.
    Object.defineProperty(nonWritable, "e", {  configurable: false }); // 变得不可配置
    Object.isFrozen(nonWritable) //=== true
    
    // 一个不可扩展的对象,拥有一个不可配置但可写的属性,则它仍然是非冻结的.
    var nonConfigurable = {  release: "the kraken!" };
    Object.preventExtensions(nonConfigurable);
    Object.defineProperty(nonConfigurable, "release", {  configurable: false });
    Object.isFrozen(nonConfigurable) //=== false
    
    // 把这个属性改为不可写,会让这个对象成为冻结对象.
    Object.defineProperty(nonConfigurable, "release", {  writable: false });
    Object.isFrozen(nonConfigurable) //=== true
    
    // 一个不可扩展的对象,值拥有一个访问器属性,则它仍然是非冻结的.
    var accessor = {  get food() {  return "yum"; } };
    Object.preventExtensions(accessor);
    Object.isFrozen(accessor) //=== false
    
    // ...但把这个属性改为不可配置,会让这个对象成为冻结对象.
    Object.defineProperty(accessor, "food", {  configurable: false });
    Object.isFrozen(accessor) //=== true
    
    // 使用Object.freeze是冻结一个对象最方便的方法.
    var frozen = {  1: 81 };
    Object.isFrozen(frozen) //=== false
    Object.freeze(frozen);
    Object.isFrozen(frozen) //=== true
    
    // 一个冻结对象也是一个密封对象.
    Object.isSealed(frozen) //=== true
    
    // 当然,更是一个不可扩展的对象.
    Object.isExtensible(frozen) //=== false

**（14）Object.isSealed()**

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

**语法**：

Object.isSealed(obj)

**参数**：

*  `obj` 要被检查的对象。

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

**示例**：

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

**（15）Object.keys()**

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

**语法**：

Object.keys(obj)

**参数**：

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

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

**示例**：

// simple array
    var arr = ['a', 'b', 'c'];
    console.log(Object.keys(arr)); // console: ['0', '1', '2']
    
    // array like object
    var obj = {  0: 'a', 1: 'b', 2: 'c' };
    console.log(Object.keys(obj)); // console: ['0', '1', '2']
    
    // array like object with random key ordering
    var anObj = {  100: 'a', 2: 'b', 7: 'c' };
    console.log(Object.keys(anObj)); // console: ['2', '7', '100']
    
    // getFoo is a property which isn't enumerable
    var myObj = Object.create({ }, { 
      getFoo: { 
        value: function () {  return this.foo; }
      }
    });
    myObj.foo = 1;
    console.log(Object.keys(myObj)); // console: ['foo']

**（16）Object.preventExtensions()**

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

**语法**：

Object.preventExtensions(obj)

**参数**：

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

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

**示例**：

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

**（17）Object.seal()**

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

**语法**：

Object.seal(obj)

**参数**：

*  `obj` 将要被密封的对象。

**返回值**：  
被密封的对象。

**示例**：

**（18）Object.setPrototypeOf()**

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

**语法**：

Object.setPrototypeOf(obj, prototype)