从 javascript 对象中提取 Transferable 列表？

Question

Worker 接口的 postMessage() 方法允许传递

transferList

，它是应该传递其引用的对象数组（而不是被复制的对象）。

myWorker.postMessage(aMessage, transferList);

是否有一种安全的方法来递归提取所有可以传递引用的对象（根据API，只有MessagePort和ArrayBuffer），这样我们就不必担心手动传递所有对象？

myWorker.postMessage(aMessage, extractTransferList(aMessage));

是否建议实施此行为？

示例：

当我们考虑以下代码时：

var objData =
{
    str: "string",
    i8: new Int8Array(200),
    obj : {
       num : 8,
       ab: new ArrayBuffer(100)
    }  
};
objWorker.postMessage(objData, [objData.i8.buffer, objData.obj.ab]);

我们需要在第二个参数中指定对象的所有字段，这些字段应该传递其引用。我的问题是关于构建一个为我们完成工作的函数，以确保我们不会忘记这里的一些可转移对象（这可能会在我们不知情的情况下影响性能）。

objWorker.postMessage(objData, extractTransferList(objData));

Answer 1

我的问题是关于构建一个为我们完成工作的函数，以确保我们不会忘记这里的一些可转移对象（这可能会在我们不知情的情况下影响性能）。

您可以实现一个函数，该函数通过对象图递归查找可传输对象并构建它们的数组，例如：

// *Sketch*, not debugged code!!
function getTransferrables(obj, array) {
    var key, value;
    if (!array) {
        array = [];
    }
    for (key in obj) {
        // (Add a hasOwnProperty check here if you want one)
        value = obj[key];
        if (value !== null) {
            if (typeof value === "object") {
                if (isTransferrable(value)) {
                    array.push(value);
                } else { // I *think* you want an else here, or should we recurse into transferrables?
                    getTransferrables(value, array);
                }
            }
        }
    }
    return array;
}
var toString = Object.prototype.toString;
function isTransferrable(obj) {
    switch (toString.call(obj)) {
        case "[object MessagePort]": // I checked these on Chrome and Firefox,
        case "[object Int8Array]":   // you'll want to verify on your target
        case "[object Int16Array]":  // browsers!
        // ...etc...
            return true;
        default:
            return false;
    }
}

然后你可以像这样使用

getTransferrables

：

foo.postMessage(obj, getTransferrables(obj));

如果您发现

toString

中的

isTransferrable

技巧在跨浏览器上不可靠，您可以使用对象的

constructor

属性，例如：

var ctor = obj.constructor;
return ctor === MessagePort ||
       ctor === Int8Array ||
       ctor === Int16Array ||
       // ...
       ;

您必须检查哪一个（如果有的话）更可靠，甚至可能必须将两者混合以获得良好的跨浏览器覆盖率。

您会注意到我没有在

instanceof

中使用

isTransferrable

，这看起来很有用。问题是类型化数组在 ES2015 中是可子类：

class MyNiftyArray extends Int32Array {
    // ...
}

当你这样做时，

MyNiftyArray

的实例是

instanceof

基类：

let a = new MyNiftyArray();
console.log(a instanceof Int32Array); // true

...但我们不知道子类实例实际上是可传递的。

但是，如果您只在自己的代码中使用这些东西，并且您知道您永远不会子类化可转移类型，那么您确实可以使用

instanceof

。

// Relies on knowing that `obj` is not an instance of a subclass of a
// tranferrable
function isTransferrable(obj) {
    return obj instanceof MessagePort ||
           obj instanceof Int8Array ||
           obj instanceof Int16Array ||
           // ...
           ;
}

Answer 2

这是查找每个 ArrayBuffer 的一种方法。它可以轻松扩展以支持其他可转让产品。

function findTransferable(obj) {
  const objsToSearch = [obj], transferable = []
  function checkTransferable(value) {
    if (typeof value !== 'object' || value === null) return
    if (ArrayBuffer.isView(value)) {
      transferable.push(value.buffer)
    } else if (value instanceof ArrayBuffer) {
      transferable.push(value)
    } else objsToSearch.push(value)
  }
  while (objsToSearch.length) {
    const obj = objsToSearch.pop()
    if (Array.isArray(obj)) {
      obj.forEach(checkTransferable)
    } else {
      Object.values(obj).forEach(checkTransferable)
    }
  }
  return transferable
}