x-note
Search…
ECMAScript 6 Reflect
Reflect是一个内置的对象,提供拦截 JavaScript 操作的方法。这些方法与处理器对象(handler)的方法相同。
Reflect不是一个函数对象,不可对其使用new操作符
ES6 推出Reflect的主要目的是,将一些明显属于语言范畴的方法,转移到Reflect对象上,例如:Object.definePropertyFunction.prototype.apply(),未来类似的功能也将只在Reflect对象上实现。其次,Reflect的方法返回值是一个布尔值,对于对象的操作更加合理,不需要使用try...catch进行捕获。此外,是某些命令式的操作,转为函数式的行为,比如:delete obj[prop]使用Reflect.deleteProperty(obj, prop)替代。
由于总能在Reflect对象上找到Proxy支持的拦截方法,Proxy可以通过调用Reflect对应的方法作为修改行为的基础,ProxyReflect的结合使得对对象的操作更加的便捷。
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!