JavaScript-ES6代理的实际用例

11次阅读

共计 3855 个字符，预计需要花费 10 分钟才能阅读完成。

元编程是一种强大的技术，使你能够编写可以创建其他程序的程序。ES6 借助代理和许多类似功能，使在 JavaScript 中利用元编程变得更加容易。ES6 Proxy（代理）有助于重新定义对象的基本操作，从而为各种可能性打开了大门。

本指南可以帮助您理解为什么 ES6 代理如此之好，尤其是对于元编程而言：

什么是 ES6 代理
如何以及何时实施代理
如何使用 ES6 代理执行访问控制，数据绑定和缓存
ES6 代理不是性能密集型任务的理想选择

本教程主要针对有 JavaScript 经验的开发人员，至少要熟悉 ES6 代理的概念。如果你已经对代理作为一种设计模式有了牢固的理解，那么这些知识应该可以转化为现实。

阅读本指南后，你应该能够：

了解什么是 ES6 代理，如何实现以及何时使用它
使用 ES6 代理进行访问控制，缓存和数据绑定

从根本上来说，代理是指某件事或某人成为其他事物的替代品，所以不管是什么东西，都要经过替代品才能达到真正的交易。ES6 代理的工作原理也是如此。

为了有效地实现和使用 ES6 代理，你必须了解三个关键术语：

Target——代理人所替代的真正的交易，目标是站在代理背后的东西。这可以是任何对象。
Handler——一个包含所有代理的陷阱逻辑的对象。
Trap——与操作系统中的陷阱类似，此上下文中的陷阱是以某种方式提供对对象的访问的方法（可理解为 拦截行为）。

综上所述，下面是最简单的实现，如果使用 ES6 代理，对象中不存在给定的属性，则可以返回不同的内容。

const target = {someProp: 1}

const handler = {get: function(target, key) {
    return key in target ? 
      target[key] : 
    'Doesn't exist!';
  }
}

const proxy = new Proxy(target, handler);
console.log(proxy.someProp) // 1
console.log(proxy.someOtherProp) // Doesn't exist!

ES6 代理是一项强大的功能，可促进 JavaScript 中对象的虚拟化。

由于数据绑定的复杂性，它通常很难实现。ES6 代理实现双向数据绑定的应用可以在 JavaScript 的 MVC 库中看到，在这些库中，当 DOM 发生变化时，对象会被修改。

简而言之，数据绑定是一种将多个数据源绑定在一起以使其同步的技术。

假设存在一个名为 username 的 <input>。

<input type="text" id="username" />

假设你要使此输入的值与对象的属性保持同步。

const inputState = {
  id: 'username',
  value: ''
}

当输入的值发生变化时，通过监听输入的变化事件，然后更新 inputState 的值，修改 inputState 是相当容易的。然而，反过来，在 inputState 被修改时更新输入，则相当困难。

ES6 代理可以在这种情况下提供帮助。

const input = document.querySelector('#username')
const handler = {set: function(target, key, value) {if (target.id && key === 'username') {target[key] = value;
      document.querySelector(`#${target.id}`)
        .value = value;
      return true
    }
    return false
  }
}

const proxy = new Proxy(inputState, handler)
proxy.value = 'John Doe'
console.log(proxy.value, input.value) 
// 双方都将印有“John Doe”

这样，当 inputState 更改时，input 将反映已进行的更改。结合侦听 change 事件，这将生成 input 和 inputState 的简单双向数据绑定。

虽然这是一个有效的用例，但通常不建议这样做。以后再说。

缓存是一个古老的概念，它允许非常复杂和大型的应用程序保持相对的性能。缓存是存储某些数据的过程，以便在请求时可以更快地提供数据。缓存并不永久地存储任何数据。缓存失效是保证缓存新鲜的过程。这是开发人员共同的苦恼。正如 Phil Karlton 所说：” 计算机科学中只有两件难事：缓存无效和给事物命名。”

ES6 代理使缓存更加容易。例如，如果你要检查对象中是否存在某些东西，它将首先检查缓存并返回数据，或者如果不存在则进行其他操作以获取该数据。

假设你需要进行很多 API 调用才能获取特定信息并对其进行处理。

const getScoreboad = (player) => {fetch('some-api-url')
    .then((scoreboard) => {// 用记分牌做点什么})
}

这就意味着，每当需要一个球员的记分牌时，就必须进行一次新的调用。相反，你可以在第一次请求时缓存记分牌，随后的请求可以从缓存中获取。

const cache = {'John': ['55', '99']
}
const handler = {get: function(target, player) {if(target[player] {return target[player]
  } else {fetch('some-api-url')
      .then(scoreboard => {target[player] = scoreboard
        return scoreboard
      })
    }
  }
}
const proxy = new Proxy(cache, handler)
// 访问缓存并使用记分牌做一些事情

这样，仅当缓存中不包含玩家的记分牌时，才会进行 API 调用。

最简单的用例是访问控制，ES6 代理的大部分内容都属于访问控制。

让我们探索使用 E6 代理的访问控制的一些实际应用。

ES6 代理最直观的用例之一是验证对象内部的内容，以确保对象中的数据尽可能准确。例如，如果你想强制执行产品描述的最大字符数，可以这样做。

const productDescs = {}
const handler = {set: function(target, key, value) {if(value.length > 150) {value = value.substring(0, 150)
    }
    target[key] = value
  }
}
const proxy = new Proxy(productDescs, handler)

现在，即使你添加的描述超过 150 个字符，也会被删减并添加。

有时候你可能要确保不以任何方式修改对象，并且只能将其用于读取目的。JavaScript 提供了 Object.freeze() 来执行此操作，但是使用代理时，该行为更可自定义。

const importantData = {
  name: 'John Doe',
  age: 42
}

const handler = {
  set: 'Read-Only',
  defineProperty: 'Read-Only',
  deleteProperty: 'Read-Only',
  preventExtensions: 'Read-Only',
  setPrototypeOf: 'Read-Only'
}

const proxy = new Proxy(importantData, handler)

现在，当你尝试以任何方式更改对象时，你只会收到一个字符串，表示只读。否则，你可能会引发错误以指示该对象是只读的。

JavaScript 本身并没有私有属性，除了闭包。当 Symbol 数据类型被引入时，它被用来模仿私有属性。但随着Object.getOwnPropertySymbols 方法的引入，它被抛弃了。ES6 代理并不是一个完美的解决方案，但在紧要关头它们可以完成任务。

一种常见的约定是通过在名称前加上下划线来标识私有属性，这个约定允许你使用 ES6 代理。

const object = {_privateProp: 42}

const handler = {has: function(target, key) {return !(key.startsWith('_') && key in target)
  },
  get: function(target, key, receiver) {return key in receiver ? target[key] : undefined
  }
}

const proxy = new Proxy(object, handler)
proxy._privateProp // undefined

添加 ownKeys 和 deleteProperty 会让这个实现更接近于真正的私有属性。然后，你仍然可以在开发者控制台中查看代理对象。如果你的用例与上面的实现一致，它仍然适用。

ES6 代理并不是性能密集型任务的理想选择。这就是为什么进行必要的测试是至关重要的。代理可以在任何预期对象的地方使用，代理只需几行代码就能提供复杂的功能，这使它成为元编程的理想功能。

代理通常与另一个称为 Reflect 的元编程功能一起使用。

来源：https://blog.logrocket.com，作者：Eslam Hefnawy Follow，翻译：公众号《前端全栈开发者》

本文首发于微信公众号《前端全栈开发者》，关注即送大礼包，准能为你节省不少钱！

正文完

javascript

发表至： javascript

2020-07-01

0

项目中常用js封装（持续更新）

Node-使用-Selenium-进行前端自动化操作

一步一步搭建前端监控系统接口请求异常监控篇

关于javascript:手写防抖和节流函数

基于声网的音视频SDK和FreeSWITCH开发WebRTC2SIP-Gateway-方案和思路一

JavaScript-ES6代理的实际用例

先决条件和结果

ES6 代理剖析：目标（Target），处理程序（handler）和陷阱（trap）

数据绑定：同步多个对象

缓存：提高代码性能

访问控制：控制进出对象的内容

1. 验证

2. 提供对象的只读视图

3. 私有属性

为何以及何时使用代理

站内搜索