@aboutweb/proxyscope 中文文档教程

Question

ProxyScope

Bootstrap 将对象与 ES 代理相结合，并在其他代理工厂上重用它们。 这也将反映对原始对象所做的更改。 在使用不可变对象或混合对象时，代理也很有用。

请注意，此方法使用 代理，因此只能在现代环境中使用。 请查看 CanIUse 了解更多信息。

Install

npm i @aboutweb/proxyscope

注意此方法使用 Proxies 因此只能在现代环境中工作。 请查看 CanIUse 了解更多信息。

ProxyFactory(`…(traps || factory))

traps 为新代理

factory 合并的陷阱链 先前创建的工厂

返回具有 traps 属性的 factory 函数

factory(Object target | Array<Object target>, ...traps)

target 用作查找堆栈的对象或对象数组

traps 在创建新代理时组合

Example

import { default as proxyFactory } from "@aboutweb/proxyscope";
import otherFactory from "./otherfactory.js";

const traps = {
  has(target, property, receiver) {
    return this.findHost(property);
  },
  /*helper method*/
  findHost(property, root) {
    let host = this.stack.find(function(level) {
      return property in level;
    });

    if(host) {
      return host;
    }

    if(root === true) {
      return this.stack[0];
    }
  }
}

const factory = proxyFactory(traps, otherfactory);

export {
  factory as default,
  traps
}

ProxyScope.read

使用 target.stack 查找特性。

Example

import { read as proxyRead } from "@aboutweb/proxyscope";

let defaultConfig = {
  fu : "bar"
}

function someFn(config) {
  let proxy = proxyRead(config, defaultConfig);

  expect(proxy.fu).to.equal("bar");
  expect(proxy.bar).to.equal("baz");
}

someFn({
  bar : "baz"
});

ProxyScope.write

与 proxyRead 相同，但如果它们在级别链中的某处定义，也会转发写入。

Example

const l1 = {
  some : "value"
}

const l2 = {
  fu : "bar"
}

let proxy = proxyWrite(l1, l2);

proxy.fu = "hallo";

expect(l2.fu).to.equal("hallo");

ProxyScope.readDeep

甚至读取嵌套对象，通过为每个具有多个可能的 getter 的属性返回一个新代理来扩展代理读取

明智地使用，因为这将为每个具有多个可能值的属性查找创建一个代理。 因此，建议尽可能缓存查找。

Example

import { readDeep as proxyReadDeep } from "@aboutweb/proxyscope";

const l1 = {
  nested : {
    some : "value",
  }
}

const l2 = {
  nested : {
    fu : "bar"
  }
}

const l3 = {
  other : true
}

let proxy = proxyReadDeep(l1, l2, l3);

//before caching or update cache afterwords
l3.nested = {
  deep : true
}

//cache the returned proxy
let nested = proxy.nested;

expect(nested.some).to.equal("value");
expect(nested.fu).to.equal("bar");
expect(nested.deep).to.equal(true);

ProxyScope.writeDeep

与 proxyReadDeep 相同，但也会写入嵌套对象

Example

import { writeDeep as proxyWriteDeep } from "@aboutweb/proxyscope";

const l1 = {
  nested : {
    some : "value",
  }
}

const l2 = {
  nested : {
    fu : "bar"
  }
}

let proxy = proxyReadDeep(l1, l2);

//also use cache where possible
let nested = proxy.nested;

nested.some = "other";
nested.fu = "baz";

expect(l1.nested.some).to.equal("other");
expect(l2.nested.fu).to.equal("baz");

Licence

ISC