recursal/MDN huggingface dataset:
WebAssembly.Instance.prototype.exports
======================================

La propriété **`exports`** du prototype de `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.


```js
instance.exports;
```

Exemples
--------

Après avoir récupéré le *bytecode* WebAssembly grâce à la méthode `fetch()`, on le compile et on instancie le module grâce à la fonction `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.


```js
var importObject = {
  imports: {
    imported\_func: function (arg) {
      console.log(arg);
    },
  },
};
WebAssembly.instantiateStreaming(fetch("simple.wasm"), importObject).then(
  (obj) => obj.instance.exports.exported\_func(),
);
```


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

Spécifications
--------------

| Specification |
| --- |
| WebAssembly JavaScript Interface # dom-instance-exports |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* Le portail WebAssembly
* Les concepts relatifs à WebAssembly
* Utiliser l'API JavaScript WebAssembly
WebAssembly.Memory.prototype.grow()
===================================

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

Syntaxe
-------


```js
memory.grow(nombre);
```

### Paramètres

`nombre`

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

### Valeur de retour

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

Exemples
--------

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


```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 :


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

| Specification |
| --- |
| WebAssembly JavaScript Interface # dom-memory-grow |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* Le portail WebAssembly
* Les concepts relatifs à WebAssembly
* Utiliser l'API JavaScript WebAssembly
WebAssembly.Memory.prototype.buffer
===================================

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

Syntaxe
-------


```js
memory.buffer;
```

Exemples
--------

Dans l'exemple suivant (cf. le fichier memory.html sur GitHub ainsi que le résultat obtenu), on récupère puis on instancie le *bytecode* `memory.wasm` grâce à la méthode `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.


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

Spécifications
--------------

| Specification |
| --- |
| WebAssembly JavaScript Interface # dom-memory-buffer |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* Le portail WebAssembly
* Les concepts relatifs à WebAssembly
* Utiliser l'API JavaScript WebAssembly
WebAssembly.Module.imports()
============================

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

Syntaxe
-------


```js
WebAssembly.Module.imports(module)
```

### Paramètres

`module`

Une instance de `WebAssembly.Module`.

### Valeur de retour

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

### Exceptions

Si `module` n'est pas une instance de `WebAssembly.Module`, une exception `TypeError` sera levée.

Exemples
--------

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


```js
WebAssembly.compileStreaming(fetch("simple.wasm")).then((mod) => {
  const imports = WebAssembly.Module.imports(mod);
  console.log(imports[0]);
});
```


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


```js
{ module: "imports", name: "imported\_func", kind: "function" }
```

Spécifications
--------------

| Specification |
| --- |
| WebAssembly JavaScript Interface # dom-module-imports |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* Le portail WebAssembly
* Les concepts relatifs à WebAssembly
* Utiliser l'API JavaScript WebAssembly
Constructeur WebAssembly.Module()
=================================

Le constructeur **`WebAssembly.Module()`** crée un nouvel objet `Module` contenant du code WebAssembly sans état qui a déjà été compilé par le navigateur et qui peut efficacement être partagé avec des workers et être instancié plusieurs fois.

Le constructeur `WebAssembly.Module()` peut être appelé de façon synchrone afin de compiler le code binaire WebAssembly correspondant. Toutefois, la méthode principale pour obtenir un `Module` consiste à utiliser une fonction de compilation asynchrone comme `WebAssembly.compile()`.

Syntaxe
-------

**Attention :** Étant donné que la compilation de grands modules peut être coûteuse, il est préférable d'utiliser `Module()` uniquement lorsqu'une compilation synchrone est nécessaire. Dans tous les autres cas, on privilégiera la méthode `WebAssembly.compileStreaming()`.


```js
new WebAssembly.Module(bufferSource);
```

### Parameters

*bufferSource*

Un tableau typé ou un `ArrayBuffer` contenant le code binaire du module .wasm qu'on souhaite compiler.

Exemples
--------

### Compiler un module WebAssembly de façon synchrone


```js
var importObject = {
  imports: {
    imported\_func: function (arg) {
      console.log(arg);
    },
  },
};

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

fetch("simple.wasm")
  .then((response) => response.arrayBuffer())
  .then((bytes) => {
    let mod = createWasmModule(bytes);
    WebAssembly.instantiate(mod, importObject).then((result) =>
      result.exports.exported\_func(),
    );
  });
```

Spécifications
--------------

| Specification |
| --- |
| WebAssembly JavaScript Interface # dom-module-module |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* La page WebAssembly
* Concepts WebAssembly
* Utiliser l'API JavaScript WebAssembly
WebAssembly.Module.exports()
============================

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

Syntaxe
-------


```js
WebAssembly.Module.exports(module)
```

### Paramètres

`module`

Un objet `WebAssembly.Module`.

### Valeur de retour

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

### Exceptions

Si l'argument n'est pas une instance de `WebAssembly.Module`, une exception `TypeError` sera levée.

Exemples
--------

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


```js
const worker = new Worker("wasm\_worker.js");

WebAssembly.compileStreaming(fetch("simple.wasm")).then((mod) =>
  worker.postMessage(mod),
);
```


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


```js
const importObject = {
  imports: {
    imported\_func(arg) {
      console.log(arg);
    },
  },
};

onmessage = (e) => {
  console.log("module received from main thread");
  const mod = e.data;

  WebAssembly.instantiate(mod, importObject).then((instance) => {
    instance.exports.exported\_func();
  });

  const exports = WebAssembly.Module.exports(mod);
  console.log(exports[0]);
};
```


La valeur `exports[0]` ressemblera alors à :


```js
{ name: "exported\_func", kind: "function" }
```

Spécifications
--------------

| Specification |
| --- |
| WebAssembly JavaScript Interface # dom-module-exports |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* Le portail WebAssembly
* Les concepts relatifs à WebAssembly
* Utiliser l'API JavaScript WebAssembly
Constructeur WebAssembly.CompileError()
=======================================

Le constructeur **`WebAssembly.CompileError()`** crée un nouvel objet `CompileError` WebAssembly qui représente une erreur qui se produit lors du décodage ou de la validation du code WebAssembly.

Syntaxe
-------


```js
new WebAssembly.CompileError();
new WebAssembly.CompileError(message);
new WebAssembly.CompileError(message, nomFichier);
new WebAssembly.CompileError(message, nomFichier, numeroLigne);
```

### Paramètres

`message` Facultatif

Une description, compréhensible par un humain, de l'erreur.

`nomFichier` Facultatif

Le nom du fichier contenant le code qui a entraîné l'exception.

`numeroLigne` Facultatif

Le numéro de la ligne dans le fichier contenant le code qui a entraîné l'exception.

Exemples
--------

### Créer une nouvelle instance CompileError

Le fragment de code qui suit crée une nouvelle instance de `CompileError` et affiche les détails correspondant dans la console :


```js
try {
  throw new WebAssembly.CompileError("Coucou", "unFichier", 10);
} catch (e) {
  console.log(e instanceof CompileError); // true
  console.log(e.message); // "Coucou"
  console.log(e.name); // "CompileError"
  console.log(e.fileName); // "unFichier"
  console.log(e.lineNumber); // 10
  console.log(e.columnNumber); // 0
  console.log(e.stack); // renvoie l'emplacement du code exécuté
}
```

Spécifications
--------------

| Specification |
| --- |
| WebAssembly JavaScript Interface # exceptiondef-compileerror |
| ECMAScript Language Specification # sec-nativeerror-constructors |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* La page WebAssembly
* Concepts WebAssembly
* Utiliser l'API JavaScript WebAssembly
Constructeur WebAssembly.RuntimeError()
=======================================

Le constructeur **`WebAssembly.RuntimeError()`** crée un nouvel objet `RuntimeError` WebAssembly, une erreur levée quand WebAssembly définit une trappe.

Syntaxe
-------


```js
new WebAssembly.RuntimeError();
new WebAssembly.RuntimeError(message);
new WebAssembly.RuntimeError(message, nomFichier);
new WebAssembly.RuntimeError(message, nomFichier, numeroLigne);
```

### Paramètres

`message` Facultatif

Une description, compréhensible par un humain, de l'erreur.

`nomFichier` Facultatif

Le nom du fichier contenant le code qui a entraîné l'exception.

`numeroLigne` Facultatif

Le numéro de la ligne dans le fichier contenant le code qui a entraîné l'exception.

Exemples
--------

### Créer une nouvelle instance de RuntimeError

Le fragment de code qui suit crée une nouvelle instance de `RuntimeError` puis affiche ses informations dans la console :


```js
try {
  throw new WebAssembly.RuntimeError("Coucou", "unFichier", 10);
} catch (e) {
  console.log(e instanceof WebAssembly.RuntimeError); // true
  console.log(e.message); // "Coucou"
  console.log(e.name); // "RuntimeError"
  console.log(e.fileName); // "unFichier"
  console.log(e.lineNumber); // 10
  console.log(e.columnNumber); // 0
  console.log(e.stack); // renvoie l'emplacement du code exécuté
}
```

Spécifications
--------------

| Specification |
| --- |
| WebAssembly JavaScript Interface # exceptiondef-runtimeerror |
| ECMAScript Language Specification # sec-nativeerror-constructors |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* La page WebAssembly
* Concepts WebAssembly
* Utiliser l'API JavaScript WebAssembly
Constructeur WebAssembly.LinkError()
====================================

Le constructeur **`WebAssembly.LinkError()`** crée un nouvel objet `LinkError` WebAssembly qui indique une erreur lors de l'instanciation du module (en dehors des trapoess de la fonction de départ).

Syntaxe
-------


```js
new WebAssembly.LinkError();
new WebAssembly.LinkError(message);
new WebAssembly.LinkError(message, nomFichier);
new WebAssembly.LinkError(message, nomFichier, numeroLigne);
```

### Paramètres

`message` Facultatif

Une description, compréhensible par un humain, de l'erreur.

`nomFichier` Facultatif

Le nom du fichier contenant le code qui a entraîné l'exception.

`numeroLigne` Facultatif

Le numéro de la ligne dans le fichier contenant le code qui a entraîné l'exception.

Exemples
--------

### Créer une nouvelle instance de LinkError

Le fragment de code qui suit crée une nouvelle instance de `LinkError` et affiche les détails correspondant dans la console :


```js
try {
  throw new WebAssembly.LinkError("Coucou", "unFichier", 10);
} catch (e) {
  console.log(e instanceof LinkError); // true
  console.log(e.message); // "Coucou"
  console.log(e.name); // "LinkError"
  console.log(e.fileName); // "unFichier"
  console.log(e.lineNumber); // 10
  console.log(e.columnNumber); // 0
  console.log(e.stack); // renvoie l'emplacement du code exécuté
}
```

Spécifications
--------------

| Specification |
| --- |
| WebAssembly JavaScript Interface # exceptiondef-linkerror |
| ECMAScript Language Specification # sec-nativeerror-constructors |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* La page WebAssembly
* Concepts WebAssembly
* Utiliser l'API JavaScript WebAssembly
WebAssembly.Exception.prototype.is()
====================================

La méthode **`is()`**, rattachée au prototype d'un objet `Exception`, peut être utilisée afin de déterminer si l'objet `Exception` correspond à une balise donnée.

La méthode peut être utilisée afin de tester si une balise est correcte avant de la passer à `Exception.prototype.getArg()` pour obtenir les valeurs passées à l'exception. Elle peut être utilisée pour les balises créées côté JavaScript ou créées dans du code WebAssembly qui les exporte en JavaScript.

**Note :** Avoir la même séquence des mêmes types de données ne suffit pas. Il faut que la balise ait la même *identité* (que ce soit la même balise) que celle utilisée pour créer l'exception.

Syntaxe
-------


```js
is(tag);
```

### Paramètres

`tag`

Une balise WebAssembly, `WebAssembly.Tag`, qui peut être utilisée pour vérifier le type de l'exception.

### Valeur de retour

Un booléen qui indique si la balise fournie correspond à l'exception, `true` si c'est le cas, `false` sinon.

Exemples
--------

Le fragment de code qui suit illustre comment utiliser la méthode `is()` afin de vérifier qu'une balise correspond au type d'une `Exception`.


```js
// On crée la balise et on l'utilise pour créer une exception
const tag1 = new WebAssembly.Tag({ parameters: ["i32", "f64"] });
const exception1 = new WebAssembly.Exception(tag1, [42, 42.3]);

// On vérifie que "tag1" correspond pour cette exception
console.log(`Tag1 : ${exception1.is(tag1)}`);

// Affichage dans la console :
// Tag1 : true
```


On peut aussi montrer que l'exception ne correspondra pas à une autre balise, même si cette dernière utilise la même structure de paramètres.


```js
// On crée une nouvelle balise avec les mêmes paramètres
// et on vérifie qu'elle ne correspond pas
const tag2 = new WebAssembly.Tag({ parameters: ["i32", "f64"] });
console.log(`Tag2 : ${exception1.is(tag2)}`);

// Affichage dans la console :
// Tag2 : false
```

Spécifications
--------------

| Specification |
| --- |
| WebAssembly JavaScript Interface: Exception Handling # dom-exception-is |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* Aperçu général de WebAssembly
* Concepts WebAssembly
* Utiliser l'API JavaScript WebAssembly
Constructeur pour WebAssembly.Exception
=======================================

Le constructeur **`WebAssembly.Exception()`** permet de créer des objets `WebAssembly.Exception`.

Le constructeur prend comme arguments une balise `Tag` et un tableau `payload` de champs de données. Les types de données pour chaque élément du tableau `payload` doivent correspondre aux types de données définis par la balise `Tag`.

Il est aussi possible de passer comme argument un objet `options`. Pour cet objet, on peut passer la propriété `options.traceStack` à `true` (elle vaut `false` par défaut) afin d'indiquer que le code WebAssembly qui lève l'exception peut renseigner la propriété `stack` de l'exception avec la trace de la pile d'appels.

Syntaxe
-------


```js
new Exception(tag, payload, options);
```

### Paramètres

`tag`

Un objet `WebAssembly.Tag` qui définit les types de données attendus pour chaque valeur contenue dans `payload`.

`payload`

Un tableau contenant un ou plusieurs champs de données qui forment la charge utile de l'exception. Les types des éléments doivent correspondre à ceux décrits par la balise `tag`. Si le nombre de champs ou leurs types ne correspond pas, une exception `TypeError` sera levée.

`options` Facultatif

Un objet avec la propriété optionnelle suivante :

`traceStack` Facultatif

`true` si l'objet `Exception` peut avoir sa pile d'appels attachée via sa propriété `stack`, `false` sinon (qui correspond au comportement par défaut si `options` ou si `options.traceStack` n'est pas fourni).


### Exceptions

`TypeError`

Les séquences de valeurs pour `payload` et `tag` ne correspondent pas en nombre ou en type.

Exemples
--------

Dans cet exemple, on illustre la création d'une exception avec une balise simple.


```js
// On crée une balise et on l'utilise pour créer une exception
const tag = new WebAssembly.Tag({ parameters: ["i32", "f32"] });
const exception = new WebAssembly.Exception(tag, [42, 42.3]);
```


L'exemple contenu dans la page `stack` illustre la création d'une exception avec le paramètre `options`.

Spécifications
--------------

| Specification |
| --- |
| WebAssembly JavaScript Interface: Exception Handling # dom-exception-exception |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* Aperçu général de WebAssembly
* Concepts WebAssembly
* Utiliser l'API JavaScript WebAssembly
WebAssembly.Table.prototype.length
==================================

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

Syntaxe
-------


```js
table.length;
```

Exemples
--------

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


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


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


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

Spécifications
--------------

| Specification |
| --- |
| WebAssembly JavaScript Interface # dom-table-length |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* Le portail WebAssembly
* Les concepts relatifs à WebAssembly
* Utiliser l'API JavaScript WebAssembly