From bf8e099b9c8b3c60d60b3712b4fc97b052c39887 Mon Sep 17 00:00:00 2001 From: julieng Date: Tue, 3 Aug 2021 08:03:23 +0200 Subject: convert content to md --- .../global_objects/webassembly/compile/index.md | 97 +++++------- .../webassembly/compileerror/index.md | 135 +++++++--------- .../webassembly/compilestreaming/index.md | 89 +++++------ .../global_objects/webassembly/global/index.md | 119 ++++++-------- .../reference/global_objects/webassembly/index.md | 163 +++++++++---------- .../webassembly/instance/exports/index.md | 55 +++---- .../global_objects/webassembly/instance/index.md | 73 ++++----- .../webassembly/instantiate/index.md | 173 +++++++++------------ .../webassembly/instantiatestreaming/index.md | 99 +++++------- .../global_objects/webassembly/linkerror/index.md | 135 +++++++--------- .../webassembly/memory/buffer/index.md | 56 +++---- .../webassembly/memory/grow/index.md | 88 +++++------ .../global_objects/webassembly/memory/index.md | 138 +++++++--------- .../webassembly/module/customsections/index.md | 99 +++++------- .../webassembly/module/exports/index.md | 101 ++++++------ .../webassembly/module/imports/index.md | 90 +++++------ .../global_objects/webassembly/module/index.md | 85 ++++------ .../webassembly/runtimeerror/index.md | 135 +++++++--------- .../global_objects/webassembly/table/get/index.md | 76 ++++----- .../global_objects/webassembly/table/grow/index.md | 87 +++++------ .../global_objects/webassembly/table/index.md | 160 +++++++++---------- .../webassembly/table/length/index.md | 59 +++---- .../global_objects/webassembly/table/set/index.md | 114 ++++++-------- .../global_objects/webassembly/validate/index.md | 80 ++++------ 24 files changed, 1038 insertions(+), 1468 deletions(-) (limited to 'files/fr/web/javascript/reference/global_objects/webassembly') 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 index 5e98ae5ba7..4cb8965534 100644 --- a/files/fr/web/javascript/reference/global_objects/webassembly/compile/index.md +++ b/files/fr/web/javascript/reference/global_objects/webassembly/compile/index.md @@ -10,77 +10,58 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/compile original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/compile --- -
{{JSRef}}
+{{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).

+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

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

Paramètres

+### Paramètres -
-
bufferSource
-
Un tableau typé ou un {{jsxref("ArrayBuffer")}} contenant le bytecode du module WebAssembly qu'on souhaite compiler.
-
+- `bufferSource` + - : Un [tableau typé](/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray) ou un {{jsxref("ArrayBuffer")}} contenant le _bytecode_ du module WebAssembly qu'on souhaite compiler. -

Valeur de retour

+### 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é.

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

Exceptions

+### Exceptions - +- Si `bufferSource` n'est pas un tableau typé, une exception {{jsxref("TypeError")}} sera levée. +- Si la compilation échoue, la promesse sera rompue avec une exception {{jsxref("WebAssembly.CompileError")}}. -

Exemples

+## 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().

+Dans l'exemple qui suit, on compile le _bytecode_ `simple.wasm` grâce à la méthode `compile()` puis on envoie le contenu à [un _worker_](https://developer.mozilla.org/fr/docs/Web/API/Web_Workers_API) grâce à la méthode [`postMessage()`](/fr/docs/Web/API/Worker/postMessage). -
var worker = new Worker("wasm_worker.js");
+```js
+var worker = new Worker("wasm_worker.js");
 
-fetch('simple.wasm').then(response =>
+fetch('simple.wasm').then(response =>
   response.arrayBuffer()
-).then(bytes =>
+).then(bytes =>
   WebAssembly.compile(bytes)
-).then(mod =>
+).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

- - +); +``` + +> **Note :** Dans la plupart des cas, mieux vaudra utiliser {{jsxref("WebAssembly.compileStreaming()")}} qui est plus efficace que `compile()`. + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------------------- | ------------------------------------ | -------------------------------------------------- | +| {{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 + +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index 0807afd7da..be5311cebf 100644 --- a/files/fr/web/javascript/reference/global_objects/webassembly/compileerror/index.md +++ b/files/fr/web/javascript/reference/global_objects/webassembly/compileerror/index.md @@ -13,62 +13,57 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/CompileError --- -
{{JSRef}}
+{{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.

+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

+## Syntaxe -
new WebAssembly.CompileError(message, nomFichier, numeroLigne)
+ new WebAssembly.CompileError(message, nomFichier, numeroLigne) -

Paramètres

+### 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.
-
+- `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

+## 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.

+_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")}}.
-
+- `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](/fr/docs/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

+## 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.

+_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")}}.
-
+- {{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

+## Exemples -

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

+Le fragment de code qui suit crée une instance de `CompileError` puis imprime ses détails dans la console : -
try {
+```js
+try {
   throw new WebAssembly.CompileError('Coucou', 'unFichier', 10);
 } catch (e) {
   console.log(e instanceof CompileError); // true
@@ -78,40 +73,22 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/CompileError
   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

- - +} +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------ | ----------------------------------------------------- | +| {{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 + +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index 539c7b3e2f..5328b248d6 100644 --- a/files/fr/web/javascript/reference/global_objects/webassembly/compilestreaming/index.md +++ b/files/fr/web/javascript/reference/global_objects/webassembly/compilestreaming/index.md @@ -11,70 +11,53 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/compileStreaming original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/compileStreaming --- -
{{JSRef}}
+{{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()")}}.

+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

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

Paramètres

+### 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.
-
+- `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

+### Valeur de retour -

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

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

Exceptions

+### Exceptions -
    -
  • Si la compilation échoue, la promesse est rejetée avec une exception {{jsxref("WebAssembly.CompileError")}}.
    • -
+- Si la compilation échoue, la promesse est rejetée avec une exception {{jsxref("WebAssembly.CompileError")}}. -

Exemples

+## 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.

+Dans l'exemple suivant (également disponible sur GitHub : [compile-streaming.html](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/compile-streaming.html) et avec [le résultat _live_](https://mdn.github.io/webassembly-examples/js-api-examples/compile-streaming.html)), 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) } };
+```js
+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

- - +.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 | État | Commentaires | +| ------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------- | -------------------------------------- | +| {{SpecName('WebAssembly Embedding', '#webassemblycompilestreaming', 'compileStreaming()')}} | {{Spec2('WebAssembly Embedding')}} | Brouillon pour la définition initiale. | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.WebAssembly.compileStreaming")}} + +## Voir aussi + +- [La page d'aperçu de WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript de WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index d31849c70e..67133e3992 100644 --- a/files/fr/web/javascript/reference/global_objects/webassembly/global/index.md +++ b/files/fr/web/javascript/reference/global_objects/webassembly/global/index.md @@ -12,58 +12,57 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Global original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Global --- -
{{JSRef}}
+{{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.

+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

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

Paramètres

+### 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.
-
+- `descripteur` -

Propriétés

+ - : Un dictionnaire `GlobalDescriptor` qui contient deux propriétés : -

Aucune.

+ - `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`. -

Instances de WebAssembly.Global

+- `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`](https://webassembly.github.io/spec/js-api/#defaultvalue). -

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 -

Propriétés des instances

+Aucune. -

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

+## Instances de `WebAssembly.Global` -

Méthodes des instances

+Toutes les instances de `Global` héritent du [prototype ](/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global/prototype)du constructeur `Global()`. Ce prototype peut être modifié afin d'avoir un impact sur l'ensemble des instances de `Global`. -

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

+### Propriétés des instances -

Exemples

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

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.

+### Méthodes des instances -

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).

+{{page('/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global/prototype', 'Méthodes')}} -
const output = document.getElementById('output');
+## 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).
+
+```js
+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>`;
+        output.innerHTML += `FAIL!
Got: ${got}
Expected: ${expected}
`;
     else
-        output.innerHTML += `SUCCESS! Got: ${got}<br>`;
+        output.innerHTML += `SUCCESS! Got: ${got}
`;
 }
 
 assertEq("WebAssembly.Global exists", typeof WebAssembly.Global, "function");
@@ -71,46 +70,30 @@ 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}) => {
+.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

- - +}); +``` + +> **Note :** Cet exemple est[ utilisable sur GitHub](https://mdn.github.io/webassembly-examples/js-api-examples/global.html) et [son code source est également disponible](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/global.html). + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------------------- | ------------------------------------ | ------------------------------------ | +| {{SpecName('WebAssembly JS', '#globals', 'WebAssembly.Global()')}} | {{Spec2('WebAssembly JS')}} | Brouillon de spécification initiale. | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.WebAssembly.Global")}} + +## Voir aussi + +- [Page principale pour la section WebAssembly de MDN](/fr/docs/WebAssembly) +- [Concepts WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) +- [La proposition pour l'import/export de variables globales modifiables](https://github.com/WebAssembly/mutable-global/blob/master/proposals/mutable-global/Overview.md) diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/index.md index eb71d2c673..5ee009f9cb 100644 --- a/files/fr/web/javascript/reference/global_objects/webassembly/index.md +++ b/files/fr/web/javascript/reference/global_objects/webassembly/index.md @@ -10,96 +10,77 @@ tags: 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 :

- -
    -
  • Charger du code WebAssembly grâce à la fonction {{jsxref("WebAssembly.instantiate()")}}
    • -
  • Créer des zones mémoires et des instances de tableaux grâce aux constructeurs  {{jsxref("WebAssembly.Memory()")}}/{{jsxref("WebAssembly.Table()")}}.
    • -
  • Fournir des outils de gestion d'erreur WebAssembly grâce aux constructeurs {{jsxref("WebAssembly.CompileError()")}}/{{jsxref("WebAssembly.LinkError()")}}/{{jsxref("WebAssembly.RuntimeError()")}}.
    • -
- -

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) } };
+{{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](/fr/docs/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 :
+
+- Charger du code WebAssembly grâce à la fonction {{jsxref("WebAssembly.instantiate()")}}
+- Créer des zones mémoires et des instances de tableaux grâce aux constructeurs  {{jsxref("WebAssembly.Memory()")}}/{{jsxref("WebAssembly.Table()")}}.
+- Fournir des outils de gestion d'erreur WebAssembly grâce aux constructeurs {{jsxref("WebAssembly.CompileError()")}}/{{jsxref("WebAssembly.LinkError()")}}/{{jsxref("WebAssembly.RuntimeError()")}}.
+
+## 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`](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/instantiate-streaming.html) sur GitHub et [le résultat obtenu](https://mdn.github.io/webassembly-examples/js-api-examples/instantiate-streaming.html)) 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.
+
+```js
+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

- - +.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 | État | Commentaires | +| ------------------------------------------------------------------------------------------------ | ------------------------------------ | --------------------------------- | +| {{SpecName('WebAssembly JS', '#the-webassembly-object', 'WebAssembly')}} | {{Spec2('WebAssembly JS')}} | Brouillon de définition initiale. | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.WebAssembly")}} + +## Voir aussi + +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index 86bece9671..6a18d00743 100644 --- 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 @@ -12,17 +12,18 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance/exports original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Instance/exports --- -
{{JSRef}}
+{{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.

+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
+ instance.exports -

Exemples

+## 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.

+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](/fr/docs/WebAssembly/Exported_functions) qui est exposée via l'instance. -
var importObject = {
+```js
+var importObject = {
   imports: {
     imported_func: function(arg) {
       console.log(arg);
@@ -30,39 +31,23 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Instance/expo
   }
 };
 WebAssembly.instantiateStreaming(fetch('simple.wasm'), importObject)
-.then(obj => obj.instance.exports.exported_func());
+.then(obj => obj.instance.exports.exported_func()); +``` -
-

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

-
+> **Note :** Voir le fichier [index.html](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/index.html) sur GitHub (ainsi que [la démonstration](https://mdn.github.io/webassembly-examples/js-api-examples/)) pour un exemple. -

Spécifications

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

Compatibilité des navigateurs

+## Compatibilité des navigateurs -

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

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

Voir aussi

+## Voir aussi - +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index 1fceef26d9..3c06a69d03 100644 --- a/files/fr/web/javascript/reference/global_objects/webassembly/instance/index.md +++ b/files/fr/web/javascript/reference/global_objects/webassembly/instance/index.md @@ -11,68 +11,49 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Instance --- -
{{JSRef}}
+{{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.

+Un objet **`WebAssembly.Instance`** représente un objet exécutable, avec un état, qui est une instance d'un [module WebAssembly](/fr/docs/Web/JavaScript/Reference/Objets_globaux/WebAssembly/Module). Un objet `Instance` contient l'ensemble [des fonctions WebAssembly exportées](/fr/docs/WebAssembly/Exported_functions) 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()")}}.

+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

+## 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.

-
+> **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);
+ var monInstance = new WebAssembly.Instance(module, importObject); -

Paramètres

+### 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.
-
+- `module` + - : L'objet [`WebAssembly.Module`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/WebAssembly/Module "The Module() constructor of the WebAssembly global object creates a new Module object instance.") 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`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/WebAssembly/Memory "The Memory() constructor of the WebAssembly global object creates a new Memory object instance, which represents a WebAssembly memory. These can be thought of as resizeable array buffers, wrappers around WebAssembly memories."). Il doit exister une propriété correspondante pour chaque import, si ce n'est pas le cas, un exception [`WebAssembly.LinkError`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/WebAssembly/LinkError) sera levée. -

Instances d'Instance

+## 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.

+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

+### Propriétés -

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

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

Méthodes

+### Méthodes -

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

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

Spécifications

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

Compatibilité des navigateurs

+## Compatibilité des navigateurs -

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

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

Voir aussi

+## Voir aussi - +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index 5ec32f1f87..9c01958668 100644 --- a/files/fr/web/javascript/reference/global_objects/webassembly/instantiate/index.md +++ b/files/fr/web/javascript/reference/global_objects/webassembly/instantiate/index.md @@ -10,87 +10,70 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/instantiate --- -
{{JSRef}}
+{{JSRef}} -

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

+La fonction **`WebAssembly.instantiate()`** permet de compiler et d'instancier du code WebAssembly. Cette fonction possède deux formes : -
    -
  • La première forme prend un code binaire WebAssembly sous forme d'un tableau typé ou d'un {{jsxref("ArrayBuffer")}} et effectue les étapes de compilation et d'instanciation en une fois. La valeur de résolution de la promesse renvoyée se compose d'un module {{jsxref("WebAssembly.Module")}} compilé et de sa première instance {{jsxref("WebAssembly.Instance")}}.
    • -
  • La seconde forme prend un module ({{jsxref("WebAssembly.Module")}}) déjà compilé et renvoie une promesse dont la valeur de résolution est une instance de ce module. Cette forme s'avère utile lorsque le module a déjà été compilé.
    • -
+- La première forme prend un code binaire WebAssembly sous forme d'un [tableau typé](/fr/docs/Web/JavaScript/Tableaux_typés) ou d'un {{jsxref("ArrayBuffer")}} et effectue les étapes de compilation et d'instanciation en une fois. La valeur de résolution de la promesse renvoyée se compose d'un module {{jsxref("WebAssembly.Module")}} compilé et de sa première instance {{jsxref("WebAssembly.Instance")}}. +- La seconde forme prend un module ({{jsxref("WebAssembly.Module")}}) déjà compilé et renvoie une promesse dont la valeur de résolution est une instance de ce module. Cette forme s'avère utile lorsque le module a déjà été compilé. -
-

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")}}.

-
+> **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

+## Syntaxe -

Première forme : utiliser le bytecode WebAssembly

+### Première forme : utiliser le _bytecode_ WebAssembly -
Promise<ResultObject> WebAssembly.instantiate(bufferSource, importObject);
-
+ Promise WebAssembly.instantiate(bufferSource, importObject); -

Paramètres

+#### 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.
-
+- `bufferSource` + - : Un [tableau typé](/fr/docs/Web/JavaScript/Tableaux_typés) 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

+#### Valeur de retour -

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

+Une promesse qui est résoluee en un objet qui contient deux champs : -
    -
  • module : un objet {{jsxref("WebAssembly.Module")}} qui représente le module WebAssembly compilé. Ce module peut être instancié à nouveau grâce à  {{domxref("Worker.postMessage", "postMessage()")}} ou via un cache IndexedDB.
    • -
  • instance : un objet {{jsxref("WebAssembly.Instance")}} qui contient l'ensemble des fonctions WebAssembly exportées.
    • -
+- `module` : un objet {{jsxref("WebAssembly.Module")}} qui représente le module WebAssembly compilé. Ce module peut être instancié à nouveau grâce à  {{domxref("Worker.postMessage", "postMessage()")}} ou via [un cache IndexedDB](/fr/docs/WebAssembly/Caching_modules). +- `instance` : un objet {{jsxref("WebAssembly.Instance")}} qui contient l'ensemble [des fonctions WebAssembly exportées](/fr/docs/WebAssembly/Exported_functions). -

Exceptions

+#### Exceptions -
    -
  • Si l'un des paramètres n'a pas le bon type ou la bonne structure, une exception {{jsxref("TypeError")}} sera levée.
    • -
  • Si l'opération échoue, la promesse est rompue avec une exception {{jsxref("WebAssembly.CompileError")}}, {{jsxref("WebAssembly.LinkError")}} ou {{jsxref("WebAssembly.RuntimeError")}} selon l'origine de l'échec.
    • -
+- Si l'un des paramètres n'a pas le bon type ou la bonne structure, une exception {{jsxref("TypeError")}} sera levée. +- Si l'opération échoue, la promesse est rompue avec une exception {{jsxref("WebAssembly.CompileError")}}, {{jsxref("WebAssembly.LinkError")}} ou {{jsxref("WebAssembly.RuntimeError")}} selon l'origine de l'échec. -

Seconde forme : utiliser une instance d'un module

+### Seconde forme : utiliser une instance d'un module -
Promise<WebAssembly.Instance> WebAssembly.instantiate(module, importObject);
-
+ Promise WebAssembly.instantiate(module, importObject); -

Paramètres

+#### 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.
-
+- `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

+#### Valeur de retour -

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

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

Exceptions

+#### Exceptions -
    -
  • Si l'un des paramètres n'est pas du bon type ou n'a pas la bonne structure, une exception {{jsxref("TypeError")}} est levée.
    • -
  • Si l'opération échoue, la promesse sera rompue avec une exception {{jsxref("WebAssembly.CompileError")}}, {{jsxref("WebAssembly.LinkError")}} ou {{jsxref("WebAssembly.RuntimeError")}} selon l'origine de l'échec.
    • -
+- Si l'un des paramètres n'est pas du bon type ou n'a pas la bonne structure, une exception {{jsxref("TypeError")}} est levée. +- Si l'opération échoue, la promesse sera rompue avec une exception {{jsxref("WebAssembly.CompileError")}}, {{jsxref("WebAssembly.LinkError")}} ou {{jsxref("WebAssembly.RuntimeError")}} selon l'origine de l'échec. -

Exemples

+## Exemples -
-

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

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

Première forme

+### 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.

+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](/fr/docs/WebAssembly/Exported_functions) via l'instance. -
var importObject = {
+```js
+var importObject = {
   imports: {
     imported_func: function(arg) {
       console.log(arg);
@@ -98,32 +81,34 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/instantiate
   }
 };
 
-fetch('simple.wasm').then(response =>
+fetch('simple.wasm').then(response =>
   response.arrayBuffer()
-).then(bytes =>
+).then(bytes =>
   WebAssembly.instantiate(bytes, importObject)
-).then(result =>
+).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().

-
+> **Note :** Voir le fichier [index.html](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/index.html) sur GitHub ([ainsi que la démonstration associée](https://mdn.github.io/webassembly-examples/js-api-examples/)) qui contient un exemple analogue et qui utilise la fonction utilitaire [`fetchAndInstantiate()`](https://github.com/mdn/webassembly-examples/blob/master/wasm-utils.js#L1). -

Seconde forme

+### 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()")}}.

+Dans l'exemple qui suit (tiré du fichier [`index-compile.html`](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/index-compile.html) sur GitHub et qui dispose d'[une démonstration](https://mdn.github.io/webassembly-examples/js-api-examples/index-compile.html)), on compile le _bytecode_ du module chargé `simple.wasm` grâce à la fonction {{jsxref("WebAssembly.compileStreaming()")}} puis on envoie le résultat à un _[worker](/fr/docs/Web/API/Web_Workers_API)_ grâce à la méthode {{domxref("Worker.postMessage", "postMessage()")}}. -
var worker = new Worker("wasm_worker.js");
+```js
+var worker = new Worker("wasm_worker.js");
 
 WebAssembly.compileStreaming(fetch('simple.wasm'))
-.then(mod =>
+.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.

+Dans le _worker_ (cf. [`wasm_worker.js`](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/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 = {
+```js
+var importObject = {
   imports: {
     imported_func: function(arg) {
       console.log(arg);
@@ -138,35 +123,21 @@ onmessage = function(e) {
   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

- - +}; +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------------------------------- | ------------------------------------ | --------------------------------- | +| {{SpecName('WebAssembly JS', '#webassemblyinstantiate', 'instantiate()')}} | {{Spec2('WebAssembly JS')}} | Brouillon de définition initiale. | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.WebAssembly.instantiate")}} + +## Voir aussi + +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index a9cbf1ead2..783fc228bf 100644 --- a/files/fr/web/javascript/reference/global_objects/webassembly/instantiatestreaming/index.md +++ b/files/fr/web/javascript/reference/global_objects/webassembly/instantiatestreaming/index.md @@ -11,77 +11,58 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/instantiateStreaming --- -
{{JSRef}}
+{{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.

+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

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

Paramètres

+### 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.
-
+- `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`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/WebAssembly/LinkError) sera levée. -

Valeur de retour

+### Valeur de retour -

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

+Un objet `Promise` dont la valeur de résolution est un objet `ResultObject` contenant deux champs : -
    -
  • module : un objet {{jsxref("WebAssembly.Module")}} qui représente le module WebAssembly compilé. Ce module pourra être instancié à nouveau, partagé avec postMessage().
    • -
  • instance : un objet {{jsxref("WebAssembly.Instance")}} qui contient l'ensemble des fonctions WebAssembly exportées.
    • -
+- `module` : un objet {{jsxref("WebAssembly.Module")}} qui représente le module WebAssembly compilé. Ce module pourra être instancié à nouveau, partagé avec [`postMessage()`](/fr/docs/Web/API/Worker/postMessage). +- `instance` : un objet {{jsxref("WebAssembly.Instance")}} qui contient l'ensemble [des fonctions WebAssembly exportées](/fr/docs/WebAssembly/Exported_functions). -

Exceptions

+### Exceptions -
    -
  • Si l'un des paramètres n'est pas du bon type ou ne possède pas la bonne structure, une exception {{jsxref("TypeError")}} est déclenchée.
    • -
  • Si l'opération échoue, la promesse lève une exception {{jsxref("WebAssembly.CompileError")}}, {{jsxref("WebAssembly.LinkError")}} ou {{jsxref("WebAssembly.RuntimeError")}} selon la cause de l'échec.
    • -
+- Si l'un des paramètres n'est pas du bon type ou ne possède pas la bonne structure, une exception {{jsxref("TypeError")}} est déclenchée. +- Si l'opération échoue, la promesse lève une exception {{jsxref("WebAssembly.CompileError")}}, {{jsxref("WebAssembly.LinkError")}} ou {{jsxref("WebAssembly.RuntimeError")}} selon la cause de l'échec. -

Examples

+## 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.

+Dans l'exemple suivant (également disponible sur GitHub : [instantiate-streaming.html](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/instantiate-streaming.html) et avec [le résultat _live_](https://mdn.github.io/webassembly-examples/js-api-examples/instantiate-streaming.html)), 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) } };
+```js
+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

- - +.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 | État | Commentaires | +| ------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------- | --------------------------------- | +| {{SpecName('WebAssembly Embedding', '#webassemblyinstantiatestreaming', 'instantiateStreaming()')}} | {{Spec2('WebAssembly Embedding')}} | Brouillon de définition initiale. | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.WebAssembly.instantiateStreaming")}} + +## Voir aussi + +- [La page d'aperçu de WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript de WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index fe881933bb..c12eeab0ec 100644 --- a/files/fr/web/javascript/reference/global_objects/webassembly/linkerror/index.md +++ b/files/fr/web/javascript/reference/global_objects/webassembly/linkerror/index.md @@ -11,62 +11,57 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/LinkError original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/LinkError --- -
{{JSRef}}
+{{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).

+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](http://webassembly.org/docs/semantics/#traps) provenant de la fonction initiale). -

Syntaxe

+## Syntaxe -
new WebAssembly.LinkError(message, nomFichier, numeroLigne)
+ new WebAssembly.LinkError(message, nomFichier, numeroLigne) -

Paramètres

+### 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.
-
+- `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

+## 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.

+_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")}}.
-
+- `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](/fr/docs/Mozilla/Projects/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

+## 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.

+_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")}}.
-
+- {{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

+## 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 :

+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 {
+```js
+try {
   throw new WebAssembly.LinkError('Coucou', 'unFichier', 10);
 } catch (e) {
   console.log(e instanceof LinkError); // true
@@ -77,40 +72,22 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/LinkError
   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

- - +} +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------ | -------------------------------------------------- | +| {{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 + +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index cd6e68ecec..54b2b1dd81 100644 --- 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 @@ -11,54 +11,40 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/buffer original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Memory/buffer --- -
{{JSRef}}
+{{JSRef}} -

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

+La propriété **`buffer`**, rattachée au prototype de l'objet [`Memory`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/WebAssembly/Memory), renvoie le tampon (_buffer_) contenu dans l'espace mémoire. -
memory.buffer
-
+ memory.buffer -

Exemples

+## 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.

+Dans l'exemple suivant (cf. le fichier [memory.html](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/memory.html) sur GitHub ainsi que [le résultat obtenu](https://mdn.github.io/webassembly-examples/js-api-examples/memory.html)), 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 => {
+```js
+WebAssembly.instantiateStreaming(fetch('memory.wasm'), { js: { mem: memory } })
+.then(obj => {
   var i32 = new Uint32Array(memory.buffer);
-  for (var i = 0; i < 10; i++) {
+  for (var i = 0; i < 10; i++) {
     i32[i] = i;
   }
   var sum = obj.instance.exports.accumulate(0, 10);
   console.log(sum);
-});
+}); +``` -

Spécifications

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

Compatibilité des navigateurs

+## Compatibilité des navigateurs -

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

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

Voir aussi

+## Voir aussi - +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index 7d4426fc4a..5872525372 100644 --- 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 @@ -11,68 +11,54 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/grow original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Memory/grow --- -
{{JSRef}}
+{{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.

+La méthode **`grow()`**, rattachée au prototype de l'objet [`Memory`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/WebAssembly/Memory), permet d'augmenter la taille de l'espace mémoire correspondant d'un nombre de pages WebAssembly. -

Syntaxe

+## Syntaxe -
memory.grow(nombre);
-
+ memory.grow(nombre); -

Paramètres

+### 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).
-
+- `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

+### Valeur de retour -

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

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

Exemples

+## 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).

+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});
+```js +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 :

+Ensuite, on augmente la taille de l'espace mémoire d'une page grâce à la méthode : -
const bytesPerPage = 64 * 1024;
+```js
+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

- - +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 | État | Commentaires | +| ---------------------------------------------------------------------------------------------------- | ------------------------------------ | -------------------------------------------------- | +| {{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 + +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index 5c5d36d7cd..dcd8256662 100644 --- a/files/fr/web/javascript/reference/global_objects/webassembly/memory/index.md +++ b/files/fr/web/javascript/reference/global_objects/webassembly/memory/index.md @@ -11,110 +11,88 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Memory --- -
{{JSRef}}
+{{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.

+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.

+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

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

Paramètres

+### 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.
-
-
-
+- `descripteurMemoire` -
-

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

-
+ - : Un objet qui contient les propriétés suivantes : -

Exceptions

+ - `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. -
    -
  • Si descripteurMemoire n'est pas un objet, une exception {{jsxref("TypeError")}} sera levée.
    • -
  • Si maximum est indiqué et qu'il est inférieur à initial, une exception {{jsxref("RangeError")}} sera levée.
    • -
+> **Note :** Une page mémoire WebAssembly correspond à une taille fixe de 65 536 octets, soit environ 64 Ko. -

Méthodes du constructeur Memory

+### Exceptions -

Aucune.

+- Si `descripteurMemoire` n'est pas un objet, une exception {{jsxref("TypeError")}} sera levée. +- Si `maximum` est indiqué et qu'il est inférieur à `initial`, une exception {{jsxref("RangeError")}} sera levée. -

Instances de Memory

+## Méthodes du constructeur `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.

+Aucune. -

Propriétés

+## Instances de `Memory` -
-
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.
-
+Toutes les instances de `Memory` héritent des propriétés du [prototype du constructeur](/fr/docs/Web/JavaScript/Reference/Objets_globaux/WebAssembly/Memory/prototype) `Memory()` qui peut être utilisé afin de modifier le comportement de l'ensemble des instances de `Memory`. -

Méthodes

+### Propriétés -
-
{{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).
-
+- `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. -

Exemples

+### Méthodes -

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).

+- {{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). -
var memoire = new WebAssembly.Memory({initial:10, maximum:100});
+## Exemples -

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.

+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). -
WebAssembly.instantiateStreaming(fetch('memory.wasm'), { js: { mem: memory } })
-.then(obj => {
+```js
+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](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/memory.html) sur GitHub ainsi que [le résultat obtenu](https://mdn.github.io/webassembly-examples/js-api-examples/memory.html)) 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.
+
+```js
+WebAssembly.instantiateStreaming(fetch('memory.wasm'), { js: { mem: memory } })
+.then(obj => {
   var i32 = new Uint32Array(memory.buffer);
-  for (var i = 0; i < 10; i++) {
+  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

- - +}); +``` + +## Spécifications + +| Spécification | État | Commentaires | +| -------------------------------------------------------------------------------------------- | ------------------------------------ | -------------------------------------------------- | +| {{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 + +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index dd76bbe66d..63877bff3b 100644 --- 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 @@ -13,83 +13,70 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/customSections original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Module/customSections --- -
{{JSRef}}
+{{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é.

+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

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

Paramètres

+### 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.
-
+- `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

+### 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.

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

Exceptions

+### 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")}}.

+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

+## 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.

+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](https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#high-level-structure) 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).

+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`](https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#name-section), 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 :

+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`](https://github.com/webassembly/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
+```bash +wast2wasm simple-name-section.was -o simple-name-section.wasm --debug-names +``` -

Exemples

+## 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.

+Dans l'exemple qui suit (tiré de [ce fichier source](https://github.com/mdn/webassembly-examples/blob/master/other-examples/custom-section.html) et de [cette démonstration](https://mdn.github.io/webassembly-examples/other-examples/custom-section.html)), 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")}}.

+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'))
+```js
+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

- - +}); +``` + +## Spécifications + +| Spécification | État | Commentaires | +| -------------------------------------------------------------------------------------------------------------------- | ------------------------------------ | -------------------------------------------------- | +| {{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 + +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index d16223a07c..6f7722bdb1 100644 --- 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 @@ -13,43 +13,44 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/exports original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Module/exports --- -
{{JSRef}}
+{{JSRef}} -

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

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

Syntaxe

+## Syntaxe -
var exports = WebAssembly.Module.exports(module);
+ var exports = WebAssembly.Module.exports(module); -

Paramètres

+### Paramètres -
-
module
-
Un objet {{jsxref("WebAssembly.Module")}}.
-
+- `module` + - : Un objet {{jsxref("WebAssembly.Module")}}. -

Valeur de retour

+### Valeur de retour -

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

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

Exceptions

+### Exceptions -

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

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

Exemples

+## 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().

+Dans l'exemple suivant (basé sur le fichier [`index-compile.html`](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/index-compile.html) disponible sur GitHub avec [la démonstration correspondante](https://mdn.github.io/webassembly-examples/js-api-examples/index-compile.html)), on compile le _bytecode_ `simple.wasm` grâce à la fonction {{jsxref("WebAssembly.compileStreaming()")}} puis on envoie le résultat à un _[worker](/fr/docs/Web/API/Web_Workers_API)_ grâce à la méthode [`postMessage()`](/fr/docs/Web/API/Worker/postMessage). -
var worker = new Worker("wasm_worker.js");
+```js
+var worker = new Worker("wasm_worker.js");
 
 WebAssembly.compileStreaming(fetch("simple.wasm"))
-.then(mod =>
+.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.

+Dans le _worker_ (cf. [`wasm_worker.js`](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/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 = {
+```js
+var importObject = {
   imports: {
     imported_func: function(arg) {
       console.log(arg);
@@ -67,39 +68,27 @@ onmessage = function(e) {
 
   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

- - +}; +``` + +La valeur `exports[0]` ressemblera alors à : + +```js +{ name: "exported_func", kind: "function" } +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------------------------------ | ------------------------------------ | -------------------------------------------------- | +| {{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 + +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index ac039a3fc7..154d821286 100644 --- 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 @@ -11,71 +11,57 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/imports original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Module/imports --- -
{{JSRef}}
+{{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é.

+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

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

Paramètres

+### Paramètres -
-
module
-
Une instance de {{jsxref("WebAssembly.Module")}}.
-
+- `module` + - : Une instance de {{jsxref("WebAssembly.Module")}}. -

Valeur de retour

+### Valeur de retour -

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

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

Exceptions

+### Exceptions -

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

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

Exemples

+## 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)

+Dans l'exemple qui suit, on compile le module `simple.wasm` puis on parcourt ses imports (cf. aussi [le code sur GitHub](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/imports.html) et [l'exemple _live_](https://mdn.github.io/webassembly-examples/js-api-examples/imports.html)) -
WebAssembly.compileStreaming(fetch('simple.wasm'))
+```js
+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

- - +``` + +Le résultat affiché dans la console ressemble alors à : + +```js +{ module: "imports", name: "imported_func", kind: "function" } +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------------------------------ | ------------------------------------ | ------------------------------------------------- | +| {{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 + +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index cd6b46e8a9..ce946737a8 100644 --- a/files/fr/web/javascript/reference/global_objects/webassembly/module/index.md +++ b/files/fr/web/javascript/reference/global_objects/webassembly/module/index.md @@ -10,77 +10,56 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Module --- -
{{JSRef}}
+{{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()")}}.

+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_](/fr/docs/Web/API/Worker/postMessage) 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.

+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

+## 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()")}}.

-
+> **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);
+ var monModule = new WebAssembly.Module(bufferSource); -

Paramètres

+### Paramètres -
-
bufferSource
-
Un tableau typé ou un {{jsxref("ArrayBuffer")}} qui contient le bytecode du module WebAssembly qu'on souhaite compiler.
-
+- `bufferSource` + - : Un [tableau typé](/fr/docs/Web/JavaScript/Tableaux_typés) ou un {{jsxref("ArrayBuffer")}} qui contient le _bytecode_ du module WebAssembly qu'on souhaite compiler. -

Méthodes du constructeur Module

+## 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.
-
+- {{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

+## 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.

+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

+### Propriétés -

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

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

Méthodes

+### Méthodes -

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

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

Spécifications

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

Compatibilité des navigateurs

+## Compatibilité des navigateurs -

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

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

Voir aussi

+## Voir aussi - +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index fe5a6d50e8..de39df2f33 100644 --- a/files/fr/web/javascript/reference/global_objects/webassembly/runtimeerror/index.md +++ b/files/fr/web/javascript/reference/global_objects/webassembly/runtimeerror/index.md @@ -11,62 +11,57 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/RuntimeError original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/RuntimeError --- -
{{JSRef}}
+{{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.

+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](http://webassembly.org/docs/semantics/#traps). -

Syntaxe

+## Syntaxe -
new WebAssembly.RuntimeError(message, nomFichier, numeroLigne)
+ new WebAssembly.RuntimeError(message, nomFichier, numeroLigne) -

Paramètres

+### 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.
-
+- `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

+## 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.

+_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")}}.
-
+- `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](/fr/docs/Mozilla/Projects/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

+## 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.

+_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")}}.
-
+- {{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

+## 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 :

+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 {
+```js
+try {
   throw new WebAssembly.RuntimeError('Coucou', 'unFichier', 10);
 } catch (e) {
   console.log(e instanceof RuntimeError); // true
@@ -77,40 +72,22 @@ original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/RuntimeError
   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

- - +} +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------ | ------------------------------------------------- | +| {{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 + +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index 717a8d70e1..3d263884fe 100644 --- 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 @@ -11,74 +11,54 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/get original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/get --- -
{{JSRef}}
+{{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.

+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

+## Syntaxe -
var funcRef = table.get(index);
-
+ var funcRef = table.get(index); -

Paramètres

+### Paramètres -
-
index
-
L'index de la référence de fonction qu'on souhaite récupérer.
-
+- `index` + - : L'index de la référence de fonction qu'on souhaite récupérer. -

Valeur de retour

+### 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.

+Une référence de fonction, c'est-à-dire [une fonction WebAssembly exportée](/fr/docs/WebAssembly/Exported_functions) qui est une enveloppe JavaScript pour manipuler la fonction WebAssembly sous-jacente. -

Exceptions

+### Exceptions -

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

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

Exemples

+## 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.

+Dans l'exemple suivant (cf. le fichier [`table.html`](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/table.html) sur GitHub ainsi que [le résultat obtenu](https://mdn.github.io/webassembly-examples/js-api-examples/table.html)), 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'))
+```js
+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.

+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écifications - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('WebAssembly JS', '#webassemblytableprototypeget', 'get()')}}{{Spec2('WebAssembly JS')}}Brouillon de définition initial pour WebAssembly.
+| Spécification | État | Commentaires | +| ------------------------------------------------------------------------------------------------ | ------------------------------------ | ------------------------------------------------- | +| {{SpecName('WebAssembly JS', '#webassemblytableprototypeget', 'get()')}} | {{Spec2('WebAssembly JS')}} | Brouillon de définition initial pour WebAssembly. | -

Compatibilité des navigateurs

+## Compatibilité des navigateurs -
+{{Compat("javascript.builtins.WebAssembly.Table.get")}} +## Voir aussi -

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

-
- -

Voir aussi

- - +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index d5356522b6..9b8745086b 100644 --- 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 @@ -11,70 +11,55 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/grow original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/grow --- -
{{JSRef}}
+{{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é.

+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

+## Syntaxe -
table.grow(nombre);
-
+ table.grow(nombre); -

Paramètres

+### Paramètres -
-
nombre
-
Le nombre d'éléments qu'on souhaite ajouter au tableau.
-
+- `nombre` + - : Le nombre d'éléments qu'on souhaite ajouter au tableau. -

Valeur de retour

+### Valeur de retour -

La taille du tableau avant l'agrandissement.

+La taille du tableau avant l'agrandissement. -

Exceptions

+### Exceptions -

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

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

Exemples

+## 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.

+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 });
+```js +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() :

+On étend ensuite le tableau d'une unité en utilisant la méthode `grow()` : -
console.log(table.length);   // "2"
+```js
+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

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------------------------------- | ------------------------------------ | -------------------------------------------------- | +| {{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 + +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index 27df06ebb6..6e2380a974 100644 --- a/files/fr/web/javascript/reference/global_objects/webassembly/table/index.md +++ b/files/fr/web/javascript/reference/global_objects/webassembly/table/index.md @@ -11,124 +11,104 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table --- -
{{JSRef}}
+{{JSRef}} -

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

+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.

+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.

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

Syntaxe

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

Paramètres

+### 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.
-
-
-
+- `descripteurTableau` -

Exceptions

+ - : Un objet composé des propriétés qui suivent : -
    -
  • Si tableDescriptor n'est pas un objet, une exception {{jsxref("TypeError")}} sera levée.
    • -
  • Si maximum est défini et est inférieur à initial, une exception {{jsxref("RangeError")}} sera levée.
    • -
+ - `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. -

Instances de Table

+### Exceptions -

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.

+- Si `tableDescriptor` n'est pas un objet, une exception {{jsxref("TypeError")}} sera levée. +- Si `maximum` est défini et est inférieur à `initial`, une exception {{jsxref("RangeError")}} sera levée. -

Propriétés

+## Instances de `Table` -
-
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.
-
+Toutes les instances `Table` héritent des propriétés [du prototype du constructeur](/fr/docs/Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/prototype) `Table()`. Ce dernier peut être utilisé afin de modifier l'ensemble des instances `Table`. -

Méthodes

+### Propriétés -
-
{{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.
-
+- `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. -

Exemples

+### Méthodes -

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")}}).

+- {{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 ` Tabl``e ` 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. -
var tbl = new WebAssembly.Table({initial:2, element:"anyfunc"});
+## Exemples
+
+Dans l'exemple qui suit (tiré du fichier [table2.html](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/table2.html) et qui dispose [d'une démonstration](https://mdn.github.io/webassembly-examples/js-api-examples/table2.html)), 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")}}).
+
+```js
+var tbl = new WebAssembly.Table({initial:2, element:"anyfunc"});
 console.log(tbl.length);
 console.log(tbl.get(0));
-console.log(tbl.get(1));
+console.log(tbl.get(1)); +``` -

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

+Ensuite, on crée un objet d'import qui contient une référence au tableau : -
var importObj = {
+```js
+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 :

+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](https://github.com/mdn/webassembly-examples/blob/0991effbbf2e2cce38a7dbadebd2f3495e3f4e07/js-api-examples/table2.wat)). Chacune de ces fonctions fournit une valeur simple : -
WebAssembly.instantiateStreaming(fetch('table2.wasm'), importObject)
+```js
+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

- - +}); +``` + +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 | État | Commentaires | +| -------------------------------------------------------------------------------------------- | ------------------------------------ | ------------------------------------------------- | +| {{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 + +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index 878447d1e1..6812a496a5 100644 --- 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 @@ -11,55 +11,42 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/length original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/length --- -
{{JSRef}}
+{{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.

+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

+## Syntaxe -
table.length;
-
+ table.length; -

Exemples

+## 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.

+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 });
+```js +var table = new WebAssembly.Table({ element: "anyfunc", initial: 2, maximum: 10 }); +``` -

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

+On peut ensuite étendre le tableau d'un élément : -
console.log(table.length);   // "2"
+```js
+console.log(table.length);   // "2"
 console.log(table.grow(1));  // "2"
 console.log(table.length);   // "3"
-
+``` -

Spécifications

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

Compatibilité des navigateurs

+## Compatibilité des navigateurs -

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

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

Voir aussi

+## Voir aussi - +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index 5413168f5e..4b1ca9f3f1 100644 --- 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 @@ -11,92 +11,78 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/set original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/Table/set --- -
{{JSRef}}
+{{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.

+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

+## Syntaxe -
table.set(index, valeur);
-
+ table.set(index, valeur); -

Paramètres

+### 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).
-
+- `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](/fr/docs/WebAssembly/Exported_functions) (c'est-à-dire une enveloppe JavaScript représentant une fonction WebAssembly sous-jacente). -

Valeur de retour

+### Valeur de retour -

Aucune.

+Aucune. -

Exceptions

+### Exceptions -
    -
  • Si index est supérieur ou égal à {{jsxref("WebAssembly/Table/length","Table.prototype.length")}}, une exception {{jsxref("RangeError")}} sera levée.
    • -
  • Si valeur n'est pas une fonction WebAssembly exportée ou la valeur {{jsxref("null")}}, une exception {{jsxref("TypeError")}} sera levée.
    • -
+- Si `index` est supérieur ou égal à {{jsxref("WebAssembly/Table/length","Table.prototype.length")}}, une exception {{jsxref("RangeError")}} sera levée. +- Si `valeur` n'est pas une fonction WebAssembly exportée ou la valeur {{jsxref("null")}}, une exception {{jsxref("TypeError")}} sera levée. -

Exemples

+## 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")}}).

+Dans l'exemple qui suit (basé sur le [code source de `table2.html`](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/table2.html) et qui dispose [d'une démonstration](https://mdn.github.io/webassembly-examples/js-api-examples/table2.html)), 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"});
+```js
+var tbl = new WebAssembly.Table({initial:2, element:"anyfunc"});
 console.log(tbl.length);
 console.log(tbl.get(0));
-console.log(tbl.get(1));
+console.log(tbl.get(1)); +``` -

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

+On crée ensuite un objet d'import qui contient une référence au tableau : -
var importObj = {
+```js
+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) :

+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](https://github.com/mdn/webassembly-examples/blob/master/text-format-examples/table2.was)) ajoute deux références de fonctions au tableau et chacune affiche une valeur simple) : -
WebAssembly.instantiateStreaming(fetch('table2.wasm'), importObject)
+```js
+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

- - +}); +``` + +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 | État | Commentaires | +| ------------------------------------------------------------------------------------------------ | ------------------------------------ | -------------------------------------------------- | +| {{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 + +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) 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 index df8887431d..2098e3eb62 100644 --- a/files/fr/web/javascript/reference/global_objects/webassembly/validate/index.md +++ b/files/fr/web/javascript/reference/global_objects/webassembly/validate/index.md @@ -10,69 +10,53 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/validate original_slug: Web/JavaScript/Reference/Objets_globaux/WebAssembly/validate --- -
{{JSRef}}
+{{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).

+La fonction **`WebAssembly.validate()`** permet de valider un [tableau typé](/fr/docs/Web/JavaScript/Tableaux_typés) 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

+## Syntaxe -
WebAssembly.validate(bufferSource);
+ WebAssembly.validate(bufferSource); -

Paramètres

+### Paramètres -
-
bufferSource
-
Un tableau typé ou un {{jsxref("ArrayBuffer")}} qui contient le bytecode du module qu'on souhaite valider.
-
+- `bufferSource` + - : Un [tableau typé](/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray) ou un {{jsxref("ArrayBuffer")}} qui contient le _bytecode_ du module qu'on souhaite valider. -

Valeur de retour

+### Valeur de retour -

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

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

Exceptions

+### 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.

+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

+## 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.

+Dans l'exemple suivant, (cf. le fichier `validate.html` du [code source](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/validate.html), ainsi que [l'exemple _live_](https://mdn.github.io/webassembly-examples/js-api-examples/validate.html)), 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 =>
+```js
+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

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| -------------------------------------------------------------------------------------------- | ------------------------------------ | -------------------------------------------------- | +| {{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 + +- [Le portail WebAssembly](/fr/docs/WebAssembly) +- [Les concepts relatifs à WebAssembly](/fr/docs/WebAssembly/Concepts) +- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API) -- cgit v1.2.3-54-g00ecf