From 844f5103992238c0c23203286dad16a466e89c97 Mon Sep 17 00:00:00 2001 From: julieng Date: Tue, 3 Aug 2021 08:03:09 +0200 Subject: move *.html to *.md --- .../global_objects/webassembly/compile/index.html | 86 ----------- .../global_objects/webassembly/compile/index.md | 86 +++++++++++ .../webassembly/compileerror/index.html | 117 -------------- .../webassembly/compileerror/index.md | 117 ++++++++++++++ .../webassembly/compilestreaming/index.html | 80 ---------- .../webassembly/compilestreaming/index.md | 80 ++++++++++ .../global_objects/webassembly/global/index.html | 116 -------------- .../global_objects/webassembly/global/index.md | 116 ++++++++++++++ .../global_objects/webassembly/index.html | 105 ------------- .../reference/global_objects/webassembly/index.md | 105 +++++++++++++ .../webassembly/instance/exports/index.html | 68 -------- .../webassembly/instance/exports/index.md | 68 ++++++++ .../global_objects/webassembly/instance/index.html | 78 ---------- .../global_objects/webassembly/instance/index.md | 78 ++++++++++ .../webassembly/instantiate/index.html | 172 --------------------- .../webassembly/instantiate/index.md | 172 +++++++++++++++++++++ .../webassembly/instantiatestreaming/index.html | 87 ----------- .../webassembly/instantiatestreaming/index.md | 87 +++++++++++ .../webassembly/linkerror/index.html | 116 -------------- .../global_objects/webassembly/linkerror/index.md | 116 ++++++++++++++ .../webassembly/memory/buffer/index.html | 64 -------- .../webassembly/memory/buffer/index.md | 64 ++++++++ .../webassembly/memory/grow/index.html | 78 ---------- .../webassembly/memory/grow/index.md | 78 ++++++++++ .../global_objects/webassembly/memory/index.html | 120 -------------- .../global_objects/webassembly/memory/index.md | 120 ++++++++++++++ .../webassembly/module/customsections/index.html | 95 ------------ .../webassembly/module/customsections/index.md | 95 ++++++++++++ .../webassembly/module/exports/index.html | 105 ------------- .../webassembly/module/exports/index.md | 105 +++++++++++++ .../webassembly/module/imports/index.html | 81 ---------- .../webassembly/module/imports/index.md | 81 ++++++++++ .../global_objects/webassembly/module/index.html | 86 ----------- .../global_objects/webassembly/module/index.md | 86 +++++++++++ .../webassembly/runtimeerror/index.html | 116 -------------- .../webassembly/runtimeerror/index.md | 116 ++++++++++++++ .../webassembly/table/get/index.html | 84 ---------- .../global_objects/webassembly/table/get/index.md | 84 ++++++++++ .../webassembly/table/grow/index.html | 80 ---------- .../global_objects/webassembly/table/grow/index.md | 80 ++++++++++ .../global_objects/webassembly/table/index.html | 134 ---------------- .../global_objects/webassembly/table/index.md | 134 ++++++++++++++++ .../webassembly/table/length/index.html | 65 -------- .../webassembly/table/length/index.md | 65 ++++++++ .../webassembly/table/set/index.html | 102 ------------ .../global_objects/webassembly/table/set/index.md | 102 ++++++++++++ .../global_objects/webassembly/validate/index.html | 78 ---------- .../global_objects/webassembly/validate/index.md | 78 ++++++++++ 48 files changed, 2313 insertions(+), 2313 deletions(-) delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/compile/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/compile/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/compileerror/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/compileerror/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/compilestreaming/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/compilestreaming/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/global/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/global/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/instance/exports/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/instance/exports/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/instance/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/instance/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/instantiate/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/instantiate/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/instantiatestreaming/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/instantiatestreaming/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/linkerror/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/linkerror/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/memory/buffer/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/memory/buffer/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/memory/grow/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/memory/grow/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/memory/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/memory/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/module/customsections/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/module/customsections/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/module/exports/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/module/exports/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/module/imports/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/module/imports/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/module/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/module/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/runtimeerror/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/runtimeerror/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/table/get/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/table/get/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/table/grow/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/table/grow/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/table/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/table/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/table/length/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/table/length/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/table/set/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/table/set/index.md delete mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/validate/index.html create mode 100644 files/fr/web/javascript/reference/global_objects/webassembly/validate/index.md (limited to 'files/fr/web/javascript/reference/global_objects/webassembly') diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/compile/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/compile/index.html deleted file mode 100644 index 5e98ae5ba7..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/compile/index.html +++ /dev/null @@ -1,86 +0,0 @@ ---- -title: WebAssembly.compile() -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/compile -tags: - - API - - JavaScript - - Méthode - - Reference - - WebAssembly -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/compile -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/compile ---- -
{{JSRef}}
- -

La méthode WebAssembly.compile(), permet de compiler un module ({{jsxref("WebAssembly.Module")}} à partir d'un code binaire WebAssembly. Cette fonction est utile lorsqu'il est nécessaire de compiler un module avant de l'instancier (dans les autres cas, la méthode {{jsxref("WebAssembly.instantiate()")}} sera plus pertinente).

- -

Syntaxe

- -
Promise<WebAssembly.Module> WebAssembly.compile(bufferSource);
- -

Paramètres

- -
-
bufferSource
-
Un tableau typé ou un {{jsxref("ArrayBuffer")}} contenant le bytecode du module WebAssembly qu'on souhaite compiler.
-
- -

Valeur de retour

- -

Une promesse ({{jsxref("Promise")}}) dont la valeur de résolution est une instance de {{jsxref("WebAssembly.Module")}} qui représente le module compilé.

- -

Exceptions

- - - -

Exemples

- -

Dans l'exemple qui suit, on compile le bytecode simple.wasm grâce à la méthode compile() puis on envoie le contenu à un worker grâce à la méthode postMessage().

- -
var worker = new Worker("wasm_worker.js");
-
-fetch('simple.wasm').then(response =>
-  response.arrayBuffer()
-).then(bytes =>
-  WebAssembly.compile(bytes)
-).then(mod =>
-  worker.postMessage(mod)
-);
- -
-

Note : Dans la plupart des cas, mieux vaudra utiliser {{jsxref("WebAssembly.compileStreaming()")}} qui est plus efficace que compile().

-
- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblycompile', 'compile()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.compile")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/compile/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/compile/index.md new file mode 100644 index 0000000000..5e98ae5ba7 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/compile/index.md @@ -0,0 +1,86 @@ +--- +title: WebAssembly.compile() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/compile +tags: + - API + - JavaScript + - Méthode + - Reference + - WebAssembly +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/compile +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/compile +--- +
{{JSRef}}
+ +

La méthode WebAssembly.compile(), permet de compiler un module ({{jsxref("WebAssembly.Module")}} à partir d'un code binaire WebAssembly. Cette fonction est utile lorsqu'il est nécessaire de compiler un module avant de l'instancier (dans les autres cas, la méthode {{jsxref("WebAssembly.instantiate()")}} sera plus pertinente).

+ +

Syntaxe

+ +
Promise<WebAssembly.Module> WebAssembly.compile(bufferSource);
+ +

Paramètres

+ +
+
bufferSource
+
Un tableau typé ou un {{jsxref("ArrayBuffer")}} contenant le bytecode du module WebAssembly qu'on souhaite compiler.
+
+ +

Valeur de retour

+ +

Une promesse ({{jsxref("Promise")}}) dont la valeur de résolution est une instance de {{jsxref("WebAssembly.Module")}} qui représente le module compilé.

+ +

Exceptions

+ + + +

Exemples

+ +

Dans l'exemple qui suit, on compile le bytecode simple.wasm grâce à la méthode compile() puis on envoie le contenu à un worker grâce à la méthode postMessage().

+ +
var worker = new Worker("wasm_worker.js");
+
+fetch('simple.wasm').then(response =>
+  response.arrayBuffer()
+).then(bytes =>
+  WebAssembly.compile(bytes)
+).then(mod =>
+  worker.postMessage(mod)
+);
+ +
+

Note : Dans la plupart des cas, mieux vaudra utiliser {{jsxref("WebAssembly.compileStreaming()")}} qui est plus efficace que compile().

+
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblycompile', 'compile()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.compile")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/compileerror/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/compileerror/index.html deleted file mode 100644 index 0807afd7da..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/compileerror/index.html +++ /dev/null @@ -1,117 +0,0 @@ ---- -title: WebAssembly.CompileError() -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError -tags: - - API - - CompileError - - Constructeur - - Error - - JavaScript - - NativeError - - Reference - - WebAssembly -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/CompileError ---- -
{{JSRef}}
- -

Le constructeur WebAssembly.CompileError() permet de créer une nouvelle instance de CompileError qui indique qu'une erreur s'est produite lors du décodage du code WebAssembly ou lors de sa validation.

- -

Syntaxe

- -
new WebAssembly.CompileError(message, nomFichier, numeroLigne)
- -

Paramètres

- -
-
message {{optional_inline}}
-
Une description, compréhensible par un humain, de l'erreur qui s'est produite.
-
nomFichier {{optional_inline}}{{non-standard_inline}}
-
Le nom du fichier contenant le code à l'origine de l'exception.
-
numeroLigne {{optional_inline}}{{non-standard_inline}}
-
Le numéro de la ligne du fichier à l'origine de l'exception.
-
- -

Propriétés

- -

Le constructeur CompileError ne possède aucune propriété propre. En revanche, il hérite de certaines propriétés via sa chaîne de prototypes.

- -
-
WebAssembly.CompileError.prototype.constructor
-
Définit la fonction qui crée le prototype d'une instance.
-
{{jsxref("Error.prototype.message", "WebAssembly.CompileError.prototype.message")}}
-
Le message qui décrit l'erreur. Bien qu'ECMA-262 indique que  l'instance devrait fournir sa propre propriété message, pour SpiderMonkey, celle-ci est héritée depuis {{jsxref("Error.prototype.message")}}.
-
{{jsxref("Error.prototype.name", "WebAssembly.CompileError.prototype.name")}}
-
Le nom de l'erreur. Cette propriété est héritée depuis {{jsxref("Error")}}.
-
{{jsxref("Error.prototype.fileName", "WebAssembly.CompileError.prototype.fileName")}}
-
Le chemin vers le fichier qui a entraîné l'erreur. Cette propriété est héritée via {{jsxref("Error")}}.
-
{{jsxref("Error.prototype.lineNumber", "WebAssembly.CompileError.prototype.lineNumber")}}
-
Le numéro de la ligne dans le fichier qui a entraîné l'erreur. Cette propriété est héritée via {{jsxref("Error")}}.
-
{{jsxref("Error.prototype.columnNumber", "WebAssembly.CompileError.prototype.columnNumber")}}
-
Le numéro de la colonne dans la ligne du fichier qui a entraîné l'erreur. Cette propriété est héritée via {{jsxref("Error")}}.
-
{{jsxref("Error.prototype.stack", "WebAssembly.CompileError.prototype.stack")}}
-
La pile d'appel. Cette propriété est héritée via {{jsxref("Error")}}.
-
- -

Méthodes

- -

Le constructeur CompileError ne contient aucune méthode qui lui soit propre. En revanche, il hérite de certaines méthodes grâce à sa chaîne de prototypes.

- -
-
{{jsxref("Error.prototype.toSource", "WebAssembly.CompileError.prototype.toSource()")}}
-
Cette méthode renvoie un code qui pourrait provoquer la même erreur. Elle est héritée via {{jsxref("Error")}}.
-
{{jsxref("Error.prototype.toString", "WebAssembly.CompileError.prototype.toString()")}}
-
Cette méthode renvoie une chaîne de caractères qui représente l'objet de l'erreur. Elle est héritée via {{jsxref("Error")}}.
-
- -

Exemples

- -

Le fragment de code qui suit crée une instance de CompileError puis imprime ses détails dans la console :

- -
try {
-  throw new WebAssembly.CompileError('Coucou', 'unFichier', 10);
-} catch (e) {
-  console.log(e instanceof CompileError); // true
-  console.log(e.message);                 // "Coucou"
-  console.log(e.name);                    // "CompileError"
-  console.log(e.fileName);                // "unFichier"
-  console.log(e.lineNumber);              // 10
-  console.log(e.columnNumber);            // 0
-  console.log(e.stack);                   // la pile d'appel pour le code
-}
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#constructor-properties-of-the-webassembly-object', 'WebAssembly constructors')}}{{Spec2('WebAssembly JS')}}Brouillon pour la définition Initiale de WebAssembly.
{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard', 'NativeError')}}{{Spec2('ESDraft')}}Définition des types standards pour NativeError.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.CompileError")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/compileerror/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/compileerror/index.md new file mode 100644 index 0000000000..0807afd7da --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/compileerror/index.md @@ -0,0 +1,117 @@ +--- +title: WebAssembly.CompileError() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError +tags: + - API + - CompileError + - Constructeur + - Error + - JavaScript + - NativeError + - Reference + - WebAssembly +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/CompileError +--- +
{{JSRef}}
+ +

Le constructeur WebAssembly.CompileError() permet de créer une nouvelle instance de CompileError qui indique qu'une erreur s'est produite lors du décodage du code WebAssembly ou lors de sa validation.

+ +

Syntaxe

+ +
new WebAssembly.CompileError(message, nomFichier, numeroLigne)
+ +

Paramètres

+ +
+
message {{optional_inline}}
+
Une description, compréhensible par un humain, de l'erreur qui s'est produite.
+
nomFichier {{optional_inline}}{{non-standard_inline}}
+
Le nom du fichier contenant le code à l'origine de l'exception.
+
numeroLigne {{optional_inline}}{{non-standard_inline}}
+
Le numéro de la ligne du fichier à l'origine de l'exception.
+
+ +

Propriétés

+ +

Le constructeur CompileError ne possède aucune propriété propre. En revanche, il hérite de certaines propriétés via sa chaîne de prototypes.

+ +
+
WebAssembly.CompileError.prototype.constructor
+
Définit la fonction qui crée le prototype d'une instance.
+
{{jsxref("Error.prototype.message", "WebAssembly.CompileError.prototype.message")}}
+
Le message qui décrit l'erreur. Bien qu'ECMA-262 indique que  l'instance devrait fournir sa propre propriété message, pour SpiderMonkey, celle-ci est héritée depuis {{jsxref("Error.prototype.message")}}.
+
{{jsxref("Error.prototype.name", "WebAssembly.CompileError.prototype.name")}}
+
Le nom de l'erreur. Cette propriété est héritée depuis {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.fileName", "WebAssembly.CompileError.prototype.fileName")}}
+
Le chemin vers le fichier qui a entraîné l'erreur. Cette propriété est héritée via {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.lineNumber", "WebAssembly.CompileError.prototype.lineNumber")}}
+
Le numéro de la ligne dans le fichier qui a entraîné l'erreur. Cette propriété est héritée via {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.columnNumber", "WebAssembly.CompileError.prototype.columnNumber")}}
+
Le numéro de la colonne dans la ligne du fichier qui a entraîné l'erreur. Cette propriété est héritée via {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.stack", "WebAssembly.CompileError.prototype.stack")}}
+
La pile d'appel. Cette propriété est héritée via {{jsxref("Error")}}.
+
+ +

Méthodes

+ +

Le constructeur CompileError ne contient aucune méthode qui lui soit propre. En revanche, il hérite de certaines méthodes grâce à sa chaîne de prototypes.

+ +
+
{{jsxref("Error.prototype.toSource", "WebAssembly.CompileError.prototype.toSource()")}}
+
Cette méthode renvoie un code qui pourrait provoquer la même erreur. Elle est héritée via {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.toString", "WebAssembly.CompileError.prototype.toString()")}}
+
Cette méthode renvoie une chaîne de caractères qui représente l'objet de l'erreur. Elle est héritée via {{jsxref("Error")}}.
+
+ +

Exemples

+ +

Le fragment de code qui suit crée une instance de CompileError puis imprime ses détails dans la console :

+ +
try {
+  throw new WebAssembly.CompileError('Coucou', 'unFichier', 10);
+} catch (e) {
+  console.log(e instanceof CompileError); // true
+  console.log(e.message);                 // "Coucou"
+  console.log(e.name);                    // "CompileError"
+  console.log(e.fileName);                // "unFichier"
+  console.log(e.lineNumber);              // 10
+  console.log(e.columnNumber);            // 0
+  console.log(e.stack);                   // la pile d'appel pour le code
+}
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#constructor-properties-of-the-webassembly-object', 'WebAssembly constructors')}}{{Spec2('WebAssembly JS')}}Brouillon pour la définition Initiale de WebAssembly.
{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard', 'NativeError')}}{{Spec2('ESDraft')}}Définition des types standards pour NativeError.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.CompileError")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/compilestreaming/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/compilestreaming/index.html deleted file mode 100644 index 539c7b3e2f..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/compilestreaming/index.html +++ /dev/null @@ -1,80 +0,0 @@ ---- -title: WebAssembly.compileStreaming() -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/compileStreaming -tags: - - API - - JavaScript - - Méthode - - Object - - Reference - - WebAssembly -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/compileStreaming -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/compileStreaming ---- -
{{JSRef}}
- -

La fonction WebAssembly.compileStreaming() permet de compiler un module WebAssembly (c'est-à-dire un objet {{jsxref("WebAssembly.Module")}}) depuis un flux source. Cette fonction est utile si on doit compiler un module avant de l'instancier séparement, sinon on utilisera plutôt {{jsxref("WebAssembly.instantiateStreaming()")}}.

- -

Syntaxe

- -
Promise<WebAssembly.Module> WebAssembly.compileStreaming(source);
- -

Paramètres

- -
-
source
-
Un objet {{domxref("Response")}} ou une promesse qui sera résolue avec un objet {{domxref("Response")}} qui représentee la source du module .wasm qu'on souhaite manipuler comme un flux et compiler.
-
- -

Valeur de retour

- -

Un objet Promise dont la valeur de résolution est un objet {{jsxref("WebAssembly.Module")}} qui représente le module compilé.

- -

Exceptions

- - - -

Exemples

- -

Dans l'exemple suivant (également disponible sur GitHub : compile-streaming.html et avec le résultat live), on récupère un flux dedpuis un module .wasm puis on le compile en un objet {{jsxref("WebAssembly.Module")}}. La fonction compileStreaming()  acceptant une promesse pour un objet {{domxref("Response")}}, on peut directement passer l'appel à  {{domxref("WindowOrWorkerGlobalScope.fetch()")}} qui transfèrera la réponse dès que la promesse sera tenue.

- -
var importObject = { imports: { imported_func: arg => console.log(arg) } };
-
-WebAssembly.compileStreaming(fetch('simple.wasm'))
-.then(module => WebAssembly.instantiate(module, importObject))
-.then(instance => instance.exports.exported_func());
- -

Le module est ensuite instancié grâce à la fonction {{jsxref("WebAssembly.instantiate()")}}. Enfin, on appelle la fonction exportée.

- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly Embedding', '#webassemblycompilestreaming', 'compileStreaming()')}}{{Spec2('WebAssembly Embedding')}}Brouillon pour la définition initiale.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.compileStreaming")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/compilestreaming/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/compilestreaming/index.md new file mode 100644 index 0000000000..539c7b3e2f --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/compilestreaming/index.md @@ -0,0 +1,80 @@ +--- +title: WebAssembly.compileStreaming() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/compileStreaming +tags: + - API + - JavaScript + - Méthode + - Object + - Reference + - WebAssembly +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/compileStreaming +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/compileStreaming +--- +
{{JSRef}}
+ +

La fonction WebAssembly.compileStreaming() permet de compiler un module WebAssembly (c'est-à-dire un objet {{jsxref("WebAssembly.Module")}}) depuis un flux source. Cette fonction est utile si on doit compiler un module avant de l'instancier séparement, sinon on utilisera plutôt {{jsxref("WebAssembly.instantiateStreaming()")}}.

+ +

Syntaxe

+ +
Promise<WebAssembly.Module> WebAssembly.compileStreaming(source);
+ +

Paramètres

+ +
+
source
+
Un objet {{domxref("Response")}} ou une promesse qui sera résolue avec un objet {{domxref("Response")}} qui représentee la source du module .wasm qu'on souhaite manipuler comme un flux et compiler.
+
+ +

Valeur de retour

+ +

Un objet Promise dont la valeur de résolution est un objet {{jsxref("WebAssembly.Module")}} qui représente le module compilé.

+ +

Exceptions

+ + + +

Exemples

+ +

Dans l'exemple suivant (également disponible sur GitHub : compile-streaming.html et avec le résultat live), on récupère un flux dedpuis un module .wasm puis on le compile en un objet {{jsxref("WebAssembly.Module")}}. La fonction compileStreaming()  acceptant une promesse pour un objet {{domxref("Response")}}, on peut directement passer l'appel à  {{domxref("WindowOrWorkerGlobalScope.fetch()")}} qui transfèrera la réponse dès que la promesse sera tenue.

+ +
var importObject = { imports: { imported_func: arg => console.log(arg) } };
+
+WebAssembly.compileStreaming(fetch('simple.wasm'))
+.then(module => WebAssembly.instantiate(module, importObject))
+.then(instance => instance.exports.exported_func());
+ +

Le module est ensuite instancié grâce à la fonction {{jsxref("WebAssembly.instantiate()")}}. Enfin, on appelle la fonction exportée.

+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly Embedding', '#webassemblycompilestreaming', 'compileStreaming()')}}{{Spec2('WebAssembly Embedding')}}Brouillon pour la définition initiale.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.compileStreaming")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/global/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/global/index.html deleted file mode 100644 index d31849c70e..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/global/index.html +++ /dev/null @@ -1,116 +0,0 @@ ---- -title: WebAssembly.Global -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Global -tags: - - API - - Constructor - - JavaScript - - Reference - - TopicStub - - WebAssembly - - global -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Global -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Global ---- -
{{JSRef}}
- -

Un objet WebAssembly.Global représente une instance d'une variable globale, accessible depuis le code JavaScript et importable/exportable pour un ou plusieurs modules WebAssembly ({{jsxref("WebAssembly.Module")}}). Cela permet de lier dynamiquement plusieurs modules.

- -

Syntaxe

- -
var maGlobale = new WebAssembly.Global(descripteur, valeur);
- -

Paramètres

- -
-
descripteur
-
Un dictionnaire GlobalDescriptor qui contient deux propriétés : -
    -
  • value : une valeur {{domxref("USVString")}} qui représente le type de donnée de la variable globale. Ce type peut être i32, i64, f32 ou f64.
    • -
  • mutable : un booléen qui indique si la variable globale peut être modifiée ou non. Par défaut, cette propriété vaut false.
    • -
-
-
valeur
-
La valeur que la variable doit contenir. Ce peut être n'importe quelle valeur qui respecte le type de donnée de la variable. Si aucune valeur n'est indiquée, c'est une valeur nulle typée qui est utilisée, tel qu'indiqué dans l'algorithme DefaultValue.
-
- -

Propriétés

- -

Aucune.

- -

Instances de WebAssembly.Global

- -

Toutes les instances de Global héritent du prototype du constructeur Global(). Ce prototype peut être modifié afin d'avoir un impact sur l'ensemble des instances de Global.

- -

Propriétés des instances

- -

{{page('/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global/prototype', 'Propriétés')}}

- -

Méthodes des instances

- -

{{page('/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global/prototype', 'Méthodes')}}

- -

Exemples

- -

Dans l'exemple suivant, on montre comment créer une nouvelle instance globale grâce au constructeur WebAssembly.Global(). Cette instance globale est définie avec le type i32 et est indiquée comme modifiable. Sa valeur initiale est 0.

- -

On change ensuite la valeur de la variable globale en la passant à 42 grâce à la propriété Global.value puis en la passant à 43 grâce à la fonction incGlobal() qui a été exportée depuis le module global.wasm (cette fonction ajoute 1 à n'imorte quelle valeur puis renvoie cette nouvelle valeur).

- -
const output = document.getElementById('output');
-
-function assertEq(msg, got, expected) {
-    output.innerHTML += `Testing ${msg}: `;
-    if (got !== expected)
-        output.innerHTML += `FAIL!<br>Got: ${got}<br>Expected: ${expected}<br>`;
-    else
-        output.innerHTML += `SUCCESS! Got: ${got}<br>`;
-}
-
-assertEq("WebAssembly.Global exists", typeof WebAssembly.Global, "function");
-
-const global = new WebAssembly.Global({value:'i32', mutable:true}, 0);
-
-WebAssembly.instantiateStreaming(fetch('global.wasm'), { js: { global } })
-.then(({instance}) => {
-    assertEq("getting initial value from wasm", instance.exports.getGlobal(), 0);
-    global.value = 42;
-    assertEq("getting JS-updated value from wasm", instance.exports.getGlobal(), 42);
-    instance.exports.incGlobal();
-    assertEq("getting wasm-updated value from JS", global.value, 43);
-});
- -
-

Note : Cet exemple est utilisable sur GitHub et son code source est également disponible.

-
- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#globals', 'WebAssembly.Global()')}}{{Spec2('WebAssembly JS')}}Brouillon de spécification initiale.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.Global")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/global/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/global/index.md new file mode 100644 index 0000000000..d31849c70e --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/global/index.md @@ -0,0 +1,116 @@ +--- +title: WebAssembly.Global +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Global +tags: + - API + - Constructor + - JavaScript + - Reference + - TopicStub + - WebAssembly + - global +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Global +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Global +--- +
{{JSRef}}
+ +

Un objet WebAssembly.Global représente une instance d'une variable globale, accessible depuis le code JavaScript et importable/exportable pour un ou plusieurs modules WebAssembly ({{jsxref("WebAssembly.Module")}}). Cela permet de lier dynamiquement plusieurs modules.

+ +

Syntaxe

+ +
var maGlobale = new WebAssembly.Global(descripteur, valeur);
+ +

Paramètres

+ +
+
descripteur
+
Un dictionnaire GlobalDescriptor qui contient deux propriétés : +
    +
  • value : une valeur {{domxref("USVString")}} qui représente le type de donnée de la variable globale. Ce type peut être i32, i64, f32 ou f64.
    • +
  • mutable : un booléen qui indique si la variable globale peut être modifiée ou non. Par défaut, cette propriété vaut false.
    • +
+
+
valeur
+
La valeur que la variable doit contenir. Ce peut être n'importe quelle valeur qui respecte le type de donnée de la variable. Si aucune valeur n'est indiquée, c'est une valeur nulle typée qui est utilisée, tel qu'indiqué dans l'algorithme DefaultValue.
+
+ +

Propriétés

+ +

Aucune.

+ +

Instances de WebAssembly.Global

+ +

Toutes les instances de Global héritent du prototype du constructeur Global(). Ce prototype peut être modifié afin d'avoir un impact sur l'ensemble des instances de Global.

+ +

Propriétés des instances

+ +

{{page('/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global/prototype', 'Propriétés')}}

+ +

Méthodes des instances

+ +

{{page('/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global/prototype', 'Méthodes')}}

+ +

Exemples

+ +

Dans l'exemple suivant, on montre comment créer une nouvelle instance globale grâce au constructeur WebAssembly.Global(). Cette instance globale est définie avec le type i32 et est indiquée comme modifiable. Sa valeur initiale est 0.

+ +

On change ensuite la valeur de la variable globale en la passant à 42 grâce à la propriété Global.value puis en la passant à 43 grâce à la fonction incGlobal() qui a été exportée depuis le module global.wasm (cette fonction ajoute 1 à n'imorte quelle valeur puis renvoie cette nouvelle valeur).

+ +
const output = document.getElementById('output');
+
+function assertEq(msg, got, expected) {
+    output.innerHTML += `Testing ${msg}: `;
+    if (got !== expected)
+        output.innerHTML += `FAIL!<br>Got: ${got}<br>Expected: ${expected}<br>`;
+    else
+        output.innerHTML += `SUCCESS! Got: ${got}<br>`;
+}
+
+assertEq("WebAssembly.Global exists", typeof WebAssembly.Global, "function");
+
+const global = new WebAssembly.Global({value:'i32', mutable:true}, 0);
+
+WebAssembly.instantiateStreaming(fetch('global.wasm'), { js: { global } })
+.then(({instance}) => {
+    assertEq("getting initial value from wasm", instance.exports.getGlobal(), 0);
+    global.value = 42;
+    assertEq("getting JS-updated value from wasm", instance.exports.getGlobal(), 42);
+    instance.exports.incGlobal();
+    assertEq("getting wasm-updated value from JS", global.value, 43);
+});
+ +
+

Note : Cet exemple est utilisable sur GitHub et son code source est également disponible.

+
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#globals', 'WebAssembly.Global()')}}{{Spec2('WebAssembly JS')}}Brouillon de spécification initiale.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.Global")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/index.html deleted file mode 100644 index eb71d2c673..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/index.html +++ /dev/null @@ -1,105 +0,0 @@ ---- -title: WebAssembly -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly -tags: - - API - - JavaScript - - Object - - Reference - - WebAssembly -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly ---- -
{{JSRef}}
- -

L'objet JavaScript WebAssembly est un objet global qui agit comme un espace de noms (namespace) pour les différentes fonctionnalités JavaScript relatives à WebAssembly.

- -

À la différence des autres objets globaux, WebAssembly n'est pas un constructeur (au même titre que {{jsxref("Math")}} qui agit comme un espace de noms pour les constantes et fonctions mathématiques ou comme {{jsxref("Intl")}} qui centralise les constructeurs et les opérations relatives à l'internationalisation).

- -

Description

- -

L'objet WebAssembly est notamment utilisé pour :

- - - -

Méthodes

- -
-
{{jsxref("WebAssembly.instantiate()")}}
-
La méthode qu'on utilisera la plupart du temps pour compiler et instancier du code WebAssembly, elle renvoie une promesse qui est résolue en une Instance ou en une Instance et un Module.
-
{{jsxref("WebAssembly.instantiateStreaming()")}}
-
Cette méthode peremet de compiler et d'instancier un module WebAssembly à partir d'un flux source (streamed source). Elle renvoie à la fois un objet Module et sa première Instance.
-
{{jsxref("WebAssembly.compile()")}}
-
Cette méthode permet de compiler un {{jsxref("WebAssembly.Module")}} à partir de bytecode  WebAssembly, l'instanciation doit alors être effectuée dans une autre étape.
-
{{jsxref("WebAssembly.compileStreaming()")}}
-
Cette méthode permet de compiler un module {{jsxref("WebAssembly.Module")}} à partir d'un flux source (streamed source). L'instanciation devra alors être réalisée avec une autre étape.
-
{{jsxref("WebAssembly.validate()")}}
-
Cette méthode permet de valider un tableau typé censé contenir du bytecode WebAssembly : elle renvoie true si les octets forment un code WebAssembly valide ou false sinon.
-
- -

Constructeurs

- -
-
{{jsxref("WebAssembly.Global()")}}
-
Ce constructeur permet de créer un nouvel objet WebAssembly Global.
-
{{jsxref("WebAssembly.Module()")}}
-
Ce constructeur permet de créer un objet WebAssembly Module.
-
{{jsxref("WebAssembly.Instance()")}}
-
Ce constructeur permet de créer un objet WebAssembly Instance.
-
{{jsxref("WebAssembly.Memory()")}}
-
Ce constructeur permet de créer un objet WebAssembly Memory.
-
{{jsxref("WebAssembly.Table()")}}
-
Ce constructeur permet de créer un objet WebAssembly Table.
-
{{jsxref("WebAssembly.CompileError()")}}
-
Ce constructeur permet de créer un objet WebAssembly CompileError.
-
{{jsxref("WebAssembly.LinkError()")}}
-
Ce constructeur permet de créer un objet WebAssembly LinkError.
-
{{jsxref("WebAssembly.RuntimeError()")}}
-
Ce constructeur permet de créer un objet WebAssembly RuntimeError.
-
- -

Exemples

- -

L'exemple suivant (cf. le fichier instantiate-streaming.html sur GitHub et le résultat obtenu) permet de récupérer le module WebAssembly via un flux depuis une source, de le compiler, puis de l'instancier. La promesse est résolue avec un objet ResultObject. La méthode instantiateStreaming() accepte une promesse pour l'argument {{domxref("Response")}}, on peut lui passer directement un appel à {{domxref("WindowOrWorkerGlobalScope.fetch()")}} qui passera ensuite la réponse à la fonction lors de la complétion de la promesse.

- -
var importObject = { imports: { imported_func: arg => console.log(arg) } };
-
-WebAssembly.instantiateStreaming(fetch('simple.wasm'), importObject)
-.then(obj => obj.instance.exports.exported_func());
- -

On accède alors à la propriété de l'instance ResultObject puis on appelle la fonction exportée.

- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#the-webassembly-object', 'WebAssembly')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/index.md new file mode 100644 index 0000000000..eb71d2c673 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/index.md @@ -0,0 +1,105 @@ +--- +title: WebAssembly +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly +tags: + - API + - JavaScript + - Object + - Reference + - WebAssembly +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly +--- +
{{JSRef}}
+ +

L'objet JavaScript WebAssembly est un objet global qui agit comme un espace de noms (namespace) pour les différentes fonctionnalités JavaScript relatives à WebAssembly.

+ +

À la différence des autres objets globaux, WebAssembly n'est pas un constructeur (au même titre que {{jsxref("Math")}} qui agit comme un espace de noms pour les constantes et fonctions mathématiques ou comme {{jsxref("Intl")}} qui centralise les constructeurs et les opérations relatives à l'internationalisation).

+ +

Description

+ +

L'objet WebAssembly est notamment utilisé pour :

+ + + +

Méthodes

+ +
+
{{jsxref("WebAssembly.instantiate()")}}
+
La méthode qu'on utilisera la plupart du temps pour compiler et instancier du code WebAssembly, elle renvoie une promesse qui est résolue en une Instance ou en une Instance et un Module.
+
{{jsxref("WebAssembly.instantiateStreaming()")}}
+
Cette méthode peremet de compiler et d'instancier un module WebAssembly à partir d'un flux source (streamed source). Elle renvoie à la fois un objet Module et sa première Instance.
+
{{jsxref("WebAssembly.compile()")}}
+
Cette méthode permet de compiler un {{jsxref("WebAssembly.Module")}} à partir de bytecode  WebAssembly, l'instanciation doit alors être effectuée dans une autre étape.
+
{{jsxref("WebAssembly.compileStreaming()")}}
+
Cette méthode permet de compiler un module {{jsxref("WebAssembly.Module")}} à partir d'un flux source (streamed source). L'instanciation devra alors être réalisée avec une autre étape.
+
{{jsxref("WebAssembly.validate()")}}
+
Cette méthode permet de valider un tableau typé censé contenir du bytecode WebAssembly : elle renvoie true si les octets forment un code WebAssembly valide ou false sinon.
+
+ +

Constructeurs

+ +
+
{{jsxref("WebAssembly.Global()")}}
+
Ce constructeur permet de créer un nouvel objet WebAssembly Global.
+
{{jsxref("WebAssembly.Module()")}}
+
Ce constructeur permet de créer un objet WebAssembly Module.
+
{{jsxref("WebAssembly.Instance()")}}
+
Ce constructeur permet de créer un objet WebAssembly Instance.
+
{{jsxref("WebAssembly.Memory()")}}
+
Ce constructeur permet de créer un objet WebAssembly Memory.
+
{{jsxref("WebAssembly.Table()")}}
+
Ce constructeur permet de créer un objet WebAssembly Table.
+
{{jsxref("WebAssembly.CompileError()")}}
+
Ce constructeur permet de créer un objet WebAssembly CompileError.
+
{{jsxref("WebAssembly.LinkError()")}}
+
Ce constructeur permet de créer un objet WebAssembly LinkError.
+
{{jsxref("WebAssembly.RuntimeError()")}}
+
Ce constructeur permet de créer un objet WebAssembly RuntimeError.
+
+ +

Exemples

+ +

L'exemple suivant (cf. le fichier instantiate-streaming.html sur GitHub et le résultat obtenu) permet de récupérer le module WebAssembly via un flux depuis une source, de le compiler, puis de l'instancier. La promesse est résolue avec un objet ResultObject. La méthode instantiateStreaming() accepte une promesse pour l'argument {{domxref("Response")}}, on peut lui passer directement un appel à {{domxref("WindowOrWorkerGlobalScope.fetch()")}} qui passera ensuite la réponse à la fonction lors de la complétion de la promesse.

+ +
var importObject = { imports: { imported_func: arg => console.log(arg) } };
+
+WebAssembly.instantiateStreaming(fetch('simple.wasm'), importObject)
+.then(obj => obj.instance.exports.exported_func());
+ +

On accède alors à la propriété de l'instance ResultObject puis on appelle la fonction exportée.

+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#the-webassembly-object', 'WebAssembly')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/instance/exports/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/instance/exports/index.html deleted file mode 100644 index 86bece9671..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/instance/exports/index.html +++ /dev/null @@ -1,68 +0,0 @@ ---- -title: WebAssembly.Instance.prototype.exports -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance/exports -tags: - - API - - Experimental - - JavaScript - - Propriété - - Reference - - WebAssembly - - instance -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance/exports -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Instance/exports ---- -
{{JSRef}}
- -

La propriété exports du prototype de {{jsxref("WebAssembly.Instance")}} est une propriété en lecture seul qui renvoie un objet dont les propriétés sont les différentes fonctions exportées depuis l'instance du module WebAssembly. Cela permet d'y accéder et de les manipuler en JavaScript.

- -
instance.exports
- -

Exemples

- -

Après avoir récupéré le bytecode WebAssembly grâce à la méthode fetch(), on le compile et on instancie le module grâce à la fonction {{jsxref("WebAssembly.instantiateStreaming()")}}. Lorsqu'on utilise cette fonction, on importe une fonction dans le module. Ensuite, on appelle une fonction WebAssembly exportée qui est exposée via l'instance.

- -
var importObject = {
-  imports: {
-    imported_func: function(arg) {
-      console.log(arg);
-    }
-  }
-};
-WebAssembly.instantiateStreaming(fetch('simple.wasm'), importObject)
-.then(obj => obj.instance.exports.exported_func());
- -
-

Note : Voir le fichier index.html sur GitHub (ainsi que la démonstration) pour un exemple.

-
- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblyinstance-objects', 'WebAssembly.Instance objects')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.Instance.exports")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/instance/exports/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/instance/exports/index.md new file mode 100644 index 0000000000..86bece9671 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/instance/exports/index.md @@ -0,0 +1,68 @@ +--- +title: WebAssembly.Instance.prototype.exports +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance/exports +tags: + - API + - Experimental + - JavaScript + - Propriété + - Reference + - WebAssembly + - instance +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance/exports +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Instance/exports +--- +
{{JSRef}}
+ +

La propriété exports du prototype de {{jsxref("WebAssembly.Instance")}} est une propriété en lecture seul qui renvoie un objet dont les propriétés sont les différentes fonctions exportées depuis l'instance du module WebAssembly. Cela permet d'y accéder et de les manipuler en JavaScript.

+ +
instance.exports
+ +

Exemples

+ +

Après avoir récupéré le bytecode WebAssembly grâce à la méthode fetch(), on le compile et on instancie le module grâce à la fonction {{jsxref("WebAssembly.instantiateStreaming()")}}. Lorsqu'on utilise cette fonction, on importe une fonction dans le module. Ensuite, on appelle une fonction WebAssembly exportée qui est exposée via l'instance.

+ +
var importObject = {
+  imports: {
+    imported_func: function(arg) {
+      console.log(arg);
+    }
+  }
+};
+WebAssembly.instantiateStreaming(fetch('simple.wasm'), importObject)
+.then(obj => obj.instance.exports.exported_func());
+ +
+

Note : Voir le fichier index.html sur GitHub (ainsi que la démonstration) pour un exemple.

+
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblyinstance-objects', 'WebAssembly.Instance objects')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.Instance.exports")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/instance/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/instance/index.html deleted file mode 100644 index 1fceef26d9..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/instance/index.html +++ /dev/null @@ -1,78 +0,0 @@ ---- -title: WebAssembly.Instance() -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance -tags: - - API - - Constructeur - - JavaScript - - Reference - - WebAssembly - - instance -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Instance ---- -
{{JSRef}}
- -

Un objet WebAssembly.Instance représente un objet exécutable, avec un état, qui est une instance d'un module WebAssembly. Un objet Instance contient l'ensemble des fonctions WebAssembly exportées qui permettent d'invoquer du code WebAssembly depuis du code JavaScript.

- -

Le constructeur WebAssembly.Instance() peut être appelé afin de créer, de façon synchrone, une instance d'un {{jsxref("WebAssembly.Module")}} donné. Toutefois, pour obtenir une instance, on utilisera généralement la fonction asynchrone {{jsxref("WebAssembly.instantiateStreaming()")}}.

- -

Syntaxe

- -
-

Attention :L'instanciation de modules volumineux peut être coûteuse en temps/ressource. Instance() ne doit être utilisée que lorsqu'une instanciation synchrone est nécessaire. Pour tous les autres cas, c'est la méthode {{jsxref("WebAssembly.instantiateStreaming()")}} qui devrait être utilisée.

-
- -
var monInstance = new WebAssembly.Instance(module, importObject);
- -

Paramètres

- -
-
module
-
L'objet WebAssembly.Module qu'on souhaite instancier.
-
importObject {{optional_inline}}
-
Un objet qui contient des valeurs à importer dans l'instance. Ce peuvent être des fonctions ou des objets WebAssembly.Memory. Il doit exister une propriété correspondante pour chaque import, si ce n'est pas le cas, un exception WebAssembly.LinkError sera levée.
-
- -

Instances d'Instance

- -

Toutes les instances du type Instance héritent du prototype du constructeur Instance(). Celui-ci peut être modifié afin de modifier l'ensemble des instances de Instance.

- -

Propriétés

- -

{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/WebAssembly/Instance/prototype', 'Propriétés')}}

- -

Méthodes

- -

{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/WebAssembly/Instance/prototype', 'Méthodes')}}

- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblyinstance-objects', 'Instance')}}{{Spec2('WebAssembly JS')}}Définition initiale dans un brouillon de spécification.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.Instance")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/instance/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/instance/index.md new file mode 100644 index 0000000000..1fceef26d9 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/instance/index.md @@ -0,0 +1,78 @@ +--- +title: WebAssembly.Instance() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance +tags: + - API + - Constructeur + - JavaScript + - Reference + - WebAssembly + - instance +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Instance +--- +
{{JSRef}}
+ +

Un objet WebAssembly.Instance représente un objet exécutable, avec un état, qui est une instance d'un module WebAssembly. Un objet Instance contient l'ensemble des fonctions WebAssembly exportées qui permettent d'invoquer du code WebAssembly depuis du code JavaScript.

+ +

Le constructeur WebAssembly.Instance() peut être appelé afin de créer, de façon synchrone, une instance d'un {{jsxref("WebAssembly.Module")}} donné. Toutefois, pour obtenir une instance, on utilisera généralement la fonction asynchrone {{jsxref("WebAssembly.instantiateStreaming()")}}.

+ +

Syntaxe

+ +
+

Attention :L'instanciation de modules volumineux peut être coûteuse en temps/ressource. Instance() ne doit être utilisée que lorsqu'une instanciation synchrone est nécessaire. Pour tous les autres cas, c'est la méthode {{jsxref("WebAssembly.instantiateStreaming()")}} qui devrait être utilisée.

+
+ +
var monInstance = new WebAssembly.Instance(module, importObject);
+ +

Paramètres

+ +
+
module
+
L'objet WebAssembly.Module qu'on souhaite instancier.
+
importObject {{optional_inline}}
+
Un objet qui contient des valeurs à importer dans l'instance. Ce peuvent être des fonctions ou des objets WebAssembly.Memory. Il doit exister une propriété correspondante pour chaque import, si ce n'est pas le cas, un exception WebAssembly.LinkError sera levée.
+
+ +

Instances d'Instance

+ +

Toutes les instances du type Instance héritent du prototype du constructeur Instance(). Celui-ci peut être modifié afin de modifier l'ensemble des instances de Instance.

+ +

Propriétés

+ +

{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/WebAssembly/Instance/prototype', 'Propriétés')}}

+ +

Méthodes

+ +

{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/WebAssembly/Instance/prototype', 'Méthodes')}}

+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblyinstance-objects', 'Instance')}}{{Spec2('WebAssembly JS')}}Définition initiale dans un brouillon de spécification.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.Instance")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/instantiate/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/instantiate/index.html deleted file mode 100644 index 5ec32f1f87..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/instantiate/index.html +++ /dev/null @@ -1,172 +0,0 @@ ---- -title: WebAssembly.instantiate() -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate -tags: - - API - - JavaScript - - Méthode - - Reference - - WebAssembly -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/instantiate ---- -
{{JSRef}}
- -

La fonction WebAssembly.instantiate() permet de compiler et d'instancier du code WebAssembly. Cette fonction possède deux formes :

- - - -
-

Attention : Tant que faire se peut, utiliser la méthode {{jsxref("WebAssembly.instantiateStreaming()")}} car elle est plus efficace et récupère, compile et instancie un module en une seule étape à partir du bytecode et il n'est pas nécessaire de passer par une conversion en {{jsxref("ArrayBuffer")}}.

-
- -

Syntaxe

- -

Première forme : utiliser le bytecode WebAssembly

- -
Promise<ResultObject> WebAssembly.instantiate(bufferSource, importObject);
-
- -

Paramètres

- -
-
bufferSource
-
Un tableau typé ou un {{jsxref("ArrayBuffer")}} qui contient le bytecode du module WebAssembly qu'on souhaite compiler.
-
importObject {{optional_inline}}
-
Un objet qui contient les valeurs à importer dans l'instance qui sera créée. Ces valeurs peuvent être des fonctions ou des objets {{jsxref("WebAssembly.Memory")}}. Il doit y avoir une propriété correspondante au sein du module compilé pour chacun des imports, si ce n'est pas le cas, une exception {{jsxref("WebAssembly.LinkError")}} sera levée.
-
- -

Valeur de retour

- -

Une promesse qui est résoluee en un objet qui contient deux champs :

- - - -

Exceptions

- - - -

Seconde forme : utiliser une instance d'un module

- -
Promise<WebAssembly.Instance> WebAssembly.instantiate(module, importObject);
-
- -

Paramètres

- -
-
module
-
L'objet {{jsxref("WebAssembly.Module")}} qui doit être instancié.
-
importObject {{optional_inline}}
-
Un objet qui contient les valeurs à importer dans l'instance qui sera créée. Ces valeurs peuvent être des fonctions ou des objets {{jsxref("WebAssembly.Memory")}}. Il doit y avoir une propriété correspondante au sein du module compilé pour chacun des imports, si ce n'est pas le cas, une exception {{jsxref("WebAssembly.LinkError")}} sera levée.
-
- -

Valeur de retour

- -

Une promesse qui est résolue en un objet {{jsxref("WebAssembly.Instance")}}.

- -

Exceptions

- - - -

Exemples

- -
-

Note : Dans la plupart des cas, on utilisera plus vraisemblablement {{jsxref("WebAssembly.instantiateStreaming()")}} qui est plus efficace que instantiate().

-
- -

Première forme

- -

Après avoir récupéré le bytecode WebAssembly grâce à fetch(), on compile et on instancie le module grâce à la fonction  {{jsxref("WebAssembly.instantiate()")}} et on importe une fonction JavaScript dans le module lors de cette étape. Ensuite, on invoque une fonction WebAssembly exportée via l'instance.

- -
var importObject = {
-  imports: {
-    imported_func: function(arg) {
-      console.log(arg);
-    }
-  }
-};
-
-fetch('simple.wasm').then(response =>
-  response.arrayBuffer()
-).then(bytes =>
-  WebAssembly.instantiate(bytes, importObject)
-).then(result =>
-  result.instance.exports.exported_func()
-);
- -
-

Note : Voir le fichier index.html sur GitHub (ainsi que la démonstration associée) qui contient un exemple analogue et qui utilise la fonction utilitaire fetchAndInstantiate().

-
- -

Seconde forme

- -

Dans l'exemple qui suit (tiré du fichier index-compile.html sur GitHub et qui dispose d'une démonstration), on compile le bytecode du module chargé simple.wasm grâce à la fonction {{jsxref("WebAssembly.compileStreaming()")}} puis on envoie le résultat à un worker grâce à la méthode {{domxref("Worker.postMessage", "postMessage()")}}.

- -
var worker = new Worker("wasm_worker.js");
-
-WebAssembly.compileStreaming(fetch('simple.wasm'))
-.then(mod =>
-  worker.postMessage(mod)
-);
- -

Dans le worker (cf. wasm_worker.js), on définit un objet d'import qui sera utilisé par le module puis on paramètre un gestionnaire d'évènement afin de recevoir le module depuis le thread principal. Lorsqu'on reçoit le module, on en crée une instance grâce à la méthode {{jsxref("WebAssembly.instantiate()")}} puis on appelle une fonction exportée depuis le module.

- -
var importObject = {
-  imports: {
-    imported_func: function(arg) {
-      console.log(arg);
-    }
-  }
-};
-
-onmessage = function(e) {
-  console.log('module reçu depuis le thread principal');
-  var mod = e.data;
-
-  WebAssembly.instantiate(mod, importObject).then(function(instance) {
-    instance.exports.exported_func();
-  });
-};
- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblyinstantiate', 'instantiate()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.instantiate")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/instantiate/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/instantiate/index.md new file mode 100644 index 0000000000..5ec32f1f87 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/instantiate/index.md @@ -0,0 +1,172 @@ +--- +title: WebAssembly.instantiate() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate +tags: + - API + - JavaScript + - Méthode + - Reference + - WebAssembly +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/instantiate +--- +
{{JSRef}}
+ +

La fonction WebAssembly.instantiate() permet de compiler et d'instancier du code WebAssembly. Cette fonction possède deux formes :

+ + + +
+

Attention : Tant que faire se peut, utiliser la méthode {{jsxref("WebAssembly.instantiateStreaming()")}} car elle est plus efficace et récupère, compile et instancie un module en une seule étape à partir du bytecode et il n'est pas nécessaire de passer par une conversion en {{jsxref("ArrayBuffer")}}.

+
+ +

Syntaxe

+ +

Première forme : utiliser le bytecode WebAssembly

+ +
Promise<ResultObject> WebAssembly.instantiate(bufferSource, importObject);
+
+ +

Paramètres

+ +
+
bufferSource
+
Un tableau typé ou un {{jsxref("ArrayBuffer")}} qui contient le bytecode du module WebAssembly qu'on souhaite compiler.
+
importObject {{optional_inline}}
+
Un objet qui contient les valeurs à importer dans l'instance qui sera créée. Ces valeurs peuvent être des fonctions ou des objets {{jsxref("WebAssembly.Memory")}}. Il doit y avoir une propriété correspondante au sein du module compilé pour chacun des imports, si ce n'est pas le cas, une exception {{jsxref("WebAssembly.LinkError")}} sera levée.
+
+ +

Valeur de retour

+ +

Une promesse qui est résoluee en un objet qui contient deux champs :

+ + + +

Exceptions

+ + + +

Seconde forme : utiliser une instance d'un module

+ +
Promise<WebAssembly.Instance> WebAssembly.instantiate(module, importObject);
+
+ +

Paramètres

+ +
+
module
+
L'objet {{jsxref("WebAssembly.Module")}} qui doit être instancié.
+
importObject {{optional_inline}}
+
Un objet qui contient les valeurs à importer dans l'instance qui sera créée. Ces valeurs peuvent être des fonctions ou des objets {{jsxref("WebAssembly.Memory")}}. Il doit y avoir une propriété correspondante au sein du module compilé pour chacun des imports, si ce n'est pas le cas, une exception {{jsxref("WebAssembly.LinkError")}} sera levée.
+
+ +

Valeur de retour

+ +

Une promesse qui est résolue en un objet {{jsxref("WebAssembly.Instance")}}.

+ +

Exceptions

+ + + +

Exemples

+ +
+

Note : Dans la plupart des cas, on utilisera plus vraisemblablement {{jsxref("WebAssembly.instantiateStreaming()")}} qui est plus efficace que instantiate().

+
+ +

Première forme

+ +

Après avoir récupéré le bytecode WebAssembly grâce à fetch(), on compile et on instancie le module grâce à la fonction  {{jsxref("WebAssembly.instantiate()")}} et on importe une fonction JavaScript dans le module lors de cette étape. Ensuite, on invoque une fonction WebAssembly exportée via l'instance.

+ +
var importObject = {
+  imports: {
+    imported_func: function(arg) {
+      console.log(arg);
+    }
+  }
+};
+
+fetch('simple.wasm').then(response =>
+  response.arrayBuffer()
+).then(bytes =>
+  WebAssembly.instantiate(bytes, importObject)
+).then(result =>
+  result.instance.exports.exported_func()
+);
+ +
+

Note : Voir le fichier index.html sur GitHub (ainsi que la démonstration associée) qui contient un exemple analogue et qui utilise la fonction utilitaire fetchAndInstantiate().

+
+ +

Seconde forme

+ +

Dans l'exemple qui suit (tiré du fichier index-compile.html sur GitHub et qui dispose d'une démonstration), on compile le bytecode du module chargé simple.wasm grâce à la fonction {{jsxref("WebAssembly.compileStreaming()")}} puis on envoie le résultat à un worker grâce à la méthode {{domxref("Worker.postMessage", "postMessage()")}}.

+ +
var worker = new Worker("wasm_worker.js");
+
+WebAssembly.compileStreaming(fetch('simple.wasm'))
+.then(mod =>
+  worker.postMessage(mod)
+);
+ +

Dans le worker (cf. wasm_worker.js), on définit un objet d'import qui sera utilisé par le module puis on paramètre un gestionnaire d'évènement afin de recevoir le module depuis le thread principal. Lorsqu'on reçoit le module, on en crée une instance grâce à la méthode {{jsxref("WebAssembly.instantiate()")}} puis on appelle une fonction exportée depuis le module.

+ +
var importObject = {
+  imports: {
+    imported_func: function(arg) {
+      console.log(arg);
+    }
+  }
+};
+
+onmessage = function(e) {
+  console.log('module reçu depuis le thread principal');
+  var mod = e.data;
+
+  WebAssembly.instantiate(mod, importObject).then(function(instance) {
+    instance.exports.exported_func();
+  });
+};
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblyinstantiate', 'instantiate()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.instantiate")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/instantiatestreaming/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/instantiatestreaming/index.html deleted file mode 100644 index a9cbf1ead2..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/instantiatestreaming/index.html +++ /dev/null @@ -1,87 +0,0 @@ ---- -title: WebAssembly.instantiateStreaming() -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming -tags: - - API - - JavaScript - - Méthode - - Object - - Reference - - WebAssembly -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/instantiateStreaming ---- -
{{JSRef}}
- -

La fonction WebAssembly.instantiateStreaming() permet de compiler et d'instancier un module WebAssembly depuis un flux source. C'est la méthode la plus efficace, et la plus optimisée, permettant de charger du code WebAssembly.

- -

Syntaxe

- -
Promise<ResultObject> WebAssembly.instantiateStreaming(source, importObject);
- -

Paramètres

- -
-
source
-
Un objet {{domxref("Response")}} ou une promesse qui sera tenue avec une valeur {{domxref("Response")}} qui représente la source du module .wasm dont on souhaite récupérer le flux, la compiler puis l'instanciere.
-
importObject {{optional_inline}}
-
Un objet qui contient les valeurs qui doivent être importées dans le nouvel objet Instance résultant. Cela peut être des fonctions ou des objets {{jsxref("WebAssembly.Memory")}}. Il est nécessaire qu'il y ait une propriété correspondante pour chaque import déclaré dans le module compilé, sinon, une exception WebAssembly.LinkError sera levée.
-
- -

Valeur de retour

- -

Un objet Promise dont la valeur de résolution est un objet ResultObject contenant deux champs :

- - - -

Exceptions

- - - -

Examples

- -

Dans l'exemple suivant (également disponible sur GitHub : instantiate-streaming.html et avec le résultat live), on récupère le flux d'un module .wasm depuis une source, on le compile et on l'instancie. La promesse est alors résolue avec un objet ResultObject. La méthode instantiateStreaming()  acceptant une promesse fournissant un objet {{domxref("Response")}}, on peut directement l'appel de {{domxref("WindowOrWorkerGlobalScope.fetch()")}} en argument qui transfèrera la réponse lorsque la promesse résultante sera tenue.

- -
var importObject = { imports: { imported_func: arg => console.log(arg) } };
-
-WebAssembly.instantiateStreaming(fetch('simple.wasm'), importObject)
-.then(obj => obj.instance.exports.exported_func());
- -

Ensuite, on accède au champ instance de l'objet ResultObject afin de pouvoir invoquer une des fonctions exportées.

- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly Embedding', '#webassemblyinstantiatestreaming', 'instantiateStreaming()')}}{{Spec2('WebAssembly Embedding')}}Brouillon de définition initiale.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.instantiateStreaming")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/instantiatestreaming/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/instantiatestreaming/index.md new file mode 100644 index 0000000000..a9cbf1ead2 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/instantiatestreaming/index.md @@ -0,0 +1,87 @@ +--- +title: WebAssembly.instantiateStreaming() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming +tags: + - API + - JavaScript + - Méthode + - Object + - Reference + - WebAssembly +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/instantiateStreaming +--- +
{{JSRef}}
+ +

La fonction WebAssembly.instantiateStreaming() permet de compiler et d'instancier un module WebAssembly depuis un flux source. C'est la méthode la plus efficace, et la plus optimisée, permettant de charger du code WebAssembly.

+ +

Syntaxe

+ +
Promise<ResultObject> WebAssembly.instantiateStreaming(source, importObject);
+ +

Paramètres

+ +
+
source
+
Un objet {{domxref("Response")}} ou une promesse qui sera tenue avec une valeur {{domxref("Response")}} qui représente la source du module .wasm dont on souhaite récupérer le flux, la compiler puis l'instanciere.
+
importObject {{optional_inline}}
+
Un objet qui contient les valeurs qui doivent être importées dans le nouvel objet Instance résultant. Cela peut être des fonctions ou des objets {{jsxref("WebAssembly.Memory")}}. Il est nécessaire qu'il y ait une propriété correspondante pour chaque import déclaré dans le module compilé, sinon, une exception WebAssembly.LinkError sera levée.
+
+ +

Valeur de retour

+ +

Un objet Promise dont la valeur de résolution est un objet ResultObject contenant deux champs :

+ + + +

Exceptions

+ + + +

Examples

+ +

Dans l'exemple suivant (également disponible sur GitHub : instantiate-streaming.html et avec le résultat live), on récupère le flux d'un module .wasm depuis une source, on le compile et on l'instancie. La promesse est alors résolue avec un objet ResultObject. La méthode instantiateStreaming()  acceptant une promesse fournissant un objet {{domxref("Response")}}, on peut directement l'appel de {{domxref("WindowOrWorkerGlobalScope.fetch()")}} en argument qui transfèrera la réponse lorsque la promesse résultante sera tenue.

+ +
var importObject = { imports: { imported_func: arg => console.log(arg) } };
+
+WebAssembly.instantiateStreaming(fetch('simple.wasm'), importObject)
+.then(obj => obj.instance.exports.exported_func());
+ +

Ensuite, on accède au champ instance de l'objet ResultObject afin de pouvoir invoquer une des fonctions exportées.

+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly Embedding', '#webassemblyinstantiatestreaming', 'instantiateStreaming()')}}{{Spec2('WebAssembly Embedding')}}Brouillon de définition initiale.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.instantiateStreaming")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/linkerror/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/linkerror/index.html deleted file mode 100644 index fe881933bb..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/linkerror/index.html +++ /dev/null @@ -1,116 +0,0 @@ ---- -title: WebAssembly.LinkError() -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/LinkError -tags: - - API - - Constructeur - - JavaScript - - LinkError - - Reference - - WebAssembly -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/LinkError -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/LinkError ---- -
{{JSRef}}
- -

Le constructeur WebAssembly.LinkError() permet de créer un nouvel objet WebAssembly LinkError qui indique qu'une erreur s'est produite lors de l'instanciation du module (en plus des trappes provenant de la fonction initiale).

- -

Syntaxe

- -
new WebAssembly.LinkError(message, nomFichier, numeroLigne)
- -

Paramètres

- -
-
message {{optional_inline}}
-
Une description, compréhensible par un humain, de l'erreur qui s'est produite.
-
nomFichier {{optional_inline}}{{non-standard_inline}}
-
Le nom du fichier qui contient le code à l'origine de l'exception.
-
numeroLigne {{optional_inline}}{{non-standard_inline}}
-
Le numéro de ligne dans le fichier contenant le code à l'origine de l'exception.
-
- -

Propriétés

- -

Le constructeur LinkError ne contient pas de propriétés qui lui soient propres. Il hérite cependant de certaines propriétés via sa chaîne de prototypes.

- -
-
WebAssembly.LinkError.prototype.constructor
-
Cette propriété est la fonction qui permet de créer le prototype de l'instance.
-
{{jsxref("Error.prototype.message", "WebAssembly.LinkError.prototype.message")}}
-
Le message d'erreur. Bien qu'ECMA-262 indique que l'objet doive fournir sa propre propriété message, dans SpiderMonkey, celle-ci est héritée depuis {{jsxref("Error.prototype.message")}}.
-
{{jsxref("Error.prototype.name", "WebAssembly.LinkError.prototype.name")}}
-
Le nom de l'erreur. Cette propriété est héritée via {{jsxref("Error")}}.
-
{{jsxref("Error.prototype.fileName", "WebAssembly.LinkError.prototype.fileName")}}
-
Le chemin du fichier qui a entraîné l'erreur. Cette propriété est héritée via {{jsxref("Error")}}.
-
{{jsxref("Error.prototype.lineNumber", "WebAssembly.LinkError.prototype.lineNumber")}}
-
Le numéro de ligne dans le fichier qui a entraîné l'erreur. Cette propriété est héritée via {{jsxref("Error")}}.
-
{{jsxref("Error.prototype.columnNumber", "WebAssembly.LinkError.prototype.columnNumber")}}
-
Le numéro de la colonne dans la ligne du fichier qui a entraîné l'erreur. Cette propriété est héritée via {{jsxref("Error")}}.
-
{{jsxref("Error.prototype.stack", "WebAssembly.LinkError.prototype.stack")}}
-
La pile d'appels à l'origine de l'erreur. Cette propriété est héritée depuis {{jsxref("Error")}}.
-
- -

Méthodes

- -

Le constructeur LinkError ne contient pas de méthodes qui lui soient propres. Il hérite toutefois de méthodes grâce à sa chaîne de prototypes.

- -
-
{{jsxref("Error.prototype.toSource", "WebAssembly.LinkError.prototype.toSource()")}}
-
Cette méthode renvoie un code qui pourrait être évalué et causere la même erreur. Elle est héritée via {{jsxref("Error")}}.
-
{{jsxref("Error.prototype.toString", "WebAssembly.LinkError.prototype.toString()")}}
-
Cette méthode renvoie une chaîne de caractères qui représente l'objet de l'erreur. Elle est héritée via {{jsxref("Error")}}.
-
- -

Exemples

- -

Dans le fragment de code qui suit, on crée un nouvelle instance de LinkError puis on imprime les détails dans la console :

- -
try {
-  throw new WebAssembly.LinkError('Coucou', 'unFichier', 10);
-} catch (e) {
-  console.log(e instanceof LinkError); // true
-  console.log(e.message);                 // "Coucou"
-  console.log(e.name);                    // "LinkError"
-  console.log(e.fileName);                // "unFichier"
-  console.log(e.lineNumber);              // 10
-  console.log(e.columnNumber);            // 0
-  console.log(e.stack);                   // renvoie la pile d'appels
-                                          // à l'origine de l'erreur
-}
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#constructor-properties-of-the-webassembly-object', 'WebAssembly constructors')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard', 'NativeError')}}{{Spec2('ESDraft')}}Définition des types standards NativeError.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.LinkError")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/linkerror/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/linkerror/index.md new file mode 100644 index 0000000000..fe881933bb --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/linkerror/index.md @@ -0,0 +1,116 @@ +--- +title: WebAssembly.LinkError() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/LinkError +tags: + - API + - Constructeur + - JavaScript + - LinkError + - Reference + - WebAssembly +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/LinkError +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/LinkError +--- +
{{JSRef}}
+ +

Le constructeur WebAssembly.LinkError() permet de créer un nouvel objet WebAssembly LinkError qui indique qu'une erreur s'est produite lors de l'instanciation du module (en plus des trappes provenant de la fonction initiale).

+ +

Syntaxe

+ +
new WebAssembly.LinkError(message, nomFichier, numeroLigne)
+ +

Paramètres

+ +
+
message {{optional_inline}}
+
Une description, compréhensible par un humain, de l'erreur qui s'est produite.
+
nomFichier {{optional_inline}}{{non-standard_inline}}
+
Le nom du fichier qui contient le code à l'origine de l'exception.
+
numeroLigne {{optional_inline}}{{non-standard_inline}}
+
Le numéro de ligne dans le fichier contenant le code à l'origine de l'exception.
+
+ +

Propriétés

+ +

Le constructeur LinkError ne contient pas de propriétés qui lui soient propres. Il hérite cependant de certaines propriétés via sa chaîne de prototypes.

+ +
+
WebAssembly.LinkError.prototype.constructor
+
Cette propriété est la fonction qui permet de créer le prototype de l'instance.
+
{{jsxref("Error.prototype.message", "WebAssembly.LinkError.prototype.message")}}
+
Le message d'erreur. Bien qu'ECMA-262 indique que l'objet doive fournir sa propre propriété message, dans SpiderMonkey, celle-ci est héritée depuis {{jsxref("Error.prototype.message")}}.
+
{{jsxref("Error.prototype.name", "WebAssembly.LinkError.prototype.name")}}
+
Le nom de l'erreur. Cette propriété est héritée via {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.fileName", "WebAssembly.LinkError.prototype.fileName")}}
+
Le chemin du fichier qui a entraîné l'erreur. Cette propriété est héritée via {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.lineNumber", "WebAssembly.LinkError.prototype.lineNumber")}}
+
Le numéro de ligne dans le fichier qui a entraîné l'erreur. Cette propriété est héritée via {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.columnNumber", "WebAssembly.LinkError.prototype.columnNumber")}}
+
Le numéro de la colonne dans la ligne du fichier qui a entraîné l'erreur. Cette propriété est héritée via {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.stack", "WebAssembly.LinkError.prototype.stack")}}
+
La pile d'appels à l'origine de l'erreur. Cette propriété est héritée depuis {{jsxref("Error")}}.
+
+ +

Méthodes

+ +

Le constructeur LinkError ne contient pas de méthodes qui lui soient propres. Il hérite toutefois de méthodes grâce à sa chaîne de prototypes.

+ +
+
{{jsxref("Error.prototype.toSource", "WebAssembly.LinkError.prototype.toSource()")}}
+
Cette méthode renvoie un code qui pourrait être évalué et causere la même erreur. Elle est héritée via {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.toString", "WebAssembly.LinkError.prototype.toString()")}}
+
Cette méthode renvoie une chaîne de caractères qui représente l'objet de l'erreur. Elle est héritée via {{jsxref("Error")}}.
+
+ +

Exemples

+ +

Dans le fragment de code qui suit, on crée un nouvelle instance de LinkError puis on imprime les détails dans la console :

+ +
try {
+  throw new WebAssembly.LinkError('Coucou', 'unFichier', 10);
+} catch (e) {
+  console.log(e instanceof LinkError); // true
+  console.log(e.message);                 // "Coucou"
+  console.log(e.name);                    // "LinkError"
+  console.log(e.fileName);                // "unFichier"
+  console.log(e.lineNumber);              // 10
+  console.log(e.columnNumber);            // 0
+  console.log(e.stack);                   // renvoie la pile d'appels
+                                          // à l'origine de l'erreur
+}
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#constructor-properties-of-the-webassembly-object', 'WebAssembly constructors')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard', 'NativeError')}}{{Spec2('ESDraft')}}Définition des types standards NativeError.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.LinkError")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/memory/buffer/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/memory/buffer/index.html deleted file mode 100644 index cd6e68ecec..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/memory/buffer/index.html +++ /dev/null @@ -1,64 +0,0 @@ ---- -title: WebAssembly.Memory.prototype.buffer -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/buffer -tags: - - API - - JavaScript - - Propriété - - Reference - - WebAssembly - - memory -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/buffer -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Memory/buffer ---- -
{{JSRef}}
- -

La propriété buffer, rattachée au prototype de l'objet Memory, renvoie le tampon (buffer) contenu dans l'espace mémoire.

- -
memory.buffer
-
- -

Exemples

- -

Dans l'exemple suivant (cf. le fichier memory.html sur GitHub ainsi que le résultat obtenu), on récupère puis on instancie le bytecode memory.wasm grâce à la méthode {{jsxref("WebAssembly.instantiateStreaming()")}} tout en important la mémoire créée à la ligne précédente. Ensuite, on enregistre certaines valeurs dans cette mémoire puis on exporte une fonction afin de l'utiliser pour additionner certaines valeurs.

- -
WebAssembly.instantiateStreaming(fetch('memory.wasm'), { js: { mem: memory } })
-.then(obj => {
-  var i32 = new Uint32Array(memory.buffer);
-  for (var i = 0; i < 10; i++) {
-    i32[i] = i;
-  }
-  var sum = obj.instance.exports.accumulate(0, 10);
-  console.log(sum);
-});
- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblymemoryprototypebuffer', 'buffer')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.Memory.buffer")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/memory/buffer/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/memory/buffer/index.md new file mode 100644 index 0000000000..cd6e68ecec --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/memory/buffer/index.md @@ -0,0 +1,64 @@ +--- +title: WebAssembly.Memory.prototype.buffer +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/buffer +tags: + - API + - JavaScript + - Propriété + - Reference + - WebAssembly + - memory +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/buffer +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Memory/buffer +--- +
{{JSRef}}
+ +

La propriété buffer, rattachée au prototype de l'objet Memory, renvoie le tampon (buffer) contenu dans l'espace mémoire.

+ +
memory.buffer
+
+ +

Exemples

+ +

Dans l'exemple suivant (cf. le fichier memory.html sur GitHub ainsi que le résultat obtenu), on récupère puis on instancie le bytecode memory.wasm grâce à la méthode {{jsxref("WebAssembly.instantiateStreaming()")}} tout en important la mémoire créée à la ligne précédente. Ensuite, on enregistre certaines valeurs dans cette mémoire puis on exporte une fonction afin de l'utiliser pour additionner certaines valeurs.

+ +
WebAssembly.instantiateStreaming(fetch('memory.wasm'), { js: { mem: memory } })
+.then(obj => {
+  var i32 = new Uint32Array(memory.buffer);
+  for (var i = 0; i < 10; i++) {
+    i32[i] = i;
+  }
+  var sum = obj.instance.exports.accumulate(0, 10);
+  console.log(sum);
+});
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblymemoryprototypebuffer', 'buffer')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.Memory.buffer")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/memory/grow/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/memory/grow/index.html deleted file mode 100644 index 7d4426fc4a..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/memory/grow/index.html +++ /dev/null @@ -1,78 +0,0 @@ ---- -title: WebAssembly.Memory.prototype.grow() -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/grow -tags: - - API - - JavaScript - - Méthode - - Reference - - WebAssembly - - memory -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/grow -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Memory/grow ---- -
{{JSRef}}
- -

La méthode grow(), rattachée au prototype de l'objet Memory, permet d'augmenter la taille de l'espace mémoire correspondant d'un nombre de pages WebAssembly.

- -

Syntaxe

- -
memory.grow(nombre);
-
- -

Paramètres

- -
-
nombre
-
Le nombre de pages WebAssembly duquel on veut augmenter l'espace mémoire correspondant à l'objet courant (une page mémoire WebAssembly correspond à 64 Ko).
-
- -

Valeur de retour

- -

La taille de l'espace mémoire avant l'extension, exprimée en nombre de pages WebAssembly.

- -

Exemples

- -

Dans le code qui suit, on crée une instance de Memory qui mesure initialement 1 page (soit 64 Ko) et dont la taille maximale est de 10 pages (soit 6,4 Mo).

- -
var memory = new WebAssembly.Memory({initial:10, maximum:100});
- -

Ensuite, on augmente la taille de l'espace mémoire d'une page grâce à la méthode :

- -
const bytesPerPage = 64 * 1024;
-console.log(memory.buffer.byteLength / bytesPerPage);  // "1"
-console.log(memory.grow(1));                           // "1"
-console.log(memory.buffer.byteLength / bytesPerPage);  // "2"
- -

On voit ici que la valeur de grow() indique l'espace utilisé avant l'agrandissement de la mémoire.

- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblymemoryprototypegrow', 'grow()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.Memory.grow")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/memory/grow/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/memory/grow/index.md new file mode 100644 index 0000000000..7d4426fc4a --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/memory/grow/index.md @@ -0,0 +1,78 @@ +--- +title: WebAssembly.Memory.prototype.grow() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/grow +tags: + - API + - JavaScript + - Méthode + - Reference + - WebAssembly + - memory +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/grow +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Memory/grow +--- +
{{JSRef}}
+ +

La méthode grow(), rattachée au prototype de l'objet Memory, permet d'augmenter la taille de l'espace mémoire correspondant d'un nombre de pages WebAssembly.

+ +

Syntaxe

+ +
memory.grow(nombre);
+
+ +

Paramètres

+ +
+
nombre
+
Le nombre de pages WebAssembly duquel on veut augmenter l'espace mémoire correspondant à l'objet courant (une page mémoire WebAssembly correspond à 64 Ko).
+
+ +

Valeur de retour

+ +

La taille de l'espace mémoire avant l'extension, exprimée en nombre de pages WebAssembly.

+ +

Exemples

+ +

Dans le code qui suit, on crée une instance de Memory qui mesure initialement 1 page (soit 64 Ko) et dont la taille maximale est de 10 pages (soit 6,4 Mo).

+ +
var memory = new WebAssembly.Memory({initial:10, maximum:100});
+ +

Ensuite, on augmente la taille de l'espace mémoire d'une page grâce à la méthode :

+ +
const bytesPerPage = 64 * 1024;
+console.log(memory.buffer.byteLength / bytesPerPage);  // "1"
+console.log(memory.grow(1));                           // "1"
+console.log(memory.buffer.byteLength / bytesPerPage);  // "2"
+ +

On voit ici que la valeur de grow() indique l'espace utilisé avant l'agrandissement de la mémoire.

+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblymemoryprototypegrow', 'grow()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.Memory.grow")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/memory/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/memory/index.html deleted file mode 100644 index 5c5d36d7cd..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/memory/index.html +++ /dev/null @@ -1,120 +0,0 @@ ---- -title: WebAssembly.Memory() -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory -tags: - - API - - Constructeur - - JavaScript - - Object - - Reference - - WebAssembly -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Memory ---- -
{{JSRef}}
- -

Le constructeur WebAssembly.Memory() crée un nouvel objet Memory dont la propriété {{jsxref("WebAssembly/Memory/buffer","buffer")}} est un {{jsxref("ArrayBuffer")}} redimensionnable qui contient les octets de mémoire bruts accessibles par une instance WebAssembly.

- -

Un espace mémoire créé depuis du code JavaScript ou depuis du code WebAssembly sera accessible et modifiable (mutable) depuis JavaScript et depuis WebAssembly.

- -

Syntaxe

- -
var maMemoire = new WebAssembly.Memory(descripteurMemoire);
- -

Paramètres

- -
-
descripteurMemoire
-
Un objet qui contient les propriétés suivantes : -
-
initial
-
La taille initiale de cet espace mémoire WebAssembly, exprimée en nombre de pages WebAssembly.
-
maximum {{optional_inline}}
-
La taille maximale autorisée pour cet espace mémoire WebAssembly, exprimée en nombre de pages WebAssembly. Lorsque ce paramètre est utilisé, il est fournit comme indication au moteur pour que celui-ci réserve l'espace mémoire correspondant. Toutefois, le moteur peut choisir d'ignorer cette indication. Dans la plupart des cas, il n'est pas nécessaire d'indiquer un maximum pour les modules WebAssembly.
-
-
-
- -
-

Note : Une page mémoire WebAssembly correspond à une taille fixe de 65 536 octets, soit environ 64 Ko.

-
- -

Exceptions

- - - -

Méthodes du constructeur Memory

- -

Aucune.

- -

Instances de Memory

- -

Toutes les instances de Memory héritent des propriétés du prototype du constructeur Memory() qui peut être utilisé afin de modifier le comportement de l'ensemble des instances de Memory.

- -

Propriétés

- -
-
Memory.prototype.constructor
-
Renvoie la fonction qui a créé l'instance de l'objet. Par défaut, c'est le constructeur {{jsxref("WebAssembly.Memory()")}}.
-
{{jsxref("WebAssembly/Memory/buffer","Memory.prototype.buffer")}}
-
Une propriété d'accesseur qui renvoie le tampon contenu dans l'espace mémoire.
-
- -

Méthodes

- -
-
{{jsxref("WebAssembly/Memory/grow","Memory.prototype.grow()")}}
-
Cette méthode permet d'augmenter la taille de l'espace mémoire d'un nombre de pages donné (dont chacune mesure 64 Ko).
-
- -

Exemples

- -

Il existe deux façons de créer un objet WebAssembly.Memory. La première consiste à le créer explicitement en JavaScript. Avec l'instruction qui suit, on crée un espace mémoire avec une taille initiale de 10 pages (soit 640 Ko) et une taille maximale de 100 pages (soit 6,4 Mo).

- -
var memoire = new WebAssembly.Memory({initial:10, maximum:100});
- -

La seconde méthode permettant d'obtenir un objet WebAssembly.Memory est de l'exporter depuis un module WebAssembly. Dans l'exemple suivant (cf. le fichier memory.html sur GitHub ainsi que le résultat obtenu) on récupère et on instancie le bytecode memory.wasm grâce à la méthode {{jsxref("WebAssembly.instantiateStreaming()")}} tout en important la mémoire créée à la ligne précédente. Ensuite, on enregistre des valeurs au sein de cette mémoire puis on exporte une fonction qu'on utilise pour additionner certaines valeurs.

- -
WebAssembly.instantiateStreaming(fetch('memory.wasm'), { js: { mem: memory } })
-.then(obj => {
-  var i32 = new Uint32Array(memory.buffer);
-  for (var i = 0; i < 10; i++) {
-    i32[i] = i;
-  }
-  var sum = obj.instance.exports.accumulate(0, 10);
-  console.log(sum);
-});
- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblymemory-objects', 'Memory')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.Memory")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/memory/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/memory/index.md new file mode 100644 index 0000000000..5c5d36d7cd --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/memory/index.md @@ -0,0 +1,120 @@ +--- +title: WebAssembly.Memory() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory +tags: + - API + - Constructeur + - JavaScript + - Object + - Reference + - WebAssembly +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Memory +--- +
{{JSRef}}
+ +

Le constructeur WebAssembly.Memory() crée un nouvel objet Memory dont la propriété {{jsxref("WebAssembly/Memory/buffer","buffer")}} est un {{jsxref("ArrayBuffer")}} redimensionnable qui contient les octets de mémoire bruts accessibles par une instance WebAssembly.

+ +

Un espace mémoire créé depuis du code JavaScript ou depuis du code WebAssembly sera accessible et modifiable (mutable) depuis JavaScript et depuis WebAssembly.

+ +

Syntaxe

+ +
var maMemoire = new WebAssembly.Memory(descripteurMemoire);
+ +

Paramètres

+ +
+
descripteurMemoire
+
Un objet qui contient les propriétés suivantes : +
+
initial
+
La taille initiale de cet espace mémoire WebAssembly, exprimée en nombre de pages WebAssembly.
+
maximum {{optional_inline}}
+
La taille maximale autorisée pour cet espace mémoire WebAssembly, exprimée en nombre de pages WebAssembly. Lorsque ce paramètre est utilisé, il est fournit comme indication au moteur pour que celui-ci réserve l'espace mémoire correspondant. Toutefois, le moteur peut choisir d'ignorer cette indication. Dans la plupart des cas, il n'est pas nécessaire d'indiquer un maximum pour les modules WebAssembly.
+
+
+
+ +
+

Note : Une page mémoire WebAssembly correspond à une taille fixe de 65 536 octets, soit environ 64 Ko.

+
+ +

Exceptions

+ + + +

Méthodes du constructeur Memory

+ +

Aucune.

+ +

Instances de Memory

+ +

Toutes les instances de Memory héritent des propriétés du prototype du constructeur Memory() qui peut être utilisé afin de modifier le comportement de l'ensemble des instances de Memory.

+ +

Propriétés

+ +
+
Memory.prototype.constructor
+
Renvoie la fonction qui a créé l'instance de l'objet. Par défaut, c'est le constructeur {{jsxref("WebAssembly.Memory()")}}.
+
{{jsxref("WebAssembly/Memory/buffer","Memory.prototype.buffer")}}
+
Une propriété d'accesseur qui renvoie le tampon contenu dans l'espace mémoire.
+
+ +

Méthodes

+ +
+
{{jsxref("WebAssembly/Memory/grow","Memory.prototype.grow()")}}
+
Cette méthode permet d'augmenter la taille de l'espace mémoire d'un nombre de pages donné (dont chacune mesure 64 Ko).
+
+ +

Exemples

+ +

Il existe deux façons de créer un objet WebAssembly.Memory. La première consiste à le créer explicitement en JavaScript. Avec l'instruction qui suit, on crée un espace mémoire avec une taille initiale de 10 pages (soit 640 Ko) et une taille maximale de 100 pages (soit 6,4 Mo).

+ +
var memoire = new WebAssembly.Memory({initial:10, maximum:100});
+ +

La seconde méthode permettant d'obtenir un objet WebAssembly.Memory est de l'exporter depuis un module WebAssembly. Dans l'exemple suivant (cf. le fichier memory.html sur GitHub ainsi que le résultat obtenu) on récupère et on instancie le bytecode memory.wasm grâce à la méthode {{jsxref("WebAssembly.instantiateStreaming()")}} tout en important la mémoire créée à la ligne précédente. Ensuite, on enregistre des valeurs au sein de cette mémoire puis on exporte une fonction qu'on utilise pour additionner certaines valeurs.

+ +
WebAssembly.instantiateStreaming(fetch('memory.wasm'), { js: { mem: memory } })
+.then(obj => {
+  var i32 = new Uint32Array(memory.buffer);
+  for (var i = 0; i < 10; i++) {
+    i32[i] = i;
+  }
+  var sum = obj.instance.exports.accumulate(0, 10);
+  console.log(sum);
+});
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblymemory-objects', 'Memory')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.Memory")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/module/customsections/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/module/customsections/index.html deleted file mode 100644 index dd76bbe66d..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/module/customsections/index.html +++ /dev/null @@ -1,95 +0,0 @@ ---- -title: WebAssembly.Module.customSections() -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/customSections -tags: - - API - - Constructeur - - JavaScript - - Module - - Méthode - - Object - - Reference - - WebAssembly -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/customSections -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Module/customSections ---- -
{{JSRef}}
- -

La méthode WebAssembly.customSections() renvoie un tableau qui contient les sections personnalisées (custom sections) disponibles dans un module WebAssembly et qui ont un nom donné.

- -

Syntaxe

- -
var custSec = WebAssembly.Module.customSections(module, nomSection);
- -

Paramètres

- -
-
module
-
L'objet {{jsxref("WebAssembly.Module")}} pour lequel on veut obtenir les sections personnalisées.
-
nomSection
-
Le nom de la section personnalisée qu'on souhaite obtenir.
-
- -

Valeur de retour

- -

Un tableau contenant des {{domxref("ArrayBuffer")}} dont chacun contient les données d'une section personnalisée du module qui correspond à nomSection.

- -

Exceptions

- -

Si le module passé en argument n'est pas une instance de {{jsxref("WebAssembly.Module")}}, la méthode lèvera une exception {{jsxref("TypeError")}}.

- -

Les sections personnalisées

- -

Un module wasm contient une série de sections. La plupart de ces sections sont spécifiées et validées par la spécification WebAssembly mais les modules peuvent contenir certaines sections « personnalisées » (custom sections) qui sont ignorées lors de la phase de validation. Pour plus d'informations, consulter l'article sur les structures de haut niveau qui détaille la structure des sections et les différences entre les sections normales (« connues ») et les sections personnalisées.

- -

Cela permet aux développeurs d'inclure des données personnalisées dans un module WebAssembly pour d'autres desseins. Par exemple, on peut avoir une section personnalisée name, qui permet aux développeurs de fournir des noms pour les fonctions et les variables locales du module (à la façon des « symboles » utilisé pour les programmes compilés).

- -

Le format WebAssembly ne possède actuellement aucune syntaxe pour ajouter une section personnalisée. Il est toutefois possible d'ajouter une section nommée au module wasm pendant la conversion du texte vers .wasm. La commande wast2wasm, disponible avec l'outil wabt, possède une option --debug-names qui permet de créer un module .wasm avec une section personnalisée name :

- -
wast2wasm simple-name-section.was -o simple-name-section.wasm --debug-names
- -

Exemples

- -

Dans l'exemple qui suit (tiré de ce fichier source et de cette démonstration), on compile et on instancie le bytecode simple-name-section.wasm et on importe une fonction JavaScript dans le module lors de cette étape. Ensuite, on exporte une fonction depuis le module grâce à Instance.exports.

- -

On faut aussi une vérification sur WebAssembly.Module.customSections pour vérifier si celle-ci contient une section personnalisée "name" dont on vérifie si la longueur est supérieure à 0. Ce module contenant une section name, les appels à console.log() sont exécutés et montrent que le tableau renvoyé par la méthode contient des objets {{domxref("ArrayBuffer")}}.

- -
WebAssembly.compileStreaming(fetch('simple-name-section.wasm'))
-.then(function(mod) {
-  var nameSections = WebAssembly.Module.customSections(mod, "name");
-  if (nameSections.length != 0) {
-    console.log("Le module contient une section nommée");
-    console.log(nameSections[0]);
-  };
-});
- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblymodulecustomsections', 'customSections()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.Module.customSections")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/module/customsections/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/module/customsections/index.md new file mode 100644 index 0000000000..dd76bbe66d --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/module/customsections/index.md @@ -0,0 +1,95 @@ +--- +title: WebAssembly.Module.customSections() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/customSections +tags: + - API + - Constructeur + - JavaScript + - Module + - Méthode + - Object + - Reference + - WebAssembly +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/customSections +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Module/customSections +--- +
{{JSRef}}
+ +

La méthode WebAssembly.customSections() renvoie un tableau qui contient les sections personnalisées (custom sections) disponibles dans un module WebAssembly et qui ont un nom donné.

+ +

Syntaxe

+ +
var custSec = WebAssembly.Module.customSections(module, nomSection);
+ +

Paramètres

+ +
+
module
+
L'objet {{jsxref("WebAssembly.Module")}} pour lequel on veut obtenir les sections personnalisées.
+
nomSection
+
Le nom de la section personnalisée qu'on souhaite obtenir.
+
+ +

Valeur de retour

+ +

Un tableau contenant des {{domxref("ArrayBuffer")}} dont chacun contient les données d'une section personnalisée du module qui correspond à nomSection.

+ +

Exceptions

+ +

Si le module passé en argument n'est pas une instance de {{jsxref("WebAssembly.Module")}}, la méthode lèvera une exception {{jsxref("TypeError")}}.

+ +

Les sections personnalisées

+ +

Un module wasm contient une série de sections. La plupart de ces sections sont spécifiées et validées par la spécification WebAssembly mais les modules peuvent contenir certaines sections « personnalisées » (custom sections) qui sont ignorées lors de la phase de validation. Pour plus d'informations, consulter l'article sur les structures de haut niveau qui détaille la structure des sections et les différences entre les sections normales (« connues ») et les sections personnalisées.

+ +

Cela permet aux développeurs d'inclure des données personnalisées dans un module WebAssembly pour d'autres desseins. Par exemple, on peut avoir une section personnalisée name, qui permet aux développeurs de fournir des noms pour les fonctions et les variables locales du module (à la façon des « symboles » utilisé pour les programmes compilés).

+ +

Le format WebAssembly ne possède actuellement aucune syntaxe pour ajouter une section personnalisée. Il est toutefois possible d'ajouter une section nommée au module wasm pendant la conversion du texte vers .wasm. La commande wast2wasm, disponible avec l'outil wabt, possède une option --debug-names qui permet de créer un module .wasm avec une section personnalisée name :

+ +
wast2wasm simple-name-section.was -o simple-name-section.wasm --debug-names
+ +

Exemples

+ +

Dans l'exemple qui suit (tiré de ce fichier source et de cette démonstration), on compile et on instancie le bytecode simple-name-section.wasm et on importe une fonction JavaScript dans le module lors de cette étape. Ensuite, on exporte une fonction depuis le module grâce à Instance.exports.

+ +

On faut aussi une vérification sur WebAssembly.Module.customSections pour vérifier si celle-ci contient une section personnalisée "name" dont on vérifie si la longueur est supérieure à 0. Ce module contenant une section name, les appels à console.log() sont exécutés et montrent que le tableau renvoyé par la méthode contient des objets {{domxref("ArrayBuffer")}}.

+ +
WebAssembly.compileStreaming(fetch('simple-name-section.wasm'))
+.then(function(mod) {
+  var nameSections = WebAssembly.Module.customSections(mod, "name");
+  if (nameSections.length != 0) {
+    console.log("Le module contient une section nommée");
+    console.log(nameSections[0]);
+  };
+});
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblymodulecustomsections', 'customSections()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.Module.customSections")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/module/exports/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/module/exports/index.html deleted file mode 100644 index d16223a07c..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/module/exports/index.html +++ /dev/null @@ -1,105 +0,0 @@ ---- -title: WebAssembly.Module.exports() -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/exports -tags: - - API - - Constructeur - - JavaScript - - Module - - Méthode - - Object - - Reference - - WebAssembly -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/exports -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Module/exports ---- -
{{JSRef}}
- -

La fonction WebAssembly.Module.exports() renvoie un tableau qui contient les descriptions des exports déclarés pour un module donné.

- -

Syntaxe

- -
var exports = WebAssembly.Module.exports(module);
- -

Paramètres

- -
-
module
-
Un objet {{jsxref("WebAssembly.Module")}}.
-
- -

Valeur de retour

- -

Un tableau qui contient des objets représentants les fonctions exportés du module passé en argument.

- -

Exceptions

- -

Si l'argument n'est pas une instance de {{jsxref("WebAssembly.Module")}}, une exception {{jsxref("TypeError")}} sera levée.

- -

Exemples

- -

Dans l'exemple suivant (basé sur le fichier index-compile.html disponible sur GitHub avec la démonstration correspondante), on compile le bytecode simple.wasm grâce à la fonction {{jsxref("WebAssembly.compileStreaming()")}} puis on envoie le résultat à un worker grâce à la méthode postMessage().

- -
var worker = new Worker("wasm_worker.js");
-
-WebAssembly.compileStreaming(fetch("simple.wasm"))
-.then(mod =>
-  worker.postMessage(mod)
-);
- -

Dans le worker (cf. wasm_worker.js), on définit un objet d'import pour le module puis on paramètre un gestionnaire d'évènement afin de recevoir le module depuis le thread principal. Lorsqu'on reçoit le module, on en crée une instance via la méthode {{jsxref("WebAssembly.Instantiate()")}} puis on appelle une fonction exportée et enfin, on affiche les informations relatives aux exports disponibles grâce à WebAssembly.Module.exports.

- -
var importObject = {
-  imports: {
-    imported_func: function(arg) {
-      console.log(arg);
-    }
-  }
-};
-
-onmessage = function(e) {
-  console.log('module reçu du thread principal');
-  var mod = e.data;
-
-  WebAssembly.instantiate(mod, importObject).then(function(instance) {
-    instance.exports.exported_func();
-  });
-
-  var exports = WebAssembly.Module.exports(mod);
-  console.log(exports[0]);
-};
- -

La valeur exports[0] ressemblera alors à :

- -
{ name: "exported_func", kind: "function" }
- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblymoduleexports', 'exports()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.Module.exports")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/module/exports/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/module/exports/index.md new file mode 100644 index 0000000000..d16223a07c --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/module/exports/index.md @@ -0,0 +1,105 @@ +--- +title: WebAssembly.Module.exports() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/exports +tags: + - API + - Constructeur + - JavaScript + - Module + - Méthode + - Object + - Reference + - WebAssembly +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/exports +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Module/exports +--- +
{{JSRef}}
+ +

La fonction WebAssembly.Module.exports() renvoie un tableau qui contient les descriptions des exports déclarés pour un module donné.

+ +

Syntaxe

+ +
var exports = WebAssembly.Module.exports(module);
+ +

Paramètres

+ +
+
module
+
Un objet {{jsxref("WebAssembly.Module")}}.
+
+ +

Valeur de retour

+ +

Un tableau qui contient des objets représentants les fonctions exportés du module passé en argument.

+ +

Exceptions

+ +

Si l'argument n'est pas une instance de {{jsxref("WebAssembly.Module")}}, une exception {{jsxref("TypeError")}} sera levée.

+ +

Exemples

+ +

Dans l'exemple suivant (basé sur le fichier index-compile.html disponible sur GitHub avec la démonstration correspondante), on compile le bytecode simple.wasm grâce à la fonction {{jsxref("WebAssembly.compileStreaming()")}} puis on envoie le résultat à un worker grâce à la méthode postMessage().

+ +
var worker = new Worker("wasm_worker.js");
+
+WebAssembly.compileStreaming(fetch("simple.wasm"))
+.then(mod =>
+  worker.postMessage(mod)
+);
+ +

Dans le worker (cf. wasm_worker.js), on définit un objet d'import pour le module puis on paramètre un gestionnaire d'évènement afin de recevoir le module depuis le thread principal. Lorsqu'on reçoit le module, on en crée une instance via la méthode {{jsxref("WebAssembly.Instantiate()")}} puis on appelle une fonction exportée et enfin, on affiche les informations relatives aux exports disponibles grâce à WebAssembly.Module.exports.

+ +
var importObject = {
+  imports: {
+    imported_func: function(arg) {
+      console.log(arg);
+    }
+  }
+};
+
+onmessage = function(e) {
+  console.log('module reçu du thread principal');
+  var mod = e.data;
+
+  WebAssembly.instantiate(mod, importObject).then(function(instance) {
+    instance.exports.exported_func();
+  });
+
+  var exports = WebAssembly.Module.exports(mod);
+  console.log(exports[0]);
+};
+ +

La valeur exports[0] ressemblera alors à :

+ +
{ name: "exported_func", kind: "function" }
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblymoduleexports', 'exports()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.Module.exports")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/module/imports/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/module/imports/index.html deleted file mode 100644 index ac039a3fc7..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/module/imports/index.html +++ /dev/null @@ -1,81 +0,0 @@ ---- -title: WebAssembly.Module.imports() -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/imports -tags: - - API - - JavaScript - - Module - - Méthode - - Reference - - WebAssembly -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/imports -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Module/imports ---- -
{{JSRef}}
- -

La méthode WebAssembly.imports() renvoie un tableau qui contient les références des fonctions importées qui sont disponibles dans un module WebAssembly donné.

- -

Syntaxe

- -
var arrImport = WebAssembly.Module.imports(module);
- -

Paramètres

- -
-
module
-
Une instance de {{jsxref("WebAssembly.Module")}}.
-
- -

Valeur de retour

- -

Un tableau qui contient des objets représentant les fonctions importées du module passé en argument.

- -

Exceptions

- -

Si module n'est pas une instance de {{jsxref("WebAssembly.Module")}}, une exception {{jsxref("TypeError")}} sera levée.

- -

Exemples

- -

Dans l'exemple qui suit, on compile le module simple.wasm puis on parcourt ses imports (cf. aussi le code sur GitHub et l'exemple live)

- -
WebAssembly.compileStreaming(fetch('simple.wasm'))
-.then(function(mod) {
-  var imports = WebAssembly.Module.imports(mod);
-  console.log(imports[0]);
-});
-
- -

Le résultat affiché dans la console ressemble alors à :

- -
{ module: "imports", name: "imported_func", kind: "function" }
- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblymoduleimports', 'imports()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initial pour WebAssembly.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.Module.imports")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/module/imports/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/module/imports/index.md new file mode 100644 index 0000000000..ac039a3fc7 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/module/imports/index.md @@ -0,0 +1,81 @@ +--- +title: WebAssembly.Module.imports() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/imports +tags: + - API + - JavaScript + - Module + - Méthode + - Reference + - WebAssembly +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/imports +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Module/imports +--- +
{{JSRef}}
+ +

La méthode WebAssembly.imports() renvoie un tableau qui contient les références des fonctions importées qui sont disponibles dans un module WebAssembly donné.

+ +

Syntaxe

+ +
var arrImport = WebAssembly.Module.imports(module);
+ +

Paramètres

+ +
+
module
+
Une instance de {{jsxref("WebAssembly.Module")}}.
+
+ +

Valeur de retour

+ +

Un tableau qui contient des objets représentant les fonctions importées du module passé en argument.

+ +

Exceptions

+ +

Si module n'est pas une instance de {{jsxref("WebAssembly.Module")}}, une exception {{jsxref("TypeError")}} sera levée.

+ +

Exemples

+ +

Dans l'exemple qui suit, on compile le module simple.wasm puis on parcourt ses imports (cf. aussi le code sur GitHub et l'exemple live)

+ +
WebAssembly.compileStreaming(fetch('simple.wasm'))
+.then(function(mod) {
+  var imports = WebAssembly.Module.imports(mod);
+  console.log(imports[0]);
+});
+
+ +

Le résultat affiché dans la console ressemble alors à :

+ +
{ module: "imports", name: "imported_func", kind: "function" }
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblymoduleimports', 'imports()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initial pour WebAssembly.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.Module.imports")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/module/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/module/index.html deleted file mode 100644 index cd6b46e8a9..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/module/index.html +++ /dev/null @@ -1,86 +0,0 @@ ---- -title: WebAssembly.Module() -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module -tags: - - Constructeur - - JavaScript - - Module - - Reference - - WebAssembly -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Module ---- -
{{JSRef}}
- -

Un objet WebAssembly.Module contient du code WebAssembly, sans état et qui a déjà été compilé par le navigateur. Ce code peut être partagé avec des web worker et être instancié à plusieurs reprises. Pour instancier le module, on pourra appeler la forme secondaire de {{jsxref("WebAssembly.instantiate()")}}.

- -

Le constructeur WebAssembly.Module() peut être appelé de façon synchrone pour compiler du code WebAssembly. Toutefois, on utilisera généralement la fonction asynchrone {{jsxref("WebAssembly.compile()")}} qui permet de compiler du bytecode.

- -

Syntaxe

- -
-

Attention : La compilation de modules volumineux peut être consommatrice de ressources et de temps. Le constructeur Module() doit uniqument être utilisé lorsqu'il faut absolument avoir une compilation  synchrone. Pour tous les autres cas de figures, on privilégiera la méthode asynchrone {{jsxref("WebAssembly.compileStreaming()")}}.

-
- -
var monModule = new WebAssembly.Module(bufferSource);
- -

Paramètres

- -
-
bufferSource
-
Un tableau typé ou un {{jsxref("ArrayBuffer")}} qui contient le bytecode du module WebAssembly qu'on souhaite compiler.
-
- -

Méthodes du constructeur Module

- -
-
{{jsxref("Objets_globaux/WebAssembly/Module/customSections", "WebAssembly.Module.customSections()")}}
-
Pour un module donné et une chaîne de caractères donnée, cette méthode renvoie une copie des sections personnalisées (custom sections) du module qui ont le nom correspondant à la chaîne.
-
{{jsxref("Objets_globaux/WebAssembly/Module/exports", "WebAssembly.Module.exports()")}}
-
Pour un module donné, cette méthode renvoie un tableau dont les éléments sont des descriptions des exports déclarés.
-
{{jsxref("Objets_globaux/WebAssembly/Module/imports", "WebAssembly.Module.imports()")}}
-
Pour un module donné, cette méthode renvoie un tableau dont les éléments sont des descriptions des imports déclarés.
-
- -

Instances de Module

- -

Toutes les instances de Module héritent du prototype du constructeur Module(), celui-ci peut être modifié afin de moifier le comportement de l'ensemble des instances de Module.

- -

Propriétés

- -

{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/WebAssembly/Module/prototype', 'Propriétés')}}

- -

Méthodes

- -

Les instances de Module ne disposent pas de méthodes en propre.

- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblymodule-objects', 'WebAssembly.Module()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.Module")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/module/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/module/index.md new file mode 100644 index 0000000000..cd6b46e8a9 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/module/index.md @@ -0,0 +1,86 @@ +--- +title: WebAssembly.Module() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module +tags: + - Constructeur + - JavaScript + - Module + - Reference + - WebAssembly +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Module +--- +
{{JSRef}}
+ +

Un objet WebAssembly.Module contient du code WebAssembly, sans état et qui a déjà été compilé par le navigateur. Ce code peut être partagé avec des web worker et être instancié à plusieurs reprises. Pour instancier le module, on pourra appeler la forme secondaire de {{jsxref("WebAssembly.instantiate()")}}.

+ +

Le constructeur WebAssembly.Module() peut être appelé de façon synchrone pour compiler du code WebAssembly. Toutefois, on utilisera généralement la fonction asynchrone {{jsxref("WebAssembly.compile()")}} qui permet de compiler du bytecode.

+ +

Syntaxe

+ +
+

Attention : La compilation de modules volumineux peut être consommatrice de ressources et de temps. Le constructeur Module() doit uniqument être utilisé lorsqu'il faut absolument avoir une compilation  synchrone. Pour tous les autres cas de figures, on privilégiera la méthode asynchrone {{jsxref("WebAssembly.compileStreaming()")}}.

+
+ +
var monModule = new WebAssembly.Module(bufferSource);
+ +

Paramètres

+ +
+
bufferSource
+
Un tableau typé ou un {{jsxref("ArrayBuffer")}} qui contient le bytecode du module WebAssembly qu'on souhaite compiler.
+
+ +

Méthodes du constructeur Module

+ +
+
{{jsxref("Objets_globaux/WebAssembly/Module/customSections", "WebAssembly.Module.customSections()")}}
+
Pour un module donné et une chaîne de caractères donnée, cette méthode renvoie une copie des sections personnalisées (custom sections) du module qui ont le nom correspondant à la chaîne.
+
{{jsxref("Objets_globaux/WebAssembly/Module/exports", "WebAssembly.Module.exports()")}}
+
Pour un module donné, cette méthode renvoie un tableau dont les éléments sont des descriptions des exports déclarés.
+
{{jsxref("Objets_globaux/WebAssembly/Module/imports", "WebAssembly.Module.imports()")}}
+
Pour un module donné, cette méthode renvoie un tableau dont les éléments sont des descriptions des imports déclarés.
+
+ +

Instances de Module

+ +

Toutes les instances de Module héritent du prototype du constructeur Module(), celui-ci peut être modifié afin de moifier le comportement de l'ensemble des instances de Module.

+ +

Propriétés

+ +

{{page('/fr/docs/Web/JavaScript/Reference/Objets_globaux/WebAssembly/Module/prototype', 'Propriétés')}}

+ +

Méthodes

+ +

Les instances de Module ne disposent pas de méthodes en propre.

+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblymodule-objects', 'WebAssembly.Module()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.Module")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/runtimeerror/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/runtimeerror/index.html deleted file mode 100644 index fe5a6d50e8..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/runtimeerror/index.html +++ /dev/null @@ -1,116 +0,0 @@ ---- -title: WebAssembly.RuntimeError() -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/RuntimeError -tags: - - API - - Constructeur - - JavaScript - - Reference - - RuntimeError - - WebAssembly -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/RuntimeError -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/RuntimeError ---- -
{{JSRef}}
- -

Le constructeur WebAssembly.RuntimeError() permet de créer un nouvel objet WebAssembly RuntimeError. C'est ce type d'exception qui est déclenchée lorsque WebAssembly définit une trappe.

- -

Syntaxe

- -
new WebAssembly.RuntimeError(message, nomFichier, numeroLigne)
- -

Paramètres

- -
-
message {{optional_inline}}
-
Une description, compréhensible par un humain, de l'erreur qui s'est produite.
-
fileName {{optional_inline}}{{non-standard_inline}}
-
Le nom du fichier qui contient le code à l'origine de l'exception.
-
lineNumber {{optional_inline}}{{non-standard_inline}}
-
Le numéro de la ligne de code à l'origine de l'exception.
-
- -

Propriétés

- -

Le constructeur RuntimeError ne contient aucune propriété qui lui soit propre. En revanche, il hérite de certaines propriétés grâce à sa chaîne de prototypes.

- -
-
WebAssembly.RuntimeError.prototype.constructor
-
La fonction qui a créé le prototype de l'instance.
-
{{jsxref("Error.prototype.message", "WebAssembly.RuntimeError.prototype.message")}}
-
Le message qui décrit l'erreur. Bien qu'ECMA-262 indique que chaque instance doit fournir sa propre propriété message, dans SpiderMonkey, elle est héritée depuis {{jsxref("Error.prototype.message")}}.
-
{{jsxref("Error.prototype.name", "WebAssembly.RuntimeError.prototype.name")}}
-
Le nom de l'erreur. Cette propriété est héritée depuis {{jsxref("Error")}}.
-
{{jsxref("Error.prototype.fileName", "WebAssembly.RuntimeError.prototype.fileName")}}
-
Le chemin du fichier à l'origine de l'erreur. Cette propriété est héritée depuis {{jsxref("Error")}}.
-
{{jsxref("Error.prototype.lineNumber", "WebAssembly.RuntimeError.prototype.lineNumber")}}
-
Le numéro de la ligne à l'origine de l'erreur. Cette propriété est héritée depuis {{jsxref("Error")}}.
-
{{jsxref("Error.prototype.columnNumber", "WebAssembly.RuntimeError.prototype.columnNumber")}}
-
Le numéro de la colonne dans la ligne qui est à l'origine de l'erreur. Cette propriété est héritée depuis {{jsxref("Error")}}.
-
{{jsxref("Error.prototype.stack", "WebAssembly.RuntimeError.prototype.stack")}}
-
La pile d'appels à l'origine de l'erreur. Cette propriété est héritée depuis {{jsxref("Error")}}.
-
- -

Méthodes

- -

Le constructeur RuntimeError ne contient aucune méthode qui lui soit propre. En revanche, il hérite de certaines méthodes grâce à sa chaîne de prototypes.

- -
-
{{jsxref("Error.prototype.toSource", "WebAssembly.RuntimeError.prototype.toSource()")}}
-
Cette méthode renvoie un code qui, évalué, entraînerait la même erreur. Elle est héritée via {{jsxref("Error")}}.
-
{{jsxref("Error.prototype.toString", "WebAssembly.RuntimeError.prototype.toString()")}}
-
Cette méthode renvoie une chaîne de caractères qui représente l'objet Error. Elle est héritée via {{jsxref("Error")}}.
-
- -

Exemples

- -

Dans le fragment de code qui suit, on crée une instance de RuntimeError et on imprime les détails de cette erreur dans la console :

- -
try {
-  throw new WebAssembly.RuntimeError('Coucou', 'unFichier', 10);
-} catch (e) {
-  console.log(e instanceof RuntimeError); // true
-  console.log(e.message);                 // "Coucou"
-  console.log(e.name);                    // "RuntimeError"
-  console.log(e.fileName);                // "unFichier"
-  console.log(e.lineNumber);              // 10
-  console.log(e.columnNumber);            // 0
-  console.log(e.stack);                   // renvoie la pile d'appels
-                                           // à l'origine de l'erreur
-}
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#constructor-properties-of-the-webassembly-object', 'WebAssembly constructors')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initial pour WebAssembly.
{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard', 'NativeError')}}{{Spec2('ESDraft')}}Définition des types standards NativeError.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.RuntimeError")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/runtimeerror/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/runtimeerror/index.md new file mode 100644 index 0000000000..fe5a6d50e8 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/runtimeerror/index.md @@ -0,0 +1,116 @@ +--- +title: WebAssembly.RuntimeError() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/RuntimeError +tags: + - API + - Constructeur + - JavaScript + - Reference + - RuntimeError + - WebAssembly +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/RuntimeError +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/RuntimeError +--- +
{{JSRef}}
+ +

Le constructeur WebAssembly.RuntimeError() permet de créer un nouvel objet WebAssembly RuntimeError. C'est ce type d'exception qui est déclenchée lorsque WebAssembly définit une trappe.

+ +

Syntaxe

+ +
new WebAssembly.RuntimeError(message, nomFichier, numeroLigne)
+ +

Paramètres

+ +
+
message {{optional_inline}}
+
Une description, compréhensible par un humain, de l'erreur qui s'est produite.
+
fileName {{optional_inline}}{{non-standard_inline}}
+
Le nom du fichier qui contient le code à l'origine de l'exception.
+
lineNumber {{optional_inline}}{{non-standard_inline}}
+
Le numéro de la ligne de code à l'origine de l'exception.
+
+ +

Propriétés

+ +

Le constructeur RuntimeError ne contient aucune propriété qui lui soit propre. En revanche, il hérite de certaines propriétés grâce à sa chaîne de prototypes.

+ +
+
WebAssembly.RuntimeError.prototype.constructor
+
La fonction qui a créé le prototype de l'instance.
+
{{jsxref("Error.prototype.message", "WebAssembly.RuntimeError.prototype.message")}}
+
Le message qui décrit l'erreur. Bien qu'ECMA-262 indique que chaque instance doit fournir sa propre propriété message, dans SpiderMonkey, elle est héritée depuis {{jsxref("Error.prototype.message")}}.
+
{{jsxref("Error.prototype.name", "WebAssembly.RuntimeError.prototype.name")}}
+
Le nom de l'erreur. Cette propriété est héritée depuis {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.fileName", "WebAssembly.RuntimeError.prototype.fileName")}}
+
Le chemin du fichier à l'origine de l'erreur. Cette propriété est héritée depuis {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.lineNumber", "WebAssembly.RuntimeError.prototype.lineNumber")}}
+
Le numéro de la ligne à l'origine de l'erreur. Cette propriété est héritée depuis {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.columnNumber", "WebAssembly.RuntimeError.prototype.columnNumber")}}
+
Le numéro de la colonne dans la ligne qui est à l'origine de l'erreur. Cette propriété est héritée depuis {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.stack", "WebAssembly.RuntimeError.prototype.stack")}}
+
La pile d'appels à l'origine de l'erreur. Cette propriété est héritée depuis {{jsxref("Error")}}.
+
+ +

Méthodes

+ +

Le constructeur RuntimeError ne contient aucune méthode qui lui soit propre. En revanche, il hérite de certaines méthodes grâce à sa chaîne de prototypes.

+ +
+
{{jsxref("Error.prototype.toSource", "WebAssembly.RuntimeError.prototype.toSource()")}}
+
Cette méthode renvoie un code qui, évalué, entraînerait la même erreur. Elle est héritée via {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.toString", "WebAssembly.RuntimeError.prototype.toString()")}}
+
Cette méthode renvoie une chaîne de caractères qui représente l'objet Error. Elle est héritée via {{jsxref("Error")}}.
+
+ +

Exemples

+ +

Dans le fragment de code qui suit, on crée une instance de RuntimeError et on imprime les détails de cette erreur dans la console :

+ +
try {
+  throw new WebAssembly.RuntimeError('Coucou', 'unFichier', 10);
+} catch (e) {
+  console.log(e instanceof RuntimeError); // true
+  console.log(e.message);                 // "Coucou"
+  console.log(e.name);                    // "RuntimeError"
+  console.log(e.fileName);                // "unFichier"
+  console.log(e.lineNumber);              // 10
+  console.log(e.columnNumber);            // 0
+  console.log(e.stack);                   // renvoie la pile d'appels
+                                           // à l'origine de l'erreur
+}
+ +

Spécifications

+ + + + + + + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#constructor-properties-of-the-webassembly-object', 'WebAssembly constructors')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initial pour WebAssembly.
{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard', 'NativeError')}}{{Spec2('ESDraft')}}Définition des types standards NativeError.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.RuntimeError")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/table/get/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/table/get/index.html deleted file mode 100644 index 717a8d70e1..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/table/get/index.html +++ /dev/null @@ -1,84 +0,0 @@ ---- -title: WebAssembly.Table.prototype.get() -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/get -tags: - - API - - JavaScript - - Méthode - - Reference - - WebAssembly - - table -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/get -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/get ---- -
{{JSRef}}
- -

La méthode get(), rattachéee au prototype de  {{jsxref("WebAssembly.Table()")}}, permet de récupérer une référence à une fonction stockée dans le tableau WebAssembly grâce à sa position. dans le tableau.

- -

Syntaxe

- -
var funcRef = table.get(index);
-
- -

Paramètres

- -
-
index
-
L'index de la référence de fonction qu'on souhaite récupérer.
-
- -

Valeur de retour

- -

Une référence de fonction, c'est-à-dire une fonction WebAssembly exportée qui est une enveloppe JavaScript pour manipuler la fonction WebAssembly sous-jacente.

- -

Exceptions

- -

Si index est supérieur ou égal à {{jsxref("WebAssembly/Table/length","Table.prototype.length")}}, la méthode lèvera une exception {{jsxref("RangeError")}}.

- -

Exemples

- -

Dans l'exemple suivant (cf. le fichier table.html sur GitHub ainsi que le résultat obtenu), on compile et on instancie le bytecode chargé, table.wasm, grâce à la méthode {{jsxref("WebAssembly.instantiateStreaming()")}}. On récupère ensuite les références stockées dans le tableau d'export.

- -
WebAssembly.instantiateStreaming(fetch('table.wasm'))
-.then(function(obj) {
-  var tbl = obj.instance.exports.tbl;
-  console.log(tbl.get(0)());  // 13
-  console.log(tbl.get(1)());  // 42
-});
- -

On note ici qu'il est nécessaire d'avoir un deuxième opérateur d'appel après l'accesseur pour récupérer le valeur stockée dans la référence (autrement dit, on utilise get(0)() plutôt que get(0)). La valeur exportée est une fonction plutôt qu'une valeur simple.

- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblytableprototypeget', 'get()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initial pour WebAssembly.
- -

Compatibilité des navigateurs

- -
- - -

{{Compat("javascript.builtins.WebAssembly.Table.get")}}

-
- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/table/get/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/table/get/index.md new file mode 100644 index 0000000000..717a8d70e1 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/table/get/index.md @@ -0,0 +1,84 @@ +--- +title: WebAssembly.Table.prototype.get() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/get +tags: + - API + - JavaScript + - Méthode + - Reference + - WebAssembly + - table +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/get +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/get +--- +
{{JSRef}}
+ +

La méthode get(), rattachéee au prototype de  {{jsxref("WebAssembly.Table()")}}, permet de récupérer une référence à une fonction stockée dans le tableau WebAssembly grâce à sa position. dans le tableau.

+ +

Syntaxe

+ +
var funcRef = table.get(index);
+
+ +

Paramètres

+ +
+
index
+
L'index de la référence de fonction qu'on souhaite récupérer.
+
+ +

Valeur de retour

+ +

Une référence de fonction, c'est-à-dire une fonction WebAssembly exportée qui est une enveloppe JavaScript pour manipuler la fonction WebAssembly sous-jacente.

+ +

Exceptions

+ +

Si index est supérieur ou égal à {{jsxref("WebAssembly/Table/length","Table.prototype.length")}}, la méthode lèvera une exception {{jsxref("RangeError")}}.

+ +

Exemples

+ +

Dans l'exemple suivant (cf. le fichier table.html sur GitHub ainsi que le résultat obtenu), on compile et on instancie le bytecode chargé, table.wasm, grâce à la méthode {{jsxref("WebAssembly.instantiateStreaming()")}}. On récupère ensuite les références stockées dans le tableau d'export.

+ +
WebAssembly.instantiateStreaming(fetch('table.wasm'))
+.then(function(obj) {
+  var tbl = obj.instance.exports.tbl;
+  console.log(tbl.get(0)());  // 13
+  console.log(tbl.get(1)());  // 42
+});
+ +

On note ici qu'il est nécessaire d'avoir un deuxième opérateur d'appel après l'accesseur pour récupérer le valeur stockée dans la référence (autrement dit, on utilise get(0)() plutôt que get(0)). La valeur exportée est une fonction plutôt qu'une valeur simple.

+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblytableprototypeget', 'get()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initial pour WebAssembly.
+ +

Compatibilité des navigateurs

+ +
+ + +

{{Compat("javascript.builtins.WebAssembly.Table.get")}}

+
+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/table/grow/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/table/grow/index.html deleted file mode 100644 index d5356522b6..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/table/grow/index.html +++ /dev/null @@ -1,80 +0,0 @@ ---- -title: WebAssembly.Table.prototype.grow() -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/grow -tags: - - API - - JavaScript - - Méthode - - Reference - - WebAssembly - - table -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/grow -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/grow ---- -
{{JSRef}}
- -

La méthode grow(), rattachée au prototype de {{jsxref("WebAssembly.Table")}}, permet d'augmenter la taille du tableau WebAssembly d'un nombre d'éléments donné.

- -

Syntaxe

- -
table.grow(nombre);
-
- -

Paramètres

- -
-
nombre
-
Le nombre d'éléments qu'on souhaite ajouter au tableau.
-
- -

Valeur de retour

- -

La taille du tableau avant l'agrandissement.

- -

Exceptions

- -

Si l'opération grow() échoue, pour quelque raison que ce soit, une exception {{jsxref("RangeError")}} sera levée.

- -

Exemples

- -

Dans l'exemple qui suit, on crée une instance de Table pour représenter un tableau WebAssembly avec une taille initiale de 2 et une taille maximale de 10.

- -
var table = new WebAssembly.Table({ element: "anyfunc", initial: 2, maximum: 10 });
- -

On étend ensuite le tableau d'une unité en utilisant la méthode grow() :

- -
console.log(table.length);   // "2"
-console.log(table.grow(1));  // "2"
-console.log(table.length);   // "3"
-
- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblytableprototypegrow', 'grow()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.Table.grow")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/table/grow/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/table/grow/index.md new file mode 100644 index 0000000000..d5356522b6 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/table/grow/index.md @@ -0,0 +1,80 @@ +--- +title: WebAssembly.Table.prototype.grow() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/grow +tags: + - API + - JavaScript + - Méthode + - Reference + - WebAssembly + - table +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/grow +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/grow +--- +
{{JSRef}}
+ +

La méthode grow(), rattachée au prototype de {{jsxref("WebAssembly.Table")}}, permet d'augmenter la taille du tableau WebAssembly d'un nombre d'éléments donné.

+ +

Syntaxe

+ +
table.grow(nombre);
+
+ +

Paramètres

+ +
+
nombre
+
Le nombre d'éléments qu'on souhaite ajouter au tableau.
+
+ +

Valeur de retour

+ +

La taille du tableau avant l'agrandissement.

+ +

Exceptions

+ +

Si l'opération grow() échoue, pour quelque raison que ce soit, une exception {{jsxref("RangeError")}} sera levée.

+ +

Exemples

+ +

Dans l'exemple qui suit, on crée une instance de Table pour représenter un tableau WebAssembly avec une taille initiale de 2 et une taille maximale de 10.

+ +
var table = new WebAssembly.Table({ element: "anyfunc", initial: 2, maximum: 10 });
+ +

On étend ensuite le tableau d'une unité en utilisant la méthode grow() :

+ +
console.log(table.length);   // "2"
+console.log(table.grow(1));  // "2"
+console.log(table.length);   // "3"
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblytableprototypegrow', 'grow()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.Table.grow")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/table/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/table/index.html deleted file mode 100644 index 27df06ebb6..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/table/index.html +++ /dev/null @@ -1,134 +0,0 @@ ---- -title: WebAssembly.Table() -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table -tags: - - API - - Constructeur - - JavaScript - - Reference - - WebAssembly - - table -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table ---- -
{{JSRef}}
- -

Le constructeur WebAssembly.Table() permet de créer un nouvel objet Table.

- -

Cet objet est une enveloppe JavaScript qui représente un tableau WebAssembly et qui contient des références à des fonctions. Un tableau créé en JavaScript ou dans du code WebAssembly sera accessible et modifiable depuis du code JavaScript et depuis du code WebAssembly.

- -
-

Note : Actuellement, les tableaux WebAssembly peuvent uniquement stocker des références à des fonctions. Cette fonctionnalité sera vraisemblablement étendue par la suite.

-
- -

Syntaxe

- -
var monTableau = new WebAssembly.Table(descripteurTableau);
- -

Paramètres

- -
-
descripteurTableau
-
Un objet composé des propriétés qui suivent : -
-
element
-
Une chaîne de caractères qui représente le type de référence enregistrée dans le tableau. Actuellement, la seule valeur possible est "anyfunc" (pour indiquer des fonctions).
-
initial
-
La longueur initiale du tableau WebAssembly. Cela correspond au nombre d'éléments contenus dans le tableau.
-
maximum {{optional_inline}}
-
La taille maximale que pourra avoir tableau WebAssembly s'il est étendu.
-
-
-
- -

Exceptions

- - - -

Instances de Table

- -

Toutes les instances Table héritent des propriétés du prototype du constructeur Table(). Ce dernier peut être utilisé afin de modifier l'ensemble des instances Table.

- -

Propriétés

- -
-
Table.prototype.constructor
-
Renvoie la fonction qui a créé l'instance. Par défaut, c'est le constructeur {{jsxref("WebAssembly.Table()")}}.
-
{{jsxref("WebAssembly/Table/length","Table.prototype.length")}}
-
Renvoie la longueur du tableau, c'est-à-dire le nombre de références qui sont enregistrées dans le tableau.
-
- -

Méthodes

- -
-
{{jsxref("WebAssembly/Table/get","Table.prototype.get()")}}
-
Une fonction d'accès qui permet d'obtenir l'élément du tableau situé à une position donnée.
-
{{jsxref("WebAssembly/Table/grow","Table.prototype.grow()")}}
-
Cette méthode permet d'augmenter la taille du tableau Table d'un incrément donné.
-
{{jsxref("WebAssembly/Table/set","Table.prototype.set()")}}
-
Cette méthode permet de modifier un élément du tableau situé à une position donnée.
-
- -

Exemples

- -

Dans l'exemple qui suit (tiré du fichier table2.html et qui dispose d'une démonstration), on crée une nouvelle instance d'un tableau WebAssembly avec une taille initiale permettant de stocker 2 références. Ensuite, on imprime la longueur du tableau et le contenu des deux éléments (obtenus grâce à la méthode {{jsxref("WebAssembly/Table/get", "Table.prototype.get()")}} afin de montrer que la longueur vaut 2 et que le tableau ne contient encore aucune référence de fonction (pour les deux positions, on a la valeur {{jsxref("null")}}).

- -
var tbl = new WebAssembly.Table({initial:2, element:"anyfunc"});
-console.log(tbl.length);
-console.log(tbl.get(0));
-console.log(tbl.get(1));
- -

Ensuite, on crée un objet d'import qui contient une référence au tableau :

- -
var importObj = {
-  js: {
-    tbl:tbl
-  }
-};
- -

Enfin, on charge et on instancie un module WebAssembly (table2.wasm) grâce à la fonction {{jsxref("WebAssembly.instantiateStreaming()")}}. Le module table2.wasm a ajouté deux références de fonctions (cf. sa représentation textuelle). Chacune de ces fonctions fournit une valeur simple :

- -
WebAssembly.instantiateStreaming(fetch('table2.wasm'), importObject)
-.then(function(obj) {
-  console.log(tbl.length);   // "2"
-  console.log(tbl.get(0)()); // "42"
-  console.log(tbl.get(1)()); // "83"
-});
- -

On voit ici qu'il faut d'abord récupérer la fonction puis effectuer une invocation pour obtenir la valeur correspondante à partir de l'accesseur (autrement dit, on écrit get(0)() plutôt que get(0) pour obtenir le résultat de la fonction) .

- -

Dans cet exemple, on voit comment créer et manipuler le tableau depuis du code JavaScript mais ce même tableau est également accessible depuis l'instance WebAssembly.

- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblytable-objects', 'Table')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initial pour WebAssembly.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.Table")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/table/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/table/index.md new file mode 100644 index 0000000000..27df06ebb6 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/table/index.md @@ -0,0 +1,134 @@ +--- +title: WebAssembly.Table() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table +tags: + - API + - Constructeur + - JavaScript + - Reference + - WebAssembly + - table +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table +--- +
{{JSRef}}
+ +

Le constructeur WebAssembly.Table() permet de créer un nouvel objet Table.

+ +

Cet objet est une enveloppe JavaScript qui représente un tableau WebAssembly et qui contient des références à des fonctions. Un tableau créé en JavaScript ou dans du code WebAssembly sera accessible et modifiable depuis du code JavaScript et depuis du code WebAssembly.

+ +
+

Note : Actuellement, les tableaux WebAssembly peuvent uniquement stocker des références à des fonctions. Cette fonctionnalité sera vraisemblablement étendue par la suite.

+
+ +

Syntaxe

+ +
var monTableau = new WebAssembly.Table(descripteurTableau);
+ +

Paramètres

+ +
+
descripteurTableau
+
Un objet composé des propriétés qui suivent : +
+
element
+
Une chaîne de caractères qui représente le type de référence enregistrée dans le tableau. Actuellement, la seule valeur possible est "anyfunc" (pour indiquer des fonctions).
+
initial
+
La longueur initiale du tableau WebAssembly. Cela correspond au nombre d'éléments contenus dans le tableau.
+
maximum {{optional_inline}}
+
La taille maximale que pourra avoir tableau WebAssembly s'il est étendu.
+
+
+
+ +

Exceptions

+ + + +

Instances de Table

+ +

Toutes les instances Table héritent des propriétés du prototype du constructeur Table(). Ce dernier peut être utilisé afin de modifier l'ensemble des instances Table.

+ +

Propriétés

+ +
+
Table.prototype.constructor
+
Renvoie la fonction qui a créé l'instance. Par défaut, c'est le constructeur {{jsxref("WebAssembly.Table()")}}.
+
{{jsxref("WebAssembly/Table/length","Table.prototype.length")}}
+
Renvoie la longueur du tableau, c'est-à-dire le nombre de références qui sont enregistrées dans le tableau.
+
+ +

Méthodes

+ +
+
{{jsxref("WebAssembly/Table/get","Table.prototype.get()")}}
+
Une fonction d'accès qui permet d'obtenir l'élément du tableau situé à une position donnée.
+
{{jsxref("WebAssembly/Table/grow","Table.prototype.grow()")}}
+
Cette méthode permet d'augmenter la taille du tableau Table d'un incrément donné.
+
{{jsxref("WebAssembly/Table/set","Table.prototype.set()")}}
+
Cette méthode permet de modifier un élément du tableau situé à une position donnée.
+
+ +

Exemples

+ +

Dans l'exemple qui suit (tiré du fichier table2.html et qui dispose d'une démonstration), on crée une nouvelle instance d'un tableau WebAssembly avec une taille initiale permettant de stocker 2 références. Ensuite, on imprime la longueur du tableau et le contenu des deux éléments (obtenus grâce à la méthode {{jsxref("WebAssembly/Table/get", "Table.prototype.get()")}} afin de montrer que la longueur vaut 2 et que le tableau ne contient encore aucune référence de fonction (pour les deux positions, on a la valeur {{jsxref("null")}}).

+ +
var tbl = new WebAssembly.Table({initial:2, element:"anyfunc"});
+console.log(tbl.length);
+console.log(tbl.get(0));
+console.log(tbl.get(1));
+ +

Ensuite, on crée un objet d'import qui contient une référence au tableau :

+ +
var importObj = {
+  js: {
+    tbl:tbl
+  }
+};
+ +

Enfin, on charge et on instancie un module WebAssembly (table2.wasm) grâce à la fonction {{jsxref("WebAssembly.instantiateStreaming()")}}. Le module table2.wasm a ajouté deux références de fonctions (cf. sa représentation textuelle). Chacune de ces fonctions fournit une valeur simple :

+ +
WebAssembly.instantiateStreaming(fetch('table2.wasm'), importObject)
+.then(function(obj) {
+  console.log(tbl.length);   // "2"
+  console.log(tbl.get(0)()); // "42"
+  console.log(tbl.get(1)()); // "83"
+});
+ +

On voit ici qu'il faut d'abord récupérer la fonction puis effectuer une invocation pour obtenir la valeur correspondante à partir de l'accesseur (autrement dit, on écrit get(0)() plutôt que get(0) pour obtenir le résultat de la fonction) .

+ +

Dans cet exemple, on voit comment créer et manipuler le tableau depuis du code JavaScript mais ce même tableau est également accessible depuis l'instance WebAssembly.

+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblytable-objects', 'Table')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initial pour WebAssembly.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.Table")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/table/length/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/table/length/index.html deleted file mode 100644 index 878447d1e1..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/table/length/index.html +++ /dev/null @@ -1,65 +0,0 @@ ---- -title: WebAssembly.Table.prototype.length -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/length -tags: - - API - - JavaScript - - Propriété - - Reference - - WebAssembly - - table -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/length -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/length ---- -
{{JSRef}}
- -

La propriété length, rattachée au prototype de l'objet {{jsxref("WebAssembly.Table")}}, renvoie la longueur du tableau WebAssembly, c'est-à-dire le nombre d'éléments qui y sont stockées.

- -

Syntaxe

- -
table.length;
-
- -

Exemples

- -

Avec l'instruction qui suit, on crée un tableau WebAssembly avec une taille initiale de 2 éléments et avec une taille maximale de 10.

- -
var table = new WebAssembly.Table({ element: "anyfunc", initial: 2, maximum: 10 });
- -

On peut ensuite étendre le tableau d'un élément :

- -
console.log(table.length);   // "2"
-console.log(table.grow(1));  // "2"
-console.log(table.length);   // "3"
-
- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblytableprototypelength', 'length')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.Table.length")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/table/length/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/table/length/index.md new file mode 100644 index 0000000000..878447d1e1 --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/table/length/index.md @@ -0,0 +1,65 @@ +--- +title: WebAssembly.Table.prototype.length +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/length +tags: + - API + - JavaScript + - Propriété + - Reference + - WebAssembly + - table +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/length +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/length +--- +
{{JSRef}}
+ +

La propriété length, rattachée au prototype de l'objet {{jsxref("WebAssembly.Table")}}, renvoie la longueur du tableau WebAssembly, c'est-à-dire le nombre d'éléments qui y sont stockées.

+ +

Syntaxe

+ +
table.length;
+
+ +

Exemples

+ +

Avec l'instruction qui suit, on crée un tableau WebAssembly avec une taille initiale de 2 éléments et avec une taille maximale de 10.

+ +
var table = new WebAssembly.Table({ element: "anyfunc", initial: 2, maximum: 10 });
+ +

On peut ensuite étendre le tableau d'un élément :

+ +
console.log(table.length);   // "2"
+console.log(table.grow(1));  // "2"
+console.log(table.length);   // "3"
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblytableprototypelength', 'length')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.Table.length")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/table/set/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/table/set/index.html deleted file mode 100644 index 5413168f5e..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/table/set/index.html +++ /dev/null @@ -1,102 +0,0 @@ ---- -title: WebAssembly.Table.prototype.set() -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/set -tags: - - API - - JavaScript - - Méthode - - Reference - - WebAssembly - - table -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/set -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/set ---- -
{{JSRef}}
- -

La méthode set(), rattachée au prototype de {{jsxref("WebAssembly.Table")}}, permet de modifier une référence de fonction stockée dans un tableau WebAssembly.

- -

Syntaxe

- -
table.set(index, valeur);
-
- -

Paramètres

- -
-
index
-
L'index de la référence de la fonction qu'on souhaite modifier.
-
valeur
-
La valeur par laquelle on souhaite remplacer la référence. Cette valeur doit être une fonction exportée WebAssembly (c'est-à-dire une enveloppe JavaScript représentant une fonction WebAssembly sous-jacente).
-
- -

Valeur de retour

- -

Aucune.

- -

Exceptions

- - - -

Exemples

- -

Dans l'exemple qui suit (basé sur le code source de table2.html et qui dispose d'une démonstration), on crée ue nouvelle instance d'un tableau WebAssembly (Table) qui permet initialement de stocker 2 référence. On imprime alors la longueur du tableau dans la console ainsi que le contenu pour les deux premiers index (obtenus grâce à la méthode {{jsxref("WebAssembly/Table/get","Table.prototype.get()")}}) afin de montrer qu la longueur vaut 2 et qu'initialement, les deux éléments du tableau ne contiennent aucune référence (ils ont tous les deux la valeur {{jsxref("null")}}).

- -
var tbl = new WebAssembly.Table({initial:2, element:"anyfunc"});
-console.log(tbl.length);
-console.log(tbl.get(0));
-console.log(tbl.get(1));
- -

On crée ensuite un objet d'import qui contient une référence au tableau :

- -
var importObj = {
-  js: {
-    tbl:tbl
-  }
-};
- -

Enfin, on charge et on instancie le module WebAssembly (table2.wasm) grâce à la méthode {{jsxref("WebAssembly.instantiateStreaming()")}}, on logge la longueur du tableau et on appelle les deux fonctions référencées qui sont désormais dans le tableau (le module table2.wasm (cf. la représentation textuelle) ajoute deux références de fonctions au tableau et chacune affiche une valeur simple) :

- -
WebAssembly.instantiateStreaming(fetch('table2.wasm'), importObject)
-.then(function(obj) {
-  console.log(tbl.length);
-  console.log(tbl.get(0)());
-  console.log(tbl.get(1)());
-});
- -

On voit ici qu'il faut appeler la fonction après avoir appeler l'opérateur sur l'accesseur (autrement dit, on écrit get(0)() plutôt que get(0)) .

- -

Dans cet exemple, on montre comment créer et manipuler un tableau en JavaScript mais ce tableau est également accessible et manipulable depuis l'instance WebAssembly.

- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblytableprototypeset', 'set()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.Table.set")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/table/set/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/table/set/index.md new file mode 100644 index 0000000000..5413168f5e --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/table/set/index.md @@ -0,0 +1,102 @@ +--- +title: WebAssembly.Table.prototype.set() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/set +tags: + - API + - JavaScript + - Méthode + - Reference + - WebAssembly + - table +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/set +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/set +--- +
{{JSRef}}
+ +

La méthode set(), rattachée au prototype de {{jsxref("WebAssembly.Table")}}, permet de modifier une référence de fonction stockée dans un tableau WebAssembly.

+ +

Syntaxe

+ +
table.set(index, valeur);
+
+ +

Paramètres

+ +
+
index
+
L'index de la référence de la fonction qu'on souhaite modifier.
+
valeur
+
La valeur par laquelle on souhaite remplacer la référence. Cette valeur doit être une fonction exportée WebAssembly (c'est-à-dire une enveloppe JavaScript représentant une fonction WebAssembly sous-jacente).
+
+ +

Valeur de retour

+ +

Aucune.

+ +

Exceptions

+ + + +

Exemples

+ +

Dans l'exemple qui suit (basé sur le code source de table2.html et qui dispose d'une démonstration), on crée ue nouvelle instance d'un tableau WebAssembly (Table) qui permet initialement de stocker 2 référence. On imprime alors la longueur du tableau dans la console ainsi que le contenu pour les deux premiers index (obtenus grâce à la méthode {{jsxref("WebAssembly/Table/get","Table.prototype.get()")}}) afin de montrer qu la longueur vaut 2 et qu'initialement, les deux éléments du tableau ne contiennent aucune référence (ils ont tous les deux la valeur {{jsxref("null")}}).

+ +
var tbl = new WebAssembly.Table({initial:2, element:"anyfunc"});
+console.log(tbl.length);
+console.log(tbl.get(0));
+console.log(tbl.get(1));
+ +

On crée ensuite un objet d'import qui contient une référence au tableau :

+ +
var importObj = {
+  js: {
+    tbl:tbl
+  }
+};
+ +

Enfin, on charge et on instancie le module WebAssembly (table2.wasm) grâce à la méthode {{jsxref("WebAssembly.instantiateStreaming()")}}, on logge la longueur du tableau et on appelle les deux fonctions référencées qui sont désormais dans le tableau (le module table2.wasm (cf. la représentation textuelle) ajoute deux références de fonctions au tableau et chacune affiche une valeur simple) :

+ +
WebAssembly.instantiateStreaming(fetch('table2.wasm'), importObject)
+.then(function(obj) {
+  console.log(tbl.length);
+  console.log(tbl.get(0)());
+  console.log(tbl.get(1)());
+});
+ +

On voit ici qu'il faut appeler la fonction après avoir appeler l'opérateur sur l'accesseur (autrement dit, on écrit get(0)() plutôt que get(0)) .

+ +

Dans cet exemple, on montre comment créer et manipuler un tableau en JavaScript mais ce tableau est également accessible et manipulable depuis l'instance WebAssembly.

+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblytableprototypeset', 'set()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.Table.set")}}

+ +

Voir aussi

+ + diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/validate/index.html b/files/fr/web/javascript/reference/global_objects/webassembly/validate/index.html deleted file mode 100644 index df8887431d..0000000000 --- a/files/fr/web/javascript/reference/global_objects/webassembly/validate/index.html +++ /dev/null @@ -1,78 +0,0 @@ ---- -title: WebAssembly.validate() -slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/validate -tags: - - API - - JavaScript - - Méthode - - Reference - - WebAssembly -translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/validate -original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/validate ---- -
{{JSRef}}
- -

La fonction WebAssembly.validate() permet de valider un tableau typé de bytecode WebAssembly et renvoie un booléen qui indique si le contenu du tableau forme un module WebAssembly valide (true) ou non (false).

- -

Syntaxe

- -
WebAssembly.validate(bufferSource);
- -

Paramètres

- -
-
bufferSource
-
Un tableau typé ou un {{jsxref("ArrayBuffer")}} qui contient le bytecode du module qu'on souhaite valider.
-
- -

Valeur de retour

- -

Un booléen qui indique si la source est un code WebAssembly valide (true) ou non (false).

- -

Exceptions

- -

Si la valeur passée en argument n'est pas un tableau typé ou un {{jsxref("ArrayBuffer")}}, une exception {{jsxref("TypeError")}} sera levée.

- -

Exemples

- -

Dans l'exemple suivant, (cf. le fichier validate.html du code source, ainsi que l'exemple live), on récupère un module .wasm et on le convertit en un tableau typé. Ensuite, on appelle la méthode validate() afin de vérifier si le module est valide.

- -
fetch('simple.wasm').then(response =>
-  response.arrayBuffer()
-).then(function(bytes) {
-  var valid = WebAssembly.validate(bytes);
-  console.log("Les octets forment un module "
-    + (valid ? "" : "in") + "valide.");
-});
-
- -

Spécifications

- - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblyvalidate', 'validate()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.WebAssembly.validate")}}

- -

Voir aussi

- - diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/validate/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/validate/index.md new file mode 100644 index 0000000000..df8887431d --- /dev/null +++ b/files/fr/web/javascript/reference/global_objects/webassembly/validate/index.md @@ -0,0 +1,78 @@ +--- +title: WebAssembly.validate() +slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/validate +tags: + - API + - JavaScript + - Méthode + - Reference + - WebAssembly +translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/validate +original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/validate +--- +
{{JSRef}}
+ +

La fonction WebAssembly.validate() permet de valider un tableau typé de bytecode WebAssembly et renvoie un booléen qui indique si le contenu du tableau forme un module WebAssembly valide (true) ou non (false).

+ +

Syntaxe

+ +
WebAssembly.validate(bufferSource);
+ +

Paramètres

+ +
+
bufferSource
+
Un tableau typé ou un {{jsxref("ArrayBuffer")}} qui contient le bytecode du module qu'on souhaite valider.
+
+ +

Valeur de retour

+ +

Un booléen qui indique si la source est un code WebAssembly valide (true) ou non (false).

+ +

Exceptions

+ +

Si la valeur passée en argument n'est pas un tableau typé ou un {{jsxref("ArrayBuffer")}}, une exception {{jsxref("TypeError")}} sera levée.

+ +

Exemples

+ +

Dans l'exemple suivant, (cf. le fichier validate.html du code source, ainsi que l'exemple live), on récupère un module .wasm et on le convertit en un tableau typé. Ensuite, on appelle la méthode validate() afin de vérifier si le module est valide.

+ +
fetch('simple.wasm').then(response =>
+  response.arrayBuffer()
+).then(function(bytes) {
+  var valid = WebAssembly.validate(bytes);
+  console.log("Les octets forment un module "
+    + (valid ? "" : "in") + "valide.");
+});
+
+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblyvalidate', 'validate()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initiale pour WebAssembly.
+ +

Compatibilité des navigateurs

+ +

{{Compat("javascript.builtins.WebAssembly.validate")}}

+ +

Voir aussi

+ + -- cgit v1.2.3-54-g00ecf