有一道面试题,题目要求应用Proxy
实现数据倒序访问,如:var arr=[1, 2, 3, 4]; arr[-1] 返回 4,arr[-2] 返回 3
。
这个题目很显然在考察Proxy
对象的使用方法,要了解Proxy
, 最好和Reflect
一起了解。接下来我们先学习Proxy
和Reflect
的基本使用方法,再来做这个题目。
1、Reflect
1)、Reflect 设计目的
Reflect
对象与Proxy
对象一样,都是 ES6 为了操作对象而提供的新 API。Reflect
对象的设计目的有这样几个。
(1)将Object
对象的一些明显属于语言内部的方法(比如Object.defineProperty
),放到Reflect
对象上。也就是说,从Reflect
对象上可以拿到语言内部的方法。
// Reflect 浏览器自带的对象,包含 13 个函数。
// console.log(Reflect);
let obj = {
x: 100,
y: 200,
};
// 普通调用方法
console.log(obj); // obj 的原型上面具有 get 和 set 方法
console.log(obj.x);
console.log(obj["x"]);
// Reflect 调用方法
console.log(Reflect.get(obj, "x"));
(2)修改某些Object
方法的返回结果,让其变得更合理。比如,Object.defineProperty(obj, name, desc)
在无法定义属性时,会抛出一个错误,而Reflect.defineProperty(obj, name, desc)
则会返回false
。
// 老写法
try {
Object.defineProperty(null, "name", {});
} catch (e) {
console.log(e.message);
}
// 新写法
if (Reflect.defineProperty(null, "name", {})) {
// success
} else {
console.log("error.");
}
(3)让Object
操作都变成函数行为。某些Object
操作是命令式,比如name in obj
和delete obj[name]
,而Reflect.has(obj, name)
和Reflect.deleteProperty(obj, name)
让它们变成了函数行为。
// 老写法
console.log("assign" in Object); // true
// 新写法
console.log(Reflect.has(Object, "assign")); // true
(4)Reflect
对象的方法与Proxy
对象的方法一一对应,只要是Proxy
对象的方法,就能在Reflect
对象上找到对应的方法。这就让Proxy
对象可以方便地调用对应的Reflect
方法,完成默认行为,作为修改行为的基础。也就是说,不管Proxy
怎么修改默认行为,你总可以在Reflect
上获取默认行为。
举一个例子:
const obj = {
x: 100,
y: 200,
};
const proxy = new Proxy(obj, {
set: function (obj, name, value, receiver) {
var success = Reflect.set(obj, name, value, receiver);
if (success) {
console.log(
"在 " + obj + " 上的属性 " + name + " 被设置值为:" + value
);
}
return success;
},
});
proxy.x = 1000;
上面代码中,Proxy
方法拦截target
对象的属性赋值行为。它采用Reflect.set
方法将值赋值给对象的属性,确保完成原有的行为,然后再部署额外的功能(比如这里的打印信息), 这个额外的功能又叫代理陷阱。
再举一个例子:
let obj = { x: 100, y: 200 };
let loggedObj = new Proxy(obj, {
get(target, name) {
console.log("get", target, name);
return Reflect.get(target, name);
},
deleteProperty(target, name) {
console.log("delete " + name);
return Reflect.deleteProperty(target, name);
},
has(target, name) {
console.log("has " + name);
return Reflect.has(target, name);
},
});
loggedObj.x; // get {x: 100, y: 200} x
delete loggedObj.y; // delete y
"x" in loggedObj; // has x
上面代码中,每一个Proxy
对象的拦截操作(get
、delete
、has
),内部都调用对应的Reflect
方法,保证原生行为能够正常执行。添加的工作,就是将每一个操作输出一行日志。
2)、Reflect 对象的静态方法
Reflect
对象一共有 13 个静态方法。
- Reflect.get(target, name, receiver)
Reflect.get
方法查找并返回target
对象的name
属性,如果没有该属性,则返回undefined
。
- Reflect.set(target, name, value, receiver)
Reflect.set
方法设置target
对象的name
属性等于value
。
- Reflect.has(target, name)
Reflect.has
方法对应name in obj
里面的in
运算符。
- Reflect.deleteProperty(target, name)
Reflect.deleteProperty
方法等同于delete obj[name]
,用于删除对象的属性。
- Reflect.construct(target, args)
Reflect.construct
方法等同于new target(...args)
,这提供了一种不使用new
,来调用构造函数的方法。
- Reflect.getPrototypeOf(target)
Reflect.getPrototypeOf
方法用于读取对象的__proto__
属性,对应Object.getPrototypeOf(obj)
。
- Reflect.setPrototypeOf(target, prototype)
Reflect.setPrototypeOf
方法用于设置目标对象的原型(prototype),对应Object.setPrototypeOf(obj, newProto)
方法。它返回一个布尔值,表示是否设置成功。
- Reflect.apply(target, thisArg, args)
Reflect.apply
方法等同于Function.prototype.apply.call(func, thisArg, args)
,用于绑定this
对象后执行给定函数。
- Reflect.defineProperty(target, name, desc)
Reflect.defineProperty
方法基本等同于Object.defineProperty
,用来为对象定义属性。未来,后者会被逐渐废除,请从现在开始就使用Reflect.defineProperty
代替它。
- Reflect.getOwnPropertyDescriptor(target, name)
Reflect.getOwnPropertyDescriptor
基本等同于Object.getOwnPropertyDescriptor
,用于得到指定属性的描述对象,将来会替代掉后者。
- Reflect.isExtensible(target)
Reflect.isExtensible
方法对应Object.isExtensible
,返回一个布尔值,表示当前对象是否可扩展。
- Reflect.preventExtensions(target)
Reflect.preventExtensions
对应Object.preventExtensions
方法,用于让一个对象变为不可扩展。它返回一个布尔值,表示是否操作成功。
- Reflect.ownKeys(target)
Reflect.ownKeys
方法用于返回对象的所有属性,基本等同于Object.getOwnPropertyNames
与Object.getOwnPropertySymbols
之和。
2、Proxy
Proxy 用于修改某些操作的默认行为,等同于在语言层面做出修改,所以属于一种“元编程”(meta programming),即对编程语言进行编程。
Proxy 可以理解成,在目标对象之前架设一层“拦截”,外界对该对象的访问,都必须先通过这层拦截,因此提供了一种机制,可以对外界的访问进行过滤和改写。Proxy 这个词的原意是代理,用在这里表示由它来“代理”某些操作,可以译为“代理器”。
var obj = new Proxy(
{},
{
get: function (target, propKey, receiver) {
console.log(`getting ${propKey}!`);
return Reflect.get(target, propKey, receiver);
},
set: function (target, propKey, value, receiver) {
console.log(`setting ${propKey}!`);
return Reflect.set(target, propKey, value, receiver);
},
}
);
obj.count = 1; // setting count!
++obj.count; // getting count! setting count!
上面代码对一个空对象架设了一层拦截,重定义了属性的读取(get
)和设置(set
)行为。这里暂时先不解释具体的语法,只看运行结果。对设置了拦截行为的对象obj
,去读写它的属性,就会得到下面的结果。
上面代码说明,Proxy 实际上重载(overload)了点运算符,即用自己的定义覆盖了语言的原始定义。
ES6 原生提供 Proxy 构造函数,用来生成 Proxy 实例。
var proxy = new Proxy(target, handler);
Proxy 对象的所有用法,都是上面这种形式,不同的只是handler
参数的写法。其中,new Proxy()
表示生成一个Proxy
实例,target
参数表示所要拦截的目标对象,handler
参数也是一个对象,用来定制拦截行为。
下面是另一个拦截读取属性行为的例子。
var proxy = new Proxy({}, {
get: function(target, propKey) {
return 35;
}
});
proxy.time // 35
proxy.name // 35
proxy.title // 35
上面代码中,作为构造函数,Proxy
接受两个参数。第一个参数是所要代理的目标对象(上例是一个空对象),即如果没有Proxy
的介入,操作原来要访问的就是这个对象;第二个参数是一个配置对象,对于每一个被代理的操作,需要提供一个对应的处理函数,该函数将拦截对应的操作。比如,上面代码中,配置对象有一个get
方法,用来拦截对目标对象属性的访问请求。get
方法的两个参数分别是目标对象和所要访问的属性。可以看到,由于拦截函数总是返回35
,所以访问任何属性都得到35
。
注意:
要使得Proxy
起作用,必须针对Proxy
实例(上例是proxy
对象)进行操作,而不是针对目标对象(上例是空对象)进行操作。
如果handler
没有设置任何拦截,那就等同于直接通向原对象。
var target = {};
var handler = {};
var proxy = new Proxy(target, handler);
proxy.a = 'b';
target.a // "b"
上面代码中,handler
是一个空对象,没有任何拦截效果,访问proxy
就等同于访问target
。
一个技巧是将 Proxy 对象,设置到object.proxy
属性,从而可以在object
对象上调用。
var obj = {};
var handler = {
get: (target, propKey, receiver) => {
return Reflect.get(target, propKey, receiver);
},
set: (target, propKey, value, receiver) => {
return Reflect.set(target, propKey, value, receiver);
},
};
var object = { proxy: new Proxy(obj, handler) };
object.proxy.x = 100;
console.log(object.proxy.x);
Proxy 实例也可以作为其他对象的原型对象。
var proxy = new Proxy(
{},
{
get: function (target, propKey) {
return 35;
},
}
);
let obj = Object.create(proxy);
console.log(obj.time); // 35
上面代码中,proxy
对象是obj
对象的原型,obj
对象本身并没有time
属性,所以根据原型链,会在proxy
对象上读取该属性,导致被拦截。
同一个拦截器函数,可以设置拦截多个操作。
var handler = {
get: function(target, name) {
if (name === 'prototype') {
return Object.prototype;
}
return 'Hello, ' + name;
},
apply: function(target, thisBinding, args) {
return args[0];
},
construct: function(target, args) {
return {value: args[1]};
}
};
var fproxy = new Proxy(function(x, y) {
return x + y;
}, handler);
fproxy(1, 2) // 1
new fproxy(1, 2) // {value: 2}
fproxy.prototype === Object.prototype // true
fproxy.foo === "Hello, foo" // true
对于可以设置、但没有设置拦截的操作,则直接落在目标对象上,按照原先的方式产生结果。
下面是 Proxy 支持的拦截操作一览,一共 13 种。
- get(target, propKey, receiver):拦截对象属性的读取,比如
proxy.foo
和proxy['foo']
。 - set(target, propKey, value, receiver):拦截对象属性的设置,比如
proxy.foo = v
或proxy['foo'] = v
,返回一个布尔值。 - has(target, propKey):拦截
propKey in proxy
的操作,返回一个布尔值。 - deleteProperty(target, propKey):拦截
delete proxy[propKey]
的操作,返回一个布尔值。 - ownKeys(target):拦截
Object.getOwnPropertyNames(proxy)
、Object.getOwnPropertySymbols(proxy)
、Object.keys(proxy)
、for...in
循环,返回一个数组。该方法返回目标对象所有自身的属性的属性名,而Object.keys()
的返回结果仅包括目标对象自身的可遍历属性。 - getOwnPropertyDescriptor(target, propKey):拦截
Object.getOwnPropertyDescriptor(proxy, propKey)
,返回属性的描述对象。 - defineProperty(target, propKey, propDesc):拦截
Object.defineProperty(proxy, propKey, propDesc)
、Object.defineProperties(proxy, propDescs)
,返回一个布尔值。 - preventExtensions(target):拦截
Object.preventExtensions(proxy)
,返回一个布尔值。 - getPrototypeOf(target):拦截
Object.getPrototypeOf(proxy)
,返回一个对象。 - isExtensible(target):拦截
Object.isExtensible(proxy)
,返回一个布尔值。 - setPrototypeOf(target, proto):拦截
Object.setPrototypeOf(proxy, proto)
,返回一个布尔值。如果目标对象是函数,那么还有两种额外操作可以拦截。 - apply(target, object, args):拦截 Proxy 实例作为函数调用的操作,比如
proxy(...args)
、proxy.call(object, ...args)
、proxy.apply(...)
。 - construct(target, args):拦截 Proxy 实例作为构造函数调用的操作,比如
new proxy(...args)
。
3、应用 Reflect 和 Proxy 实现观察者模式
const queuedObservers = new Set();
const observe = (fn) => queuedObservers.add(fn);
const observable = (obj) => new Proxy(obj, { set });
function set(target, key, value, receiver) {
const result = Reflect.set(target, key, value, receiver);
queuedObservers.forEach((observer) => observer());
return result;
}
const person = observable({
name: "张三",
age: 20,
});
function print() {
console.log(`${person.name}, ${person.age}`);
}
observe(print);
person.name = "李四";
// 输出
// 李四, 20
4、解面试题
应用 Proxy
实现数据倒序访问,如: var arr=[1, 2, 3, 4]; arr[-1] 返回 4,arr[-2] 返回 3
。具体实现代码:
var arr = [1, 2, 3, 4];
var proxy = new Proxy(arr, {
get(target, propKey, receiver) {
let nPropKey = parseInt(propKey);
if (nPropKey < 0) {
if (Math.abs(nPropKey) <= target.length) {
return target[target.length + nPropKey];
} else {
return "访问越界";
}
}
return Reflect.get(target, propKey, receiver);
},
});
console.log(proxy[-1]); // 4
console.log(proxy[-2]); // 3
console.log(proxy[-100]); // 访问越界
console.log(proxy[0]); // 1
上面代码中,get
函数里实现了数组访问的拦截,对小于0且非越界的倒序访问做了特殊处理。
-THE END-