WebAssembly.Exception.prototype.getArg()

exceptionTag

Ein WebAssembly.Tag, das mit dem mit dieser Ausnahme verbundenen Tag übereinstimmen muss.

index

Der Index des Werts in den Datenargumenten, der zurückgegeben werden soll, 0-indexiert.

Der Wert des Arguments bei index.

TypeError

Die Tags stimmen nicht überein; die Ausnahme wurde nicht mit dem Tag erstellt, das an die Methode übergeben wurde.

RangeError

Der Wert des index-Parameters ist größer oder gleich der Anzahl der Felder in den Daten.

Um die Werte einer Ausnahme zu erhalten, muss der Tag dem aufrufenden Code "bekannt" sein; er kann entweder in den aufrufenden Code importiert oder aus diesem exportiert werden.

Betrachten Sie den folgenden WebAssembly-Code, der angenommen wird, dass er in eine Datei "example.wasm" kompiliert wird. Dieser importiert ein Tag, das intern als $tagname bezeichnet wird, und exportiert eine Methode run, die von externem Code aufgerufen werden kann, um eine Ausnahme mit dem Tag auszulösen.

(module
  ;; import tag that will be referred to here as $tagname
  (import "extmod" "exttag" (tag $tagname (param i32)))

  ;; $throwException function throws i32 param as a $tagname exception
  (func $throwException (param i32)
    local.get 0
    throw $tagname
  )

  ;; Exported function "run" that calls $throwException
  (func (export "run")
    i32.const 1
    call $throwException
  )
)

Der unten stehende Code ruft WebAssembly.instantiateStreaming auf, um die "example.wasm"-Datei zu importieren, und übergibt ein "Import-Objekt" (importObject), das ein neues WebAssembly.Tag namens tagToImport enthält. Das Import-Objekt definiert ein Objekt mit Eigenschaften, die der Import-Anweisung im WebAssembly-Code entsprechen.

Sobald die Datei instanziiert ist, ruft der Code die exportierte WebAssembly-Methode run() auf, die sofort eine Ausnahme werfen wird.

const tagToImport = new WebAssembly.Tag({ parameters: ["i32"] });

// Note: the import object properties match the import statement in WebAssembly code!
const importObject = {
  extmod: {
    exttag: tagToImport,
  },
};

WebAssembly.instantiateStreaming(fetch("example.wasm"), importObject)
  .then((obj) => {
    console.log(obj.instance.exports.run());
  })
  .catch((e) => {
    console.error(e);
    console.log(`getArg 0 : ${e.getArg(tagToImport, 0)}`);
  });

/* Log output
example.js:40 WebAssembly.Exception: wasm exception
example.js:41 getArg 0 : 1
*/

Der Code fängt die Ausnahme ab und verwendet getArg(), um den Wert an dem ersten Index auszugeben. In diesem Fall ist es einfach "1".

Der Prozess für die Verwendung eines exportierten Tags ist dem im vorherigen Abschnitt gezeigten sehr ähnlich. Hier ist dasselbe WebAssembly-Modul, nur dass der Import durch einen Export ersetzt wird.

(module
  ;; Export tag giving it external name: "exptag"
  (tag $tagname (export "exptag") (param i32))

  (func $throwException (param i32)
    local.get 0
    throw $tagname
  )

  (func (export "run")
    i32.const 1
    call $throwException
  )
)

Das JavaScript ist ebenfalls ähnlich. In diesem Fall haben wir keine Importe, aber stattdessen erhalten wir das exportierte Tag und verwenden es, um das Argument abzurufen. Um es etwas "sicherer" zu machen, testen wir hier auch, ob wir das richtige Tag mit der is() Methode haben.

let tagExportedFromWasm;

WebAssembly.instantiateStreaming(fetch("example.wasm"))
  .then((obj) => {
    // Import the tag using its name from the WebAssembly module
    tagExportedFromWasm = obj.instance.exports.exptag;
    console.log(obj.instance.exports.run());
  })
  .catch((e) => {
    console.error(e);
    // If the tag is correct, get the value
    if (e.is(tagExportedFromWasm)) {
      console.log(`getArg 0 : ${e.getArg(tagExportedFromWasm, 0)}`);
    }
  });

• WebAssembly Übersichtsseite
• WebAssembly-Konzepte
• Verwendung der WebAssembly JavaScript API