• ES6中Object的用法


    Object.getOwnPropertyDescriptor

    一般的我们通过name属性可以获取函数名,像下面

    let demo1 ={
        say(){
            console.log("im say")
        }
    }
    console.log("第一个例子",demo1.say.name)
    

    如果对象的方法使用了取值函数(getter)和存值函数(setter)
    直接获取name获取不到

    let demo2 = {
        get foo(){},
        set foo(x){}
    
    };
    obj.foo.name
    

    会发现出现错误:Uncaught TypeError: Cannot read property 'name' of undefined

    这时候就要使用Object的这个属获取了

    let description = Object.getOwnPropertyDescriptor(demo2,'foo');
    console.log(description.get.name)
    console.log(description.set.name)
    

    输出

    get foo
    set foo
    

    Object.create

    Object.create()方法用于创建一个新对象,并把新对象的原型对象指向该方法的第一个参数。
    语法
    Object.create(prototype, [propertiesObject])
    参数

    • prototype:新创建的对象的原型对象。这个参数只能是一个对象或者是null。传入其他值会抛出TypeError。

    • propertiesObject:可选。要添加到新对象内的属性。

    返回值

    一个新创建的对象,带着指定的原型对象和属性。

    var obj1 = { a: 1 };
    var obj2 = Object.create(obj1);
    obj2.__proto__ === obj1; // true
    obj2.__proto__.__proto__ === Object.prototype; // true
    obj2.a === 1; // true,调用的是原型对象obj1的自有属性a
    

    Object.getPrototypeOf

    Object.getPrototypeOf() 方法用于获取指定对象的原型对象(也就是__protp__的指向)
    语法:Object.getPrototypeOf( obj )
    参数:obj ---> 你所指定的对象

    function Obj() {
        this.name = 'liming';
    }
    var obj = new Obj();
    console.log(Object.getPrototypeOf(obj) === obj.__proto__ ); // true  说明地址一致
    

    使用符合标准的Object.getPrototypeOf函数而不要使用非标准的__proto__属性
    另外可以使用这个方法判断,一个类是否继承了另一个类。

    Object.assign

    语法
    Object.assign(target, ...sources)
    target 目标对象。sources源对象。
    Object.assign方法用于对象的合并,将源对象(source)的所有可枚举属性,复制到目标对象(target)。
    它属于浅拷贝之拷贝了引用

    const target = { a: 1 };
    
    const source1 = { b: 2 };
    const source2 = { c: 3 };
    
    Object.assign(target, source1, source2);
    target // {a:1, b:2, c:3}
    

    Object.assign方法的第一个参数是目标对象,后面的参数都是源对象。如果键名存在则更新。
    因为采用这种方法克隆,只能克隆原始对象自身的值,不能克隆它继承的值。如果想要保持继承链,可以采用下面的代码

    // 深拷贝
    
    function clone(origin) {
      let originProto = Object.getPrototypeOf(origin);
      return Object.assign(Object.create(originProto), origin);
    }
    

    我们可以使用它为对象添加方法

     function Person(name, age) {
        this.name = name;
        this.age = age;
    }
    Object.assign(Person.prototype, {
      someMethod(arg1, arg2) {
        console.log("in someMethod")
      },
      anotherMethod() {
        console.log("in anotherMethod")
      }
    });
    let person =new Person("lisa")
    person.anotherMethod()
    // 等同于下面的写法
    Person.prototype.someMethod = function (arg1, arg2) {
      ···
    };
    Person.prototype.anotherMethod = function () {
      ···
    };
    

    Object.keys

    遍历对象的键

    var d = {"a":1,"b":2,"c":3}
    
    for (let k of Object.keys(d)){
    
    console.log(k)
    
    }
    

    Object.value

    遍历对象的值

    for (let k of Object.values(d)){
    
    console.log(k)
    
    }
    

    Object.entries

    这主要是遍历对象键值对

    for (let [k,v] of Object.entries(d)){
    
    console.log(k,v)
    
    }
    
  • 相关阅读:
    Flink中的window、watermark和ProcessFunction(三)
    ThreadLocal刨根问底
    Flink的流处理API(二)
    Flink简介(一)
    SparkStreaming
    SparkSQL
    Spark入门
    SparkCore
    【HNOI2009】 最小圈
    【BOI 2002】 双调路径
  • 原文地址:https://www.cnblogs.com/c-x-a/p/13272608.html
Copyright © 2020-2023  润新知