理解ReAct的核心思想-CFANZ编程社区

1，object.assign()

用于合并对象的属性。它可以将一个或多个源对象的属性复制到目标对象中，实现属性的合并。

语法 Object.assign(target, ...sources);

1,target：目标对象，将属性复制到该对象中。

2,sources：一个或多个源对象，它们的属性将被复制到目标对象中。

    const target = { a: 1, b: 2 };
    const source = { b: 4, c: 5 };

    const returnedTarget = Object.assign(target, source);

    console.log(target);
    console.log(returnedTarget)
    console.log(returnedTarget === target);//true

如果存在相同属性名，则后面的源对象将覆盖前面的源对象。

2，`Object.create()`

以一个现有对象作为原型，创建一个新对象。

语法

Object.create(proto)
Object.create(proto, propertiesObject)

1，proto 新创建对象的原型对象

2，propertiesObject(可选参数) 如果该参数被指定且不为 undefined，则该传入对象可枚举的自有属性将为新创建的对象添加具有对应属性名称的属性描述符。这些属性对应于 Object.defineProperties() 的第二个参数。

    //用法一
    const person = {
        isHuman: false,
        printIntroduction: function () {
            console.log(`My name is ${this.name}. Am I human? ${this.isHuman}`);
        },
    };

    const me = Object.create(person);

    me.name = 'Matthew'; // “name”是在“me”上设置的属性，但不在“person”上设置
    me.isHuman = true; // 可以覆盖继承的属性

    me.printIntroduction();
    //最终输出  My name is Matthew. Am I human? true
    
    //用法二
    let person={
       name:"李四",
       age:30,
       fun:function () {
            console.log(this.age)
       }
   }
   let newObj=Object.create(person,{
       name:{
           value:"来财"
       },
       color:{
           value:'456'
       }
   })
    console.log(newObj.name)//来财
    console.log(newObj.color)//456
    console.log(newObj.age)//30
    newObj.fun()

3，`Object.defineProperty()`

在一个对象上定义一个新属性，或修改其现有属性，并返回此对象。

语法：Object.defineProperty(obj, prop, descriptor)

1，obj属性所在的对象

2，prop属性所在的名字

3，descriptor描述符对象

    const o = {}; // 创建一个新对象

    // 通过 defineProperty 使用数据描述符添加对象属性的示例
    Object.defineProperty(o, "a", {
        value: 37,//包含这个属性的数据值
        writable: true,//表示能否修改属性的值
        enumerable: true,//表示能否通过for-in循环返回属性
        configurable: true,//是否能通过delete删除属性从而重新定义属性
    });
    console.log(o.a)
    // 'a' 属性存在于对象 o 中，其值为 37

4，`Object.entries()`

方法返回一个数组，包含给定对象自有的可枚举字符串键属性的键值对。

语法：Object.entries(obj) obj参数是一个对象

    let obj={
        name:"张三",
        age:28,
        weight:140
    }
    for (const [key, value] of Object.entries(obj)) {
        console.log(`${key}: ${value}`);
    }
    console.log(Object.entries(obj))

返回值：一个由给定对象自有的可枚举字符串键属性的键值对组成的数组。每个键值对都是一个包含两个元素的数组：第一个元素是属性的键（始终是字符串），第二个元素是属性值。

5，`Object.values()`

返回一个给定对象的自有可枚举字符串键属性值组成的数组

语法：Object.values(obj) obj为一个对象

    let person={
       name:"张三",
       age:28,
       weight:180
   }
   console.log(Object.values(person))
    //结果为一个数组['张三',28,180]

返回值是一个包含了给定对象的自有可枚举字符串键属性值的数组。

6，`Object.keys()`

返回一个由给定对象自身的可枚举的字符串键属性名组成的数组

语法：Object.keys(obj) obj为一个对象

    let person={
       name:"张三",
       age:28,
       weight:180
   }
   console.log(Object.keys(person))
    //结果为一个数组['name','age','weight']

返回值一个由给定对象自身可枚举的字符串键属性键组成的数组。

7，`Object.is()`

确定两个值是否为相同值

语法：Object.is(value1, value2)

1，value1要比较的第一个值

2，value2要比较的第二个值

Object.is(25, 25); // true
Object.is("foo", "foo"); // true
Object.is("foo", "bar"); // false
Object.is(null, null); // true
Object.is(undefined, undefined); // true

返回值为一个布尔值

8，Object.freeze()

Object.freeze() 静态方法可以使一个对象被冻结。冻结对象可以防止扩展，并使现有的属性不可写入和不可配置。被冻结的对象不能再被更改：不能添加新的属性，不能移除现有的属性，不能更改它们的可枚举性、可配置性、可写性或值，对象的原型也不能被重新指定。

语法：Object.freeze(obj) obj为要冻结的对象

<script>
    "use strict"
    let obj={
        name:"张三",
        age:28,
        weight:140
    }
    Object.freeze(obj)
    //obj.name='李四'
    delete obj.name
    console.log(obj)
</script>

在严格模式下，修改属性或删除都会有错误提示

9，`Object.getOwnPropertyDescriptor()`

可以取得给定属性的描述符。

语法:Object.getOwnPropertyDescriptor(obj, prop)

1，obj 属性所在的对象

2，prop要读取的属性描述符名称

   let book={}
   Object.defineProperties(book,{
       _year:{
           value:100
       },
       _editor:{
           value:200
       },
       year:{
           get:function(){
               return this._year
           },
           set:function (newValue) {
                if(newValue>50){
                    this._year=newValue
                    this._editor+=newValue-10
                }
           }
       }
   })
    let description1 = Object.getOwnPropertyDescriptor(book,"_year")
    console.log(description1.get)//undefined
    console.log(description1.value)//100
    console.log(description1.configurable)//false
    console.log(description1.enumerable)//false
    console.log(description1.writable)//false
    let description2 = Object.getOwnPropertyDescriptor(book,"_editor")
    console.log(description2.value)//200
    console.log(description2.configurable)//false

返回值是一个对象，如果是访问器属性，这个对象的属性有configurable,enumerable,get,set；如果是数据属性，这个对象的属性有configurable,enumerable,writable和value。

10，`Object.getOwnPropertyDescriptors()`

返回给定对象的所有自有属性描述符。

语法：Object.getOwnPropertyDescriptors(obj) obj获取其所有自有属性描述符的对象

    let person={
       name:"张三",
       age:28,
       weight:180
   }
   let des1=Object.getOwnPropertyDescriptors(person)
    console.log(des1.name.configurable)//true
    console.log(des1.name.writable)//true
    console.log(des1.name.value)//张三

返回值是一个包含给定对象的所有自有属性描述符的对象。包含configurable，weitable，value，enumerable，get和set。

11，`Object.getPrototypeOf()`

返回指定对象的原型（即内部 [[Prototype]] 属性的值）。

语法：Object.getPrototypeOf(obj) obj为返回原型的对象

    const proto = {};
    const obj = Object.create(proto);
    console.log( Object.getPrototypeOf(obj) === proto); // true

返回值为给定对象的原型

12，`Object.setPrototypeOf()`

可以将一个指定对象的原型（即内部的 [[Prototype]] 属性）设置为另一个对象或者 null。

语法：Object.setPrototypeOf(obj, prototype)

1，obj要设置其原型的对象

2，prototype该对象的新原型（一个对象或 null）。

    let person={
       name:"李四"
   }
   let animal={
       types:"小狗",
       fun:function(){
           console.log("这里被调用了")
       }
   }
   Object.setPrototypeOf(person,animal)
    console.log(person.types)//输出小狗
    person.fun()

返回值是一个指定的对象。

还有很多使用频率不高的方法，Object.isFrozen(),Object.isSealed(),Object.fromEntries()等等...