ECMAScript 6 Reflect

Search…
Reflect是一个内置的对象，提供拦截 JavaScript 操作的方法。这些方法与处理器对象（handler）的方法相同。
Reflect不是一个函数对象，不可对其使用new操作符
ES6 推出Reflect的主要目的是，将一些明显属于语言范畴的方法，转移到Reflect对象上，例如：Object.defineProperty、Function.prototype.apply()，未来类似的功能也将只在Reflect对象上实现。其次，Reflect的方法返回值是一个布尔值，对于对象的操作更加合理，不需要使用try...catch进行捕获。此外，是某些命令式的操作，转为函数式的行为，比如：delete obj[prop]使用Reflect.deleteProperty(obj, prop)替代。
由于总能在Reflect对象上找到Proxy支持的拦截方法，Proxy可以通过调用Reflect对应的方法作为修改行为的基础，Proxy和Reflect的结合使得对对象的操作更加的便捷。
1
const proxy = new Proxy({}, {
2
    get(...args) {
3
        const rest = Reflect.get(...args);
4
        if (rest) {
5
            console.log('get property success');
6
        } else {
7
            console.log('get property failed');
8
        }
9
        return rest;
10
    }
11
});
12
​
13
Reflect.get(proxy, 'a'); // get property failed
14
​
15
Reflect.set(proxy, 'a', 1);
16
Reflect.get(proxy, 'a'); //get property success
Copied!
相关API
Reflect.apply(target, context, args)
对一个函数进行调用操作，同时可以传入一个数组作为调用参数.
1
Reflect.apply(Array.prototype.slice, [1, 2, 3], [0, 2]); // [1, 2]
Copied!
Reflect.construct(target, args[, newTarget])
对构造函数进行new操作.
newTarget 参考 new.target
1
const arrNum = Reflect.construct(Array, [], Number);
2
​
3
Array.isArray(arrNum); // true
4
Refelect.getPrototypeOf(arrNum) === Number.prototype; // true
Copied!
Reflect.defineProperty(target, prop, descriptor)
定义对象属性，与Object.defineProperty()类似
1
const obj = {};
2
const rest = Reflect.defineProperty(obj, 'a', { value: 1 }); // true
3
console.log(rest, obj.a); // true 1
4
​
5
Reflect.preventExtensions(obj);
6
const rest2 = Reflect.defineProperty(obj, 'b', { value: 1 }); // true
7
console.log(rest2, obj.b); // false undefined
Copied!
Reflect.deleteProperty(target, propKey)
删除目标对象的属性，delete操作符的函数级操作
1
const obj = { a: 1 };
2
Reflect.defineProperty(obj, 'b', {
3
    configurable: false,
4
    value: 2 
5
});
6
const rest1 = Reflect.deleteProperty(obj, 'a');
7
const rest2 = Reflect.deleteProperty(obj, 'b');
8
​
9
console.log(rest1, obj.a); // true undefined
10
console.log(rest2, obj.b); // false 2
Copied!
Reflect.get(target, propKey[, receiver])
获取对象身上某个属性的值
1
const obj = {
2
    a: 1,
3
    [Symbol.for('b')]: 2,
4
    get c() {
5
        return 3;
6
    }
7
};
8
​
9
Reflect.get(obj, 'a'); // 1
10
Reflect.get(obj, Symbol.for('b')); // 2
11
Reflect.get(obj, 'c'); // 3
12
​
13
​
14
Reflect.get([1, 2], 1); // 2
15
​
16
function fn () { }
17
fn.prototype.z = 'parent';
18
Reflect.get(new fn(), 'z'); // parent
Copied!
Reflect.getOwnPropertyDescriptor(target, propKey)
获取对象属性描述器。
1
const obj = { a: 1 };
2
Reflect.defineProperty(obj, 'b', {
3
    configurable: false,
4
    value: 2 
5
});
6
​
7
Reflect.getOwnPropertyDescriptor(obj, 'a'); // {value: 1, writable: true, enumerable: true, configurable: true}
8
Reflect.getOwnPropertyDescriptor(obj, 'b'); // {value: 2, writable: false, enumerable: false, configurable: false}
Copied!
Reflect.getPrototypeOf(target)
获取对象原型
1
class A {}
2
const obj = new A();
3
Reflect.getPrototypeOf(obj) === A.prototype;
4
​
5
function fn () { }
6
const obj2 = new fn();
7
Reflect.getPrototypeOf(obj2) === fn.prototype; // true
Copied!
Reflect.has(target, propKey)
检查对象是否存在某个属性
1
const obj = {
2
    a: 1,
3
    [Symbol.for('b')]: 2,
4
    get c() {
5
        return 3;
6
    }
7
};
8
​
9
Reflect.has(obj, 'a'); // true
10
Reflect.has(obj, Symbol.for('b')); // true
11
Reflect.has(obj, 'c'); // true
12
Reflect.has(obj, 'd'); // false
Copied!
Reflect.isExtensible(target)
检查对象是否可扩展
1
const obj = {};
2
​
3
Reflect.isExtensible(obj); // true
4
Reflect.preventExtensions(obj);
5
Reflect.isExtensible(obj); // false
Copied!
Reflect.ownKeys(target)
返回一个包含所有自身属性（不包含继承属性）的数组
1
const obj1 = {
2
    a: 1,
3
    [Symbol.for('b')]: 2,
4
    get c() {
5
        return 3;
6
    }
7
};
8
Reflect.ownKeys(obj1); // ["a", "c", Symbol(b)]
9
​
10
function fn () {
11
    this.x = 1
12
}
13
fn.prototype.z = 'z';
14
const obj2 = new fn();
15
Reflect.ownKeys(obj2); // ["x"]
Copied!
Reflect.preventExtensions(target)
将对象标记为不再可扩展
1
const obj = {};
2
obj.a = 1;
3
Reflect.preventExtensions(obj); // true
4
obj.b = 1;
5
​
6
console.log(obj); // { a: 1 }
Copied!
Reflect.set(target, propKey, val[, receiver])
给目标对象分配属性的值
1
const obj = {};
2
Reflect.set(obj, 'a', 1); // true
3
​
4
Reflect.defineProperty(obj, 'a', { 
5
    writeable: false,
6
}); // true
7
Reflect.set(obj, 'a', 2); // false
8
​
9
Reflect.preventExtensions(obj); // true
10
Reflect.set(obj, 'b', 1); // false
Copied!
Reflect.setPrototypeOf(target, prototype)
修改对象的原型
1
function fn () {}
2
const obj = new fn();
3
​
4
Reflect.getPrototypeOf(obj) === fn.prototype; // true
5
​
6
Reflect.setPrototypeOf(obj, Array.prototype); // true
7
Reflect.getPrototypeOf(obj) === Array.prototype; // true
8
​
9
Reflect.preventExtensions(obj); // true
10
Reflect.setPrototypeOf(obj, Number.prototype); // true
Copied!
ECMAScript 6 Proxy
ECMAScript 6 new.target
Last modified 4yr ago
Copy link
Contents