recursal/MDN huggingface dataset:
Generator.prototype.throw()
===========================

La méthode **`throw()`** lève une erreur dans un générateur.

Syntaxe
-------


```js
gen.throw(exception);
```

### Paramètres

`exception`

L'exception à lever. On préfèrera généralement utiliser un objet qui est une instance d'`Error`.

### Valeur de retour

Un `Object` avec deux propriétés :

* `done` (un booléen)
    + Qui vaut `true` lorsque l'itérateur a fini de parcourir la suite. Dans ce cas, `value` correspondra éventuellement à la valeur de retour de l'itérateur.
    + Qui vaut `false` si l'itérateur a pu produire la prochaine valeur de la série.
* `value` : une valeur renvoyée par l'itérateur. Lorsque `done` vaut `true`, cette valeur peut être absente ou valoir `undefined`.
Exemples
--------

### Utiliser `throw()`

Dans l'exemple suivant, on utilise un générateur simple et on génère une exception grâce à la méthode `throw()`. Une exception peut être interceptée avec un bloc `try...catch` usuel.


```js
function\* gen() {
  while (true) {
    try {
      yield 42;
    } catch (e) {
      console.log("Erreur interceptée !");
    }
  }
}

var g = gen();
g.next();
// { value: 42, done: false }
g.throw(new Error("Quelque chose s'est mal passé"));
// "Erreur interceptée !"
// { value: 42, done: false }
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator.prototype.throw |

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

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

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

* `function*`
Generator.prototype.return()
============================

La méthode **`return()`** renvoie la valeur fournie et termine le générateur.

Syntaxe
-------


```js
gen.return(valeur);
```

### Paramètres

`valeur`

La valeur à renvoyer

### Valeur de retour

La valeur fournie comme argument.

Exemples
--------

### Utiliser `return()`

L'exemple suivant illustre une utilisation simple d'un générateur et de la méthode `return()`.


```js
function\* gen() {
  yield 1;
  yield 2;
  yield 3;
}

var g = gen();

g.next(); // { value: 1, done: false }
g.return("toto"); // { value: "toto", done: true }
g.next(); // { value: undefined, done: true }
```


**Note :** Si `done` vaut `true`, `return(valeur)` renverra la même chose que `next()` : `undefined`. Si aucun argument n'est fourni, la propriété `value` de l'objet renvoyé sera la même qu'avec un appel à `.next()`. Si un argument est fourni, c'est lui qui sera utilisé comme valeur pour l'attribut `value` du résultat.


```js
function\* gen() {
  yield 1;
  yield 2;
  yield 3;
}
var g = gen();
console.log(g.next()); // { value: 1; done: false}
console.log(g.next()); // { value: 2; done: false}
console.log(g.next()); // { value: 3; done: false}
console.log(g.next()); // { value: undefined; done: true}
console.log(g.return()); // { value: undefined; done: true}
console.log(g.return(1)); // { value: 1; done: true}
```


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

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator.prototype.return |

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

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

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

* `function*`
Atomics.or()
============

La méthode statique **`Atomics.or()`** calcule le résultat d'un OU binaire entre une valeur donnée et une valeur du tableau typé et y place le résultat obtenu. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.

Exemple interactif
------------------

Syntaxe
-------


```js
Atomics.or(typedArray, index, value);
```

### Paramètres

`typedArray`

Un tableau typé entier partagé parmi `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Int32Array` ou `Uint32Array`.

`index`

La position du tableau `typedArray` sur laquelle calculer le OU binaire.

`valeur`

Le nombre avec lequel calculer le OU binaire.

### Valeur de retour

L'ancienne valeur contenue à l'emplacement du tableau (`typedArray[index]`).

### Exceptions levées

* Cette méthode lève `TypeError` si le type de `typedArray` n'est pas un des types entiers autorisés.
* Cette méthode lève `TypeError` si `typedArray` n'est pas tableau typé partagé.
* Cette méthode lève `RangeError` si `index` est en dehors des limites de `typedArray`.
Description
-----------

L'opération binaire OU renvoie 1 si `a` ou `b` valent 1. La table de vérité de cette opération est :

| `a` | `b` | `a | b` |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |

Par exemple, un OU binaire appliqué entre 5 et 1 (`5 | 1`) renvoie `0101`, ce qui correspond à 5 en notation décimale.
```

5  0101
1  0001
   ----

5  0101
```

Exemples
--------


```js
var sab = new SharedArrayBuffer(1024);
var ta = new Uint8Array(sab);
ta[0] = 2;

Atomics.or(ta, 0, 1); // renvoie 2, l'ancienne valeur
Atomics.load(ta, 0); // 3
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.or |

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

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

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

* `Atomics`
* `Atomics.and()`
* `Atomics.xor()`
Atomics.sub()
=============

La méthode statique **`Atomics.sub()`** permet de soustraire une valeur donnée à une position donnée du tableau partagé. Elle renvoie l'ancienne valeur qui était contenue dans le tableau avant l'opération. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.

Exemple interactif
------------------

Syntaxe
-------


```js
Atomics.sub(typedArray, index, valeur);
```

### Paramètres

`typedArray`

Un tableau typé entier partagé parmi `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Int32Array` ou `Uint32Array`.

`index`

La position du tableau typé `typedArray` à laquelle on veut soustraire `valeur`.

`valeur`

La quantité qu'on souhaite soustraire.

### Valeur de retour

L'ancienne valeur qui était contenue à (`typedArray[index]`).

### Exceptions levées

* Cette méthode lève `TypeError` si le type de `typedArray` n'est pas un des types entiers autorisés.
* Cette méthode lève `TypeError` si `typedArray` n'est pas tableau typé partagé.
* Cette méthode lève `RangeError` si `index` est en dehors des limites de `typedArray`.
Exemples
--------


```js
var sab = new SharedArrayBuffer(1024);
var ta = new Uint8Array(sab);
ta[0] = 48;

Atomics.sub(ta, 0, 12); // renvoie 48, l'ancienne valeur
Atomics.load(ta, 0); // 36
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.sub |

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

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

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

* `Atomics`
* `Atomics.add()`
Atomics.waitAsync()
===================

La méthode statique **`Atomics.waitAsync()`** permet d'attendre de façon asynchrone à un emplacement de mémoire partagée et renvoie une promesse.

À la différence de `Atomics.wait()`, `waitAsync()` n'est pas bloquante et peut être utilisée sur le fil d'exécution principal.

**Note :** Cette opération ne fonctionne qu'avec un tableau typé partagé entier `Int32Array` ou `BigInt64Array`.

Syntaxe
-------


```js
Atomics.waitAsync(typedArray, index, value);
Atomics.waitAsync(typedArray, index, value, timeout);
```

### Paramètres

`typedArray`

Un tableau typé partagé de type `Int32Array` ou `BigInt64Array`.

`index`

La position au sein du tableau typé `typedArray` à laquelle on souhaite attendre.

`value`

La valeur attendue à tester.

`timeout` Facultatif

Le temps à attendre, exprimé en millisecondes. Par défaut, c'est la valeur `Infinity` qui est utilisée.

### Valeur de retour

Un objet `Promise` dont la valeur de résolution est l'un des objets suivants :


```js
{ async: false, value: 'ok' }
{ async: false, value: 'not-equal' }
{ async: false, value: 'timed-out' }
{ async: true, value: promise }
```

Exemples
--------

### Utiliser `waitAsync()`

Soit un tableau de mémoire partagée `Int32Array`.


```js
const sab = new SharedArrayBuffer(1024);
const int32 = new Int32Array(sab);
```


Un *thread* de lecture est en sommeil et attend la valeur 0 à l'emplacement 0. La promesse `resultat` est renvoyée immédiatement.


```js
const resultat = Atomics.waitAsync(int32, 0, 0, 1000);
// { async: true, value: promise }
```


Dans le *thread* de lecture ou dans un autre *thread*, on fait appel à l'emplacement mémoire 0 et la promesse peut être résolue avec `value: "ok"`.


```js
Atomics.notify(int32, 0);
// { async: false, value: "ok" }
```


Si la résolution ne founit pas `value: "ok"`, cela signifie que :

* La valeur située à cet emplacement de la mémoire partagée n'était pas la valeur attendue (`"not-equal"`)
* Ou que la durée d'attente a expiré (`"time-out"`).
Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.waitasync |

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

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

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

* `Atomics`
* `Atomics.wait()`
* `Atomics.notify()`
Atomics.compareExchange()
=========================

La méthode statique **`Atomics.compareExchange()`** échange une valeur d'un tableau à un emplacement donné si la valeur qui était dans le tableau correspond à une valeur donnée. Cette méthode renvoie l'ancienne valeur à cet emplacement, qu'il y ait eu remplacement ou non. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.

Exemple interactif
------------------

Syntaxe
-------


```js
Atomics.compareExchange(typedArray, index, valeurAttendue, valeurRemplacement);
```

### Paramètres

`typedArray`

Un tableau typé entier partagé parmi `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Int32Array` ou `Uint32Array`.

`index`

La position du tableau `typedArray` à laquelle on veut échanger les valeurs.

`valeurAttendue`

La valeur avec laquelle on teste l'égalité.

`valeurRemplacement`

Le nombre qu'on souhaite placer dans le tableau si l'ancienne valeur est égale avec `valeurAttendue`.

### Valeur de retour

L'ancienne valeur présente à `typedArray[index]`.

### Exceptions levées

* Cette méthode lève `TypeError` si le type de `typedArray` n'est pas un des types entiers autorisés.
* Cette méthode lève `TypeError` si `typedArray` n'est pas tableau typé partagé.
* Cette méthode lève `RangeError` si `index` est en dehors des limites de `typedArray`.
Exemples
--------


```js
var sab = new SharedArrayBuffer(1024);
var ta = new Uint8Array(sab);
ta[0] = 7;

Atomics.compareExchange(ta, 0, 7, 12); // renvoie 7, l'ancienne valeur
Atomics.load(ta, 0); // 12
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.compareexchange |

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

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

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

* `Atomics`
* `Atomics.exchange()`
Atomics.notify()
================

La méthode statique **`Atomics.notify()`** permet de réveiller des agents dormants qui sont dans la file d'attente.

**Note :** Cette opération ne fonctionne que sur un tableau typé partagé de type `Int32Array`.

Syntaxe
-------


```js
Atomics.notify(typedArray, index, count);
```

### Paramètres

`typedArray`

Un table typé partagé de type `Int32Array`.

`index`

La position sur le tableau `typedArray` pour laquelle réveiller les agents.

`count`

Le nombre d'agents dormants à réveiller.

### Valeur de retour

Le nombre d'agents réveillés.

### Exceptions levées

* Cette méthode lève `TypeError` si `typedArray` n'est pas un tableau typé partagé de type`Int32Array`.
* Cette méthode lève `RangeError` si `index` est en dehors des limites de `typedArray`.
Exemples
--------

Soit un tableau typé partagé `Int32Array`:


```js
var sab = new SharedArrayBuffer(1024);
var int32 = new Int32Array(sab);
```


Un *thread* de lecture est en sommeil et surveille l'emplacement 0 et s'attend à ce que la valeur soit 0. Tant que cette condition est vérifiée, l'exécution n'ira pas plus loin. Lorsque le *thread* d'écriture a enregistré une nouvelle valeur, le *thread* de lecture sera réveillé par le *thread* d'écriture et renverra la nouvelle valeur (123).


```js
Atomics.wait(int32, 0, 0);
console.log(int32[0]); // 123
```


Un *thread* d'écriture stocke une nouvelle valeur et notifie le *thread* de lecture une fois que la valeur a bien été écrite :


```js
console.log(int32[0]); // 0;
Atomics.store(int32, 0, 123);
Atomics.notify(int32, 0, 1);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.notify |

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

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

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

* `Atomics`
* `Atomics.wait()`
Atomics.and()
=============

La méthode statique **`Atomics.and()`** calcule un ET binaire avec une valeur donnée, à un emplacement donné du tableau. Elle renvoie l'ancienne valeur qui était contenue à cet emplacement. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.

Exemple interactif
------------------

Syntaxe
-------


```js
Atomics.and(typedArray, index, valeur);
```

### Paramètres

`typedArray`

Un tableau typé entier partagé parmi `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Int32Array` ou `Uint32Array`.

`index`

La position dans `typedArray` où calculer le ET binaire.

`valeur`

Le nombre avec lequel on souhaite calculer le ET binaire.

### Valeur de retour

L'ancienne valeur qui était contenue à (`typedArray[index]`).

### Exceptions levée

* Cette méthode lève `TypeError` si le type de `typedArray` n'est pas un des types entiers autorisés.
* Cette méthode lève `TypeError` si `typedArray` n'est pas tableau typé partagé.
* Cette méthode lève `RangeError` si `index` est en dehors des limites de `typedArray`.
Description
-----------

Un ET binaire fournit la valeur 1 uniquement si `a` et `b` valent 1. La table de vérité pour l'opération ET est :

| `a` | `b` | `a & b` |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |

Ainsi, si on calcule le ET binaire de 5 et 1 avec l'instruction `5 & 1`, cela fournira la valeur `0001`, qui correspond à 1 en notation décimale.
```

5  0101
1  0001
   ----

1  0001
```

Exemples
--------


```js
var sab = new SharedArrayBuffer(1024);
var ta = new Uint8Array(sab);
ta[0] = 5;

Atomics.and(ta, 0, 1); // renvoie 0, l'ancienne valeur
Atomics.load(ta, 0); // 1
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.and |

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

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

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

* `Atomics`
* `Atomics.or()`
* `Atomics.xor()`
Atomics.wait()
==============

La méthode statique **`Atomics.wait()`** permet de vérifier qu'un emplacement d'un tableau `Int32Array` contient toujours une valeur donnée et, si c'est le cas, l'agent dort en attendant un réveil ou un délai d'expiration. La méthode renvoie une chaîne qui vaut `"ok"`, `"not-equal"` ou `"timed-out"`.

**Note :** Cette opération ne fonctionne qu'avec un tableau typé partagé `Int32Array` et peut ne pas être autorisée sur le *thread* principal.

Syntaxe
-------


```js
Atomics.wait(typedArray, index, valeur[, timeout])
```

### Paramètres

`typedArray`

Un tableau typé partagé de type `Int32Array`.

`index`

La position du tableau typé `typedArray` sur laquelle on attend un changement.

`valeur`

La valeur attendue qu'on souhaite tester.

`timeout` Facultatif

Le temps à attendre pour le changement de valeur, exprimé en millisecondes. La valeur par défaut est `Infinity`.

### Valeur de retour

Une chaîne de caractères (`String` qui vaut `"ok"`, `"not-equal"` ou `"timed-out"` selon le cas.

### Exceptions levées

* Cette méthode lève `TypeError` si `typedArray` n'est pas un tableau typé partagé de type `Int32Array`.
* Cette méthode lève `RangeError` si `index` est en dehors des limites de `typedArray`.
Exemples
--------

Soit un tableau typé partagé `Int32Array`:


```js
var sab = new SharedArrayBuffer(1024);
var int32 = new Int32Array(sab);
```


Un *thread* de lecture est en sommeille et surveille l'emplacement 0 et s'attend à ce que la valeur soit 0. Tant que cette condition est vérifiée, l'exécution n'ira pas plus loin. Lorsque le *thread* d'écriture a enregistré une nouvelle valeur, le *thread* de lecture sera notifié par le *thread* d'écriture et renverra la nouvelle valeur (123).


```js
Atomics.wait(int32, 0, 0);
console.log(int32[0]); // 123
```


Un *thread* d'écriture stocke une nouvelle valeur et notifie le *thread* de lecture une fois que la valeur a bien été écrite :


```js
console.log(int32[0]); // 0;
Atomics.store(int32, 0, 123);
Atomics.notify(int32, 0, 1);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.wait |

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

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

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

* `Atomics`
* `Atomics.notify()`
Atomics.exchange()
==================

La méthode statique **`Atomics.exchange()`** permet d'enregistrer une valeur à une position donnée d'un tableau et de renvoyer l'ancienne valeur qui était contenue dans le tableau. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.

Exemple interactif
------------------

Syntaxe
-------


```js
Atomics.exchange(typedArray, index, valeur);
```

### Paramètres

`typedArray`

Un tableau typé entier partagé parmi `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Int32Array` ou `Uint32Array`.

`index`

La position dans le tableau `typedArray` à laquelle on veut placer `valeur`.

`valeur`

Le nombre qu'on souhaite échanger.

### Valeur de retour

L'ancienne valeur qui était contenue à (`typedArray[index]`).

### Exceptions levées

* Cette méthode lève `TypeError` si le type de `typedArray` n'est pas un des types entiers autorisés.
* Cette méthode lève `TypeError` si `typedArray` n'est pas tableau typé partagé.
* Cette méthode lève `RangeError` si `index` est en dehors des limites de `typedArray`.
Exemples
--------


```js
var sab = new SharedArrayBuffer(1024);
var ta = new Uint8Array(sab);

Atomics.exchange(ta, 0, 12); // renvoie 0, l'ancienne valeur
Atomics.load(ta, 0); // 12
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.exchange |

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

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

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

* `Atomics`
* `Atomics.compareExchange()`
Atomics.xor()
=============

La méthode statique **`Atomics.xor()`** calcule le résultat d'un OU exclusif (XOR) binaire entre une valeur donnée et une valeur du tableau partagé à un emplacement donné. Elle renvoie l'ancienne valeur qui était contenue à cette position. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.

Exemple interactif
------------------

Syntaxe
-------


```js
Atomics.xor(typedArray, index, valeur);
```

### Paramètres

`typedArray`

Un tableau typé entier partagé parmi `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Int32Array` ou `Uint32Array`.

`index`

La position du tableau `typedArray` à laquelle calculer le OU exclusif binaire.

`valeur`

La valeur avec laquelle on souhaite calculer le OU exclusif binaire.

### Valeur de retour

L'ancienne valeur située à cet emplacement du tableau (`typedArray[index]`).

### Exceptions

* Cette méthode lève `TypeError` si le type de `typedArray` n'est pas un des types entiers autorisés.
* Cette méthode lève `TypeError` si `typedArray` n'est pas tableau typé partagé.
* Cette méthode lève `RangeError` si `index` est en dehors des limites de `typedArray`.
Description
-----------

L'opération binaire OU exclusif (XOR) renvoie 1 si `a` et `b` sont différents. La table de vérité correspondante est :

| `a` | `b` | `a ^ b` |
| --- | --- | --- |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |

Par exemple, le calcul d'un OU exclusif binaire entre 5 et 1 (`5 ^ 1`) renvoie `0100`, qui correspond à 4 en notation décimale.
```

5  0101
1  0001
   ----

4  0100
```

Exemples
--------


```js
var sab = new SharedArrayBuffer(1024);
var ta = new Uint8Array(sab);
ta[0] = 5;

Atomics.xor(ta, 0, 1); // renvoie 5, l'ancienne valeur
Atomics.load(ta, 0); // 4
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.xor |

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

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

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

* `Atomics`
* `Atomics.and()`
* `Atomics.or()`
Atomics.isLockFree()
====================

La méthode statique **`Atomics.isLockFree()`** est utilisée afin de déterminer si on doit utiliser des verrous (*locks*) ou des opérations atomiques. Elle renvoie `true` si la taille donnée correspond à une des propriétés `BYTES_PER_ELEMENT` d'un des types `TypedArray`.

Exemple interactif
------------------

Syntaxe
-------


```js
Atomics.isLockFree(taille);
```

### Paramètres

`taille`

La taille en octets qu'on souhaite vérifier.

### Valeur de retour

Un booléen indiquant si l'opération se déroule sans verrou.

Exemples
--------


```js
Atomics.isLockFree(1); // true
Atomics.isLockFree(2); // true
Atomics.isLockFree(3); // false
Atomics.isLockFree(4); // true
Atomics.isLockFree(5); // false
Atomics.isLockFree(6); // false
Atomics.isLockFree(7); // false
Atomics.isLockFree(8); // true
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.islockfree |

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

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

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

* `Atomics`
Atomics.load()
==============

La méthode statique **`Atomics.load()`** renvoie une valeur située à une position donnée du tableau.

Exemple interactif
------------------

Syntaxe
-------


```js
Atomics.load(typedArray, index);
```

### Paramètres

`typedArray`

Un tableau typé entier partagé parmi `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Int32Array` ou `Uint32Array`.

`index`

La position du tableau `typedArray` qu'on souhaite charger.

### Valeur de retour

La valeur à la position indiquée (`typedArray[index]`).

### Exceptions levées

* Cette méthode lève `TypeError` si le type de `typedArray` n'est pas un des types entiers autorisés.
* Cette méthode lève `TypeError` si `typedArray` n'est pas tableau typé partagé.
* Cette méthode lève `RangeError` si `index` est en dehors des limites de `typedArray`.
Exemples
--------


```js
var sab = new SharedArrayBuffer(1024);
var ta = new Uint8Array(sab);

Atomics.add(ta, 0, 12);
Atomics.load(ta, 0); // 12
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.load |

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

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

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

* `Atomics`
* `Atomics.store()`