HTML: Markup language
CSS: Styling language
JavaScript: Scripting language
Web APIs: Programming interfaces
All web technology
Learn web development
Discover our tools
Get to know MDN better
Dieser Inhalt wurde automatisch aus dem Englischen übersetzt, und kann Fehler enthalten. Erfahre mehr über dieses Experiment.
View in English Always switch to English
Diese Funktion ist gut etabliert und funktioniert auf vielen Geräten und in vielen Browserversionen. Sie ist seit Mai 2022 browserübergreifend verfügbar.
* Einige Teile dieser Funktion werden möglicherweise unterschiedlich gut unterstützt.
Hinweis: Diese Funktion ist in Web Workers verfügbar.
Das WebAssembly.Exception-Objekt stellt eine Laufzeitausnahme dar, die von WebAssembly nach JavaScript geworfen wird oder von JavaScript zu einem WebAssembly-Ausnahmebehandler.
WebAssembly.Exception
Der Konstruktor akzeptiert einen WebAssembly.Tag, ein Array von Werten und ein options-Objekt als Argumente. Der Tag definiert eindeutig den Typ einer Ausnahme, einschließlich der Reihenfolge seiner Argumente und ihrer Datentypen. Der gleiche Tag, der zum Erstellen der Exception verwendet wurde, ist erforderlich, um die Argumente einer ausgelösten Ausnahme zuzugreifen. Es werden Methoden bereitgestellt, um zu testen, ob eine Ausnahme mit einem bestimmten Tag übereinstimmt, und auch um einen bestimmten Wert nach Index zu erhalten (wenn die Ausnahme mit dem angegebenen Tag übereinstimmt).
WebAssembly.Tag
options
Exception
JavaScript und anderer Clientcode können nur auf WebAssembly-Ausnahmewerte zugreifen, und umgekehrt, wenn der zugehörige Tag geteilt ist (Sie können nicht einfach einen anderen Tag verwenden, der zufällig dieselben Datentypen definiert). Ohne das übereinstimmende Tag können Ausnahmen abgefangen und erneut ausgelöst werden, aber sie können nicht inspiziert werden.
Um das Werfen von Ausnahmen schneller zu machen, enthalten aus WebAssembly geworfene Ausnahmen im Allgemeinen keinen Stack-Trace. WebAssembly-Code, der einen Stack-Trace bereitstellen muss, muss eine JavaScript-Funktion aufrufen, um die Ausnahme zu erstellen, und den Parameter options.traceStack=true im Konstruktor übergeben. Der Konstruktor kann dann eine Ausnahme zurückgeben, die einen Stack-Trace in der stack-Eigenschaft angehängt hat.
options.traceStack=true
stack
WebAssembly.Exception()
Erstellt ein neues WebAssembly.Exception-Objekt.
Exception.prototype.is()
Prüft, ob die Ausnahme mit einem bestimmten Tag übereinstimmt.
Exception.prototype.getArg()
Gibt die Datenfelder einer Ausnahme zurück, die mit einem angegebenen Tag übereinstimmt.
Exception.prototype.stack
Gibt den Stack-Trace für die Ausnahme oder undefined zurück.
undefined
Dieses Beispiel zeigt, wie man einen Tag definiert und ihn in ein Modul importiert, um dann eine Ausnahme zu werfen, die in JavaScript abgefangen wird.
Betrachten Sie den folgenden WebAssembly-Code, der angenommen wird, dass er in eine Datei example.wasm kompiliert wurde.
$tagname
i32
extmod
exttag
$throwException
throw
run()
(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 $errorValueArg i32) local.get $errorValueArg throw $tagname ) ;; Exported function "run" that calls $throwException (func (export "run") i32.const 42 call $throwException ) )
Der folgende Code ruft WebAssembly.instantiateStreaming auf, um die Datei example.wasm zu importieren und ein "Importobjekt" (importObject) zu übergeben, das einen neuen WebAssembly.Tag mit dem Namen tagToImport enthält. Das Importobjekt definiert ein Objekt mit Eigenschaften, die zur import-Anweisung im WebAssembly-Code passen.
WebAssembly.instantiateStreaming
importObject
tagToImport
import
Sobald die Datei instanziiert ist, ruft der Code die exportierte WebAssembly-Methode run() auf, die unmittelbar eine Ausnahme auslöst.
const tagToImport = new WebAssembly.Tag({ parameters: ["i32"] }); // Note: import object properties match the WebAssembly import statement! const importObject = { extmod: { exttag: tagToImport, }, }; WebAssembly.instantiateStreaming(fetch("example.wasm"), importObject) .then((obj) => { console.log(obj.instance.exports.run()); }) .catch((e) => { console.error(e); // Check we have the right tag for the exception // If so, use getArg() to inspect it if (e.is(tagToImport)) { console.log(`getArg 0 : ${e.getArg(tagToImport, 0)}`); } }); /* Log output example.js:40 WebAssembly.Exception: wasm exception example.js:41 getArg 0 : 42 */
Die Ausnahme wird in JavaScript mit dem catch-Block abgefangen. Wir können sehen, dass es vom Typ WebAssembly.Exception ist, aber wenn wir nicht den richtigen Tag hätten, könnten wir nicht viel mehr tun.
catch
Da wir jedoch einen Tag haben, verwenden wir Exception.prototype.is(), um zu überprüfen, ob es der richtige ist, und da es richtig ist, rufen wir Exception.prototype.getArg() auf, um den Wert von "42" zu lesen.
JavaScript aktivieren, um diese Browser-Kompatibilitätstabelle anzuzeigen.