小编use*_*170的帖子

为什么Object.getPrototypeOf(Object) === Object.getPrototypeOf(Function)在 JavaScript\xef\xbc\x9f 中

这样设计的目的是什么\xef\xbc\x9f

我有一个Proxy模仿虚拟物体的方法。该代理的 Getter 返回准备好的值。

我发现，如果等待代理，它会导致调用我的代理的“then”属性：

await myProxy

在这种情况下我的代理 getter 应该返回什么？返回代理本身或对自身的承诺是一个好主意吗？

例子在这里：

https://jsfiddle.net/rv55Lpu1

让我感到困惑的是，如果我是await一个对象，我会得到该对象，但如果我是awaita Proxy，它需要有一个返回自身的“then”属性陷阱。

我正在尝试Object.setPrototypeOf重新设置已转换为 JSON 并返回对象的对象的原型。然而，instanceof似乎并没有按照我预期的方式工作：

class Foo {}

const obj = {};
Object.setPrototypeOf(obj, Foo);
console.log(obj instanceof Foo);

为什么会这样呢？据我所知，instanceof工作基于将给定对象的原型与引用的类进行比较。应该有不同的方法吗？

为什么要撤销代理？您能提供一个实际应用吗Proxy.revocable()？

根据MDN Proxy.revocable() 文档，我了解它允许垃圾收集。但是，如果你刚刚删除了 Proxy 对象，不是也允许垃圾回收吗？

附录：如果这个问题有问题，请告诉我它是什么，我很乐意改写或添加其他信息。

@艾米：

我认为这似乎是一个不必要的内置功能，因为我可以像这样创建一个可撤销代理：

function createRevocable(o,handlers){
	var revoked = false
	var handlerWrapper = {
		get(...args){
			if(revoked){
				throw Error('Sorry, this object went poof.')
			}
			if(typeof handlers.get == 'function'){
				return handlers.get(...args)
			}else{
				return Reflect.get(...args)
			}
		}
	}
	var p = new Proxy(o,Object.assign({},handlers,handlerWrapper))
	var r = function(){
		revoked = true
	}
	return {r,p}
}

var a = createRevocable({a:1},{})
var prox = a.p
var revoke = a.r
console.log(prox.a) //1
revoke()
console.log(prox.a)

然而，垃圾收集似乎确实是问题所在，因为我可以撤销对该对象的访问，但无法删除 Proxy 对象内对其的内部引用。除非...

function …

我有一个函数将 CS:GO 十字线代码解码为键值对象。

（之前我问过如何解码CS:GO的分享代码的问题在这里）

如何从解码这些值反转为将它们编码为由字母数字字符组成的“共享代码”？

函数解码分享代码：

const BigNumber = require("bignumber.js");

// Intentionally no 0 and 1 number in DICTIONARY
const DICTIONARY = "ABCDEFGHJKLMNOPQRSTUVWXYZabcdefhijkmnopqrstuvwxyz23456789";
const DICTIONARY_LENGTH = DICTIONARY.length;
const SHARECODE_PATTERN = /CSGO(-?[\w]{5}){5}$/;

const bigNumberToByteArray = big => {
  const str = big.toString(16).padStart(36, "0");
  const bytes = [];

  for (let i = 0; i < str.length; i += 2) {
    bytes.push(parseInt(str.slice(i, i + 2), 16));
  }

  return bytes;
}

const parseBytes = bytes => {
  return {
    cl_crosshairgap: Int8Array.of(bytes[2])[0] / …

请参阅 Mozilla 文档中有关Proxy()的内容

一个简单的代理示例：

const handler = {
  get: function(target, prop, receiver) {
    return Reflect.get(target, prop, receiver);
  },
  set: function(target, prop, receiver) {
    return Reflect.set(target, prop, receiver);
  }
};

const proxy = new Proxy(target, handler);

get我在and中有一些异步函数set，所以我想让get和setto 成为async函数。

我期望类似的东西：

const handler = {
  get: async function(target, prop, receiver) {
    await foo();
    return Reflect.get(target, prop, receiver);
  },
  set: async function(target, prop, receiver) {
    await bar();
    return Reflect.set(target, prop, receiver);
  }
};

const …

我有一些从网络服务器获取的对象。对象的某些属性需要额外的异步解析，但出于性能原因我想延迟执行此操作。我试图使用代理来拦截访问，然后在访问时解析属性。我的处理程序看起来像这样

class MyClass {
   type() {
      return "my new class";
   }
}

let myObject = new MyClass();

let proxy = new Proxy(myObject, {
  get: async(target, prop, receiver) => {
    if (prop === "attribute") {
      let newProp = prop + "_parsed";
      if (!(newProp in target)) {
        return await (new Promise((resolve, reject) => { resolve("parsed value") }));
      }
      else {
        return target[newProp];
      }
    }
    else {
      return Reflect.get(target, prop, receiver);
    }
  },
});

console.log(proxy.attribute);  // "parsed value"
console.log(proxy.type()); // "my new class" …

我为 InnerStruct 编写了一个漂亮的打印机，它将数组显示为 2 个元素和正确的值。我还为TestStruct2开了个玩笑，但是我不知道如何使TestStruct包含与InnerStruct相同的内容。我不知道如何从 gdb/python 访问 array.nestedVariables。我如何编写这个以便 TestStruct 给出与 InnerStruct 相同的结果？

来源

struct InnerStruct
{
    int buffer[100];
    int len;
};
struct TestStruct
{
    InnerStruct array;
};
struct TestStruct2
{
    InnerStruct array;
};

int main() {
    TestStruct s;
    s.array.buffer[0] = 5;
    s.array.buffer[1] = 8;
    s.array.len=2;
    TestStruct2 s2;
    s2.array.buffer[0] = 5;
    s2.array.buffer[1] = 8;
    s2.array.len=2;
    return 0;
}

.gdbinit

python

pp = gdb.printing.RegexpCollectionPrettyPrinter("pp")

class InnerStructPrinter:
    "Print a InnerStruct"

    class _iterator:
        def __init__ (self, start, finish):
            self.item = start
            self.finish = finish …

为了研究 JavaScript GC 的复杂性，我深入研究了其中的内容（即 ECMAScript 规范）。我发现，只要一个物体被认为是“活的”，就不应该被收集。活性本身定义如下：

在评估期间的任何时刻，如果满足以下任一条件，则将一组对象S视为 活动对象：

• S中的任何元素都包含在任何代理的[[KeptAlive]]列表中。
• 存在一个关于S的有效的未来假设 WeakRef-oblivious 执行，它观察S中任何对象的 Object 值。