Reflect

概述

 Reflect 对象是 ES6 为了操作对象而提供的新 API。

基本使用

const user = {}

const status = Reflect.set(user, 'name', 'xiaoming')

console.log(user.name, status) // xiaoming, true

静态方法

 Reflect 对象一共有 13 个静态方法。

• Reflect.apply(target, thisArg, args)
• Reflect.construct(target, args)
• Reflect.get(target, name, receiver)
• Reflect.set(target, name, value, receiver)
• Reflect.defineProperty(target, name, desc)
• Reflect.deleteProperty(target, name)
• Reflect.has(target, name)
• Reflect.ownKeys(target)
• Reflect.isExtensible(target)
• Reflect.preventExtensions(target)
• Reflect.getOwnPropertyDescriptor(target, name)
• Reflect.getPrototypeOf(target)
• Reflect.setPrototypeOf(target, prototype)

上面这些方法的作用，大部分与 object 对象的同名方法的作用都是相同的，而且它与 Proxy 对象的方法是一一对应的。下面是对它们的解释。

Reflect.apply()

        let arr = [10, 30, 60, 200, 700];
        // let max = Math.max(...arr);
        // let max = Math.max.apply(Math,arr);
        // console.log(max);
        // let min = Math.min.apply(Math,arr);
        // console.log(min);

        // 1 apply` 
        // let m = Reflect.apply(Math.max, Math, arr);
        // let m = Reflect.apply(Math.min, Math, arr);
        // console.log(m);

Reflect.construct()

        class Man {
            constructor(name, age) {
                this.name = name;
                this.age = age;
            }
            say() {
                console.log('wc');
            }
        }
        // let m = new Man('徐嘎', 28);
        let m = Reflect.construct(Man, ['徐嘎', 28])

Reflect.get()   Reflect.set()

        class Man {
            constructor(name, age) {
                this.name = name;
                this.age = age;
            }
            say() {
                console.log('wc');
            }
        }
        // let m = new Man('徐狗', 28);
        let m = Reflect.construct(Man, ['徐狗', 28])
        Reflect.set(m, 'name', '嘎子');
        console.log(m);
        let age = Reflect.get(m, 'age');
        console.log(age);

Reflect.defineProperty()

// 旧写法
Object.defineProperty(MyDate, 'now', {
  value: () => Date.now()
});

// 新写法
Reflect.defineProperty(MyDate, 'now', {
  value: () => Date.now()
});

Reflect.deleteProperty()

        class Man {
            constructor(name, age) {
                this.name = name;
                this.age = age;
            }
            say() {
                console.log('wc');
            }
        }

        // let rst = Reflect.has(m,'say');//true
        let rst = Reflect.has(m, 'run');//false
        console.log(rst);

Reflect.has()

        class Man {
            constructor(name, age) {
                this.name = name;
                this.age = age;
            }
            say() {
                console.log('wc');
            }
        }
        // let rst = Reflect.has(m,'say');//true
        let rst = Reflect.has(m, 'run');//false
        console.log(rst);

Reflect.ownKeys()

        class Man {
            constructor(name, age) {
                this.name = name;
                this.age = age;
            }
            say() {
                console.log('wc');
            }
        }
        // let m = new Man('徐狗', 28);
        let m = Reflect.construct(Man, ['徐狗', 28])
        let keys = Reflect.ownKeys(m);
        console.log(keys);

Reflect.isExtensible()

/*
    Reflect.isExtensible方法对应Object.isExtensible，
    返回一个布尔值，表示当前对象是否可扩展。
*/

let myObject = {};

// 旧写法
Object.isExtensible(myObject) // true

// 新写法
Reflect.isExtensible(myObject) // true

Reflect.preventExtensions()

/*
    Reflect.preventExtensions对应Object.preventExtensions方法，
    用于让一个对象变为不可扩展。它返回一个布尔值，表示是否操作成功。
*/
let myObject = {};

// 旧写法
Object.preventExtensions(myObject) // Object {}

// 新写法
Reflect.preventExtensions(myObject) // true

Reflect.getOwnPropertyDescriptor()

/*
    Reflect.getOwnPropertyDescriptor基本等同于Object.getOwnPropertyDescriptor，
    用于得到指定属性的描述对象，将来会替代掉后者。
*/
let myObject = {};
Object.defineProperty(myObject, 'hidden', {
  value: true,
  enumerable: false,
});

// 旧写法
let theDescriptor = Object.getOwnPropertyDescriptor(myObject, 'hidden');

// 新写法
let theDescriptor = Reflect.getOwnPropertyDescriptor(myObject, 'hidden');

Reflect.getPrototypeOf()

/*
    Reflect.getPrototypeOf方法用于读取对象的__proto__属性，
    对应Object.getPrototypeOf(obj)。
*/
let myObj = new FancyThing();

// 旧写法
Object.getPrototypeOf(myObj) === FancyThing.prototype;

// 新写法
Reflect.getPrototypeOf(myObj) === FancyThing.prototype;

Reflect.setPrototypeOf()

/*
    Reflect.setPrototypeOf方法用于设置目标对象的原型（prototype），
    对应Object.setPrototypeOf(obj, newProto)方法。它返回一个布尔值，表示是否设置成功。
*/
let myObj = {};

// 旧写法
Object.setPrototypeOf(myObj, Array.prototype);

// 新写法
Reflect.setPrototypeOf(myObj, Array.prototype);

myObj.length // 0