Ein WebAssembly.Module() Konstruktor erstellt ein neues Modulobjekt, das zustandslosen WebAssembly-Code enthält, der bereits vom Browser kompiliert wurde und effizient mit Workern geteilt und mehrfach instanziiert werden kann.

Die WebAssembly.Module() Konstruktorfunktion kann aufgerufen werden, um den gegebenen WebAssembly-Binärcode synchron zu kompilieren. Der primäre Weg, um ein Module zu erhalten, ist jedoch durch eine asynchrone Kompilierungsfunktion wie WebAssembly.compile().

Syntax

new WebAssembly.Module(bufferSource)
new WebAssembly.Module(bufferSource, compileOptions)

Parameter

bufferSource

Ein typisiertes Array oder ArrayBuffer, das den Binärcode des Wasm-Moduls enthält, das Sie kompilieren möchten.

compileOptions Optional

Ein Objekt, das Kompilierungsoptionen enthält. Eigenschaften können beinhalten:

builtins Optional

Ein Array von Zeichenfolgen, das die Verwendung von JavaScript builtins im kompilierten Wasm-Modul ermöglicht. Die Zeichenfolgen definieren die builtins, die Sie aktivieren möchten. Derzeit ist der einzige verfügbare Wert "js-string", der JavaScript-String-Builtins aktiviert.

importedStringConstants Optional

Eine Zeichenfolge, die einen Namespace für importierte globale Zeichenfolgenkonstanten angibt. Diese Eigenschaft muss angegeben werden, wenn Sie importierte globale Zeichenfolgenkonstanten im Wasm-Modul verwenden möchten.

Ausnahmen

• Wenn der Parameter nicht den richtigen Typ oder die richtige Struktur hat, wird ein TypeError ausgelöst.
• Wenn die Kompilierung fehlschlägt, lehnt der Konstruktor mit einem WebAssembly.CompileError ab.
• Einige Browser können einen RangeError auslösen, da sie die Kompilierung und Instanziierung von Wasm mit großen Puffern im UI-Thread verbieten.

Beispiele

Synchrones Kompilieren eines WebAssembly-Moduls

const importObject = {
  my_namespace: {
    imported_func(arg) {
      console.log(arg);
    },
  },
};

function createWasmModule(bytes) {
  return new WebAssembly.Module(bytes);
}

fetch("simple.wasm")
  .then((response) => response.arrayBuffer())
  .then((bytes) => {
    const mod = createWasmModule(bytes);
    WebAssembly.instantiate(mod, importObject).then((result) =>
      result.exports.exported_func(),
    );
  });

Aktivierung von JavaScript-Builtins und globalen Zeichenfolgenimporten

Dieses Beispiel ermöglicht JavaScript-String-Builtins und importierte globale Zeichenfolgenkonstanten, wenn ein Wasm-Modul über den Module()-Konstruktor kompiliert wird, welches dann mit instantiate() instanziiert wird. Anschließend wird die exportierte Funktion main() aufgerufen, die "hello world!" auf die Konsole schreibt. Hier live ansehen.

const importObject = {
  // Regular import
  m: {
    log: console.log,
  },
};

const compileOptions = {
  builtins: ["js-string"], // Enable JavaScript string builtins
  importedStringConstants: "string_constants", // Enable imported global string constants
};

fetch("log-concat.wasm")
  .then((response) => response.arrayBuffer())
  .then((bytes) => {
    const module = new WebAssembly.Module(bytes, compileOptions);
    WebAssembly.instantiate(module, importObject).then((instance) =>
      instance.exports.main(),
    );
  });

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Überblick über WebAssembly
• WebAssembly-Konzepte
• Verwendung der WebAssembly JavaScript-API