diff options
| author | julieng <julien.gattelier@gmail.com> | 2021-08-03 08:03:23 +0200 |
|---|---|---|
| committer | SphinxKnight <SphinxKnight@users.noreply.github.com> | 2021-09-03 08:08:25 +0200 |
| commit | bf8e099b9c8b3c60d60b3712b4fc97b052c39887 (patch) | |
| tree | c101746d082c9581c94f5937519c7d0e2f4af8cb /files/fr/web/javascript/reference/global_objects/atomics | |
| parent | 844f5103992238c0c23203286dad16a466e89c97 (diff) | |
| download | translated-content-bf8e099b9c8b3c60d60b3712b4fc97b052c39887.tar.gz translated-content-bf8e099b9c8b3c60d60b3712b4fc97b052c39887.tar.bz2 translated-content-bf8e099b9c8b3c60d60b3712b4fc97b052c39887.zip | |
convert content to md
Diffstat (limited to 'files/fr/web/javascript/reference/global_objects/atomics')
13 files changed, 620 insertions, 920 deletions
diff --git a/files/fr/web/javascript/reference/global_objects/atomics/add/index.md b/files/fr/web/javascript/reference/global_objects/atomics/add/index.md index d09496b255..9967dde934 100644 --- a/files/fr/web/javascript/reference/global_objects/atomics/add/index.md +++ b/files/fr/web/javascript/reference/global_objects/atomics/add/index.md @@ -10,72 +10,56 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/add original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/add --- -<div>{{JSRef}}</div> +{{JSRef}} -<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.add()</code></strong> ajoute une valeur donnée à un élément du tableau à une position donnée. 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.</p> +La méthode statique **`Atomics`\*\***`.add()`\*\* ajoute une valeur donnée à un élément du tableau à une position donnée. 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. -<div>{{EmbedInteractiveExample("pages/js/atomics-add.html")}}</div> +{{EmbedInteractiveExample("pages/js/atomics-add.html")}} -<h2 id="Syntaxe">Syntaxe</h2> +## Syntaxe -<pre class="syntaxbox">Atomics.add(typedArray, index, valeur) -</pre> + Atomics.add(typedArray, index, valeur) -<h3 id="Paramètres">Paramètres</h3> +### Paramètres -<dl> - <dt><code>typedArray</code></dt> - <dd>Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.</dd> - <dt><code>index</code></dt> - <dd>La position du tableau <code>typedArray</code> auquel on souhaite ajouter une <code>valeur</code>.</dd> - <dt><code>valeur</code></dt> - <dd>La valeur à ajouter.</dd> -</dl> +- `typedArray` + - : Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}. +- `index` + - : La position du tableau `typedArray` auquel on souhaite ajouter une `valeur`. +- `valeur` + - : La valeur à ajouter. -<h3 id="Valeur_de_retour">Valeur de retour</h3> +### Valeur de retour -<p>L'ancienne valeur qui était contenue à (<code>typedArray[index]</code>).</p> +L'ancienne valeur qui était contenue à (`typedArray[index]`). -<h3 id="Exceptions_levées">Exceptions levées</h3> +### Exceptions levées -<ul> - <li>Cette méthode lève {{jsxref("TypeError")}} si le type de <code>typedArray</code> n'est pas un des types entiers autorisés.</li> - <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas tableau typé partagé.</li> - <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li> -</ul> +- Cette méthode lève {{jsxref("TypeError")}} si le type de `typedArray` n'est pas un des types entiers autorisés. +- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas tableau typé partagé. +- Cette méthode lève {{jsxref("RangeError")}} si `index` est en dehors des limites de `typedArray`. -<h2 id="Exemples">Exemples</h2> +## Exemples -<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +```js +var sab = new SharedArrayBuffer(1024); var ta = new Uint8Array(sab); Atomics.add(ta, 0, 12); // renvoie 0, l'ancienne valeur -Atomics.load(ta, 0); // 12</pre> - -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">État</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-atomics.add', 'Atomics.add')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>Définition initiale avec ES2017.</td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - -<p>{{Compat("javascript.builtins.Atomics.add")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("Atomics")}}</li> - <li>{{jsxref("Atomics.sub()")}}</li> -</ul> +Atomics.load(ta, 0); // 12 +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | -------------------------------- | +| {{SpecName('ESDraft', '#sec-atomics.add', 'Atomics.add')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Atomics.add")}} + +## Voir aussi + +- {{jsxref("Atomics")}} +- {{jsxref("Atomics.sub()")}} diff --git a/files/fr/web/javascript/reference/global_objects/atomics/and/index.md b/files/fr/web/javascript/reference/global_objects/atomics/and/index.md index 80e18842ac..d3fba9dc8f 100644 --- a/files/fr/web/javascript/reference/global_objects/atomics/and/index.md +++ b/files/fr/web/javascript/reference/global_objects/atomics/and/index.md @@ -10,118 +10,76 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/and original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/and --- -<div>{{JSRef}}</div> - -<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.and()</code></strong> 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.</p> - -<div>{{EmbedInteractiveExample("pages/js/atomics-and.html")}}</div> - -<h2 id="Syntaxe">Syntaxe</h2> - -<pre class="syntaxbox">Atomics.and(typedArray, index, valeur) -</pre> - -<h3 id="Paramètres">Paramètres</h3> - -<dl> - <dt><code>typedArray</code></dt> - <dd>Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.</dd> - <dt><code>index</code></dt> - <dd>La position dans <code>typedArray</code> où calculer le ET binaire.</dd> - <dt><code>valeur</code></dt> - <dd>Le nombre avec lequel on souhaite calculer le ET binaire.</dd> -</dl> - -<h3 id="Valeur_de_retour">Valeur de retour</h3> - -<p>L'ancienne valeur qui était contenue à (<code>typedArray[index]</code>).</p> - -<h3 id="Exceptions_levée">Exceptions levée</h3> - -<ul> - <li>Cette méthode lève {{jsxref("TypeError")}} si le type de <code>typedArray</code> n'est pas un des types entiers autorisés.</li> - <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas tableau typé partagé.</li> - <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li> -</ul> - -<h2 id="Description">Description</h2> - -<p>Un ET binaire fournit la valeur 1 uniquement si <code>a</code> et <code>b</code> valent 1. La table de vérité pour l'opération ET est :</p> - -<table class="standard-table"> - <thead> - <tr> - <th><code>a</code></th> - <th><code>b</code></th> - <th><code>a & b</code></th> - </tr> - </thead> - <tbody> - <tr> - <td>0</td> - <td>0</td> - <td>0</td> - </tr> - <tr> - <td>0</td> - <td>1</td> - <td>0</td> - </tr> - <tr> - <td>1</td> - <td>0</td> - <td>0</td> - </tr> - <tr> - <td>1</td> - <td>1</td> - <td>1</td> - </tr> - </tbody> -</table> - -<p>Ainsi, si on calcule le ET binaire de 5 et 1 avec l'instruction <code>5 & 1</code>, cela fournira la valeur <code>0001</code>, qui correspond à 1 en notation décimale.</p> - -<pre>5 0101 -1 0001 - ---- -1 0001</pre> - -<h2 id="Exemples">Exemples</h2> - -<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +{{JSRef}} + +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. + +{{EmbedInteractiveExample("pages/js/atomics-and.html")}} + +## Syntaxe + + Atomics.and(typedArray, index, valeur) + +### Paramètres + +- `typedArray` + - : Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("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 {{jsxref("TypeError")}} si le type de `typedArray` n'est pas un des types entiers autorisés. +- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas tableau typé partagé. +- Cette méthode lève {{jsxref("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 -</pre> - -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">État</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-atomics.and', 'Atomics.and')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>Définition initiale avec ES2017.</td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - -<p>{{Compat("javascript.builtins.Atomics.and")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("Atomics")}}</li> - <li>{{jsxref("Atomics.or()")}}</li> - <li>{{jsxref("Atomics.xor()")}}</li> -</ul> +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | -------------------------------- | +| {{SpecName('ESDraft', '#sec-atomics.and', 'Atomics.and')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Atomics.and")}} + +## Voir aussi + +- {{jsxref("Atomics")}} +- {{jsxref("Atomics.or()")}} +- {{jsxref("Atomics.xor()")}} diff --git a/files/fr/web/javascript/reference/global_objects/atomics/compareexchange/index.md b/files/fr/web/javascript/reference/global_objects/atomics/compareexchange/index.md index add0ccdd87..e606b19bd4 100644 --- a/files/fr/web/javascript/reference/global_objects/atomics/compareexchange/index.md +++ b/files/fr/web/javascript/reference/global_objects/atomics/compareexchange/index.md @@ -10,75 +10,59 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/compareExchange original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/compareExchange --- -<div>{{JSRef}}</div> +{{JSRef}} -<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.compareExchange()</code></strong> é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.</p> +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. -<div>{{EmbedInteractiveExample("pages/js/atomics-compareexchange.html")}}</div> +{{EmbedInteractiveExample("pages/js/atomics-compareexchange.html")}} -<h2 id="Syntaxe">Syntaxe</h2> +## Syntaxe -<pre class="syntaxbox">Atomics.compareExchange(typedArray, index, valeurAttendue, valeurRemplacement) -</pre> + Atomics.compareExchange(typedArray, index, valeurAttendue, valeurRemplacement) -<h3 id="Paramètres">Paramètres</h3> +### Paramètres -<dl> - <dt><code>typedArray</code></dt> - <dd>Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.</dd> - <dt><code>index</code></dt> - <dd>La position du tableau <code>typedArray</code> à laquelle on veut échanger les valeurs.</dd> - <dt><code>valeurAttendue</code></dt> - <dd>La valeur avec laquelle on teste l'égalité.</dd> - <dt><code>valeurRemplacement</code></dt> - <dd>Le nombre qu'on souhaite placer dans le tableau si l'ancienne valeur est égale avec <code>valeurAttendue</code>.</dd> -</dl> +- `typedArray` + - : Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("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`. -<h3 id="Valeur_de_retour">Valeur de retour</h3> +### Valeur de retour -<p>L'ancienne valeur présente à <code>typedArray[index]</code>.</p> +L'ancienne valeur présente à `typedArray[index]`. -<h3 id="Exceptions_levées">Exceptions levées</h3> +### Exceptions levées -<ul> - <li>Cette méthode lève {{jsxref("TypeError")}} si le type de <code>typedArray</code> n'est pas un des types entiers autorisés.</li> - <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas tableau typé partagé.</li> - <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li> -</ul> +- Cette méthode lève {{jsxref("TypeError")}} si le type de `typedArray` n'est pas un des types entiers autorisés. +- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas tableau typé partagé. +- Cette méthode lève {{jsxref("RangeError")}} si `index` est en dehors des limites de `typedArray`. -<h2 id="Exemples">Exemples</h2> +## Exemples -<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +```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</pre> - -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">État</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-atomics.compareexchange', 'Atomics.compareExchange')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>Définition initiale avec ES2017.</td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - -<p>{{Compat("javascript.builtins.Atomics.compareExchange")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("Atomics")}}</li> - <li>{{jsxref("Atomics.exchange()")}}</li> -</ul> +Atomics.load(ta, 0); // 12 +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------------------- | +| {{SpecName('ESDraft', '#sec-atomics.compareexchange', 'Atomics.compareExchange')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Atomics.compareExchange")}} + +## Voir aussi + +- {{jsxref("Atomics")}} +- {{jsxref("Atomics.exchange()")}} diff --git a/files/fr/web/javascript/reference/global_objects/atomics/exchange/index.md b/files/fr/web/javascript/reference/global_objects/atomics/exchange/index.md index 7a01cb04b1..05b78da455 100644 --- a/files/fr/web/javascript/reference/global_objects/atomics/exchange/index.md +++ b/files/fr/web/javascript/reference/global_objects/atomics/exchange/index.md @@ -10,74 +10,56 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/exchange original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/exchange --- -<div>{{JSRef}}</div> +{{JSRef}} -<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.exchange()</code></strong> 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.</p> +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. -<div>{{EmbedInteractiveExample("pages/js/atomics-exchange.html")}}</div> +{{EmbedInteractiveExample("pages/js/atomics-exchange.html")}} -<h2 id="Syntaxe">Syntaxe</h2> +## Syntaxe -<pre class="syntaxbox">Atomics.exchange(typedArray, index, valeur) -</pre> + Atomics.exchange(typedArray, index, valeur) -<h3 id="Paramètres">Paramètres</h3> +### Paramètres -<dl> - <dt><code>typedArray</code></dt> - <dd>Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.</dd> - <dt><code>index</code></dt> - <dd>La position dans le tableau <code>typedArray</code> à laquelle on veut placer <code>valeur</code>.</dd> - <dt><code>valeur</code></dt> - <dd>Le nombre qu'on souhaite échanger.</dd> -</dl> +- `typedArray` + - : Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}. +- `index` + - : La position dans le tableau `typedArray` à laquelle on veut placer `valeur`. +- `valeur` + - : Le nombre qu'on souhaite échanger. -<h3 id="Valeur_de_retour">Valeur de retour</h3> +### Valeur de retour -<p>L'ancienne valeur qui était contenue à (<code>typedArray[index]</code>).</p> +L'ancienne valeur qui était contenue à (`typedArray[index]`). -<h3 id="Exceptions_levées">Exceptions levées</h3> +### Exceptions levées -<ul> - <li>Cette méthode lève {{jsxref("TypeError")}} si le type de <code>typedArray</code> n'est pas un des types entiers autorisés.</li> - <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas tableau typé partagé.</li> - <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li> -</ul> +- Cette méthode lève {{jsxref("TypeError")}} si le type de `typedArray` n'est pas un des types entiers autorisés. +- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas tableau typé partagé. +- Cette méthode lève {{jsxref("RangeError")}} si `index` est en dehors des limites de `typedArray`. -<h2 id="Exemples">Exemples</h2> +## Exemples -<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +```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</pre> +Atomics.load(ta, 0); // 12 +``` -<h2 id="Spécifications">Spécifications</h2> +## Spécifications -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">Statut</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-atomics.exchange', 'Atomics.exchange')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>Définition initiale avec ES2017.</td> - </tr> - </tbody> -</table> +| Spécification | Statut | Commentaires | +| -------------------------------------------------------------------------------------------- | ---------------------------- | -------------------------------- | +| {{SpecName('ESDraft', '#sec-atomics.exchange', 'Atomics.exchange')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. | -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> +## Compatibilité des navigateurs +{{Compat("javascript.builtins.Atomics.exchange")}} +## Voir aussi -<p>{{Compat("javascript.builtins.Atomics.exchange")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("Atomics")}}</li> - <li>{{jsxref("Atomics.compareExchange()")}}</li> -</ul> +- {{jsxref("Atomics")}} +- {{jsxref("Atomics.compareExchange()")}} diff --git a/files/fr/web/javascript/reference/global_objects/atomics/index.md b/files/fr/web/javascript/reference/global_objects/atomics/index.md index b358b66964..c9d61aaa85 100644 --- a/files/fr/web/javascript/reference/global_objects/atomics/index.md +++ b/files/fr/web/javascript/reference/global_objects/atomics/index.md @@ -8,107 +8,78 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Atomics original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics --- -<div>{{JSRef}}</div> - -<p>L'objet <strong><code>Atomics</code></strong> fournit des opérations atomiques sous la forme de méthodes statiques. Celles-ci sont utilisées avec les objets {{jsxref("SharedArrayBuffer")}}.</p> - -<p>Les opérations atomiques sont installées sur un module <code>Atomics</code>. À la différence des autres objets globaux, <code>Atomics</code> n'est pas un constructeur. Pour cette raison, il ne peut être utilisé avec l'opérateur {{jsxref("Opérateurs/L_opérateur_new")}} et il ne peut pas être appelé comme une fonction. Les propriétés et les méthodes d'<code>Atomics</code> sont statiques (<code>Atomics</code> fonctionne ainsi comme l'objet {{jsxref("Math")}}).</p> - -<h2 id="Propriétés">Propriétés</h2> - -<dl> - <dt><code>Atomics[Symbol.toStringTag]</code></dt> - <dd> - <p>La valeur de cette propriété vaut <code>"Atomics"</code>.</p> - </dd> -</dl> - -<h2 id="Méthodes">Méthodes</h2> - -<h3 id="Opérations_atomiques">Opérations atomiques</h3> - -<p>Lorsque la mémoire est partagée, plusieurs <em>threads</em> peuvent lire et écrire sur les mêmes données en mémoire. Les opérations atomiques permettent de s'assurer que des valeurs prévisibles sont écrites et lues, que les opérations sont finies avant que la prochaine débute et que les opérations ne sont pas interrompues.</p> - -<dl> - <dt>{{jsxref("Atomics.add()")}}</dt> - <dd>Cette méthode ajoute la valeur fournie à la position indiquée dans le tableau. Elle renvoie l'ancienne valeur qui était à cette position.</dd> - <dt>{{jsxref("Atomics.and()")}}</dt> - <dd>Cette méthode calcule un ET binaire sur la position indiquée dans le tableau. Elle renvoie l'ancienne valeur qui était à cette position.</dd> - <dt>{{jsxref("Atomics.compareExchange()")}}</dt> - <dd>Cette méthode stocke la valeur fournie à la position indiquée dans le tableau si elle est égale à une valeur donnée. Elle renvoie l'ancienne valeur.</dd> - <dt>{{jsxref("Atomics.exchange()")}}</dt> - <dd>Cette méthode stocke la valeur fournie à la position indiquée dans le tableau. Elle renvoie l'ancienne valeur.</dd> - <dt>{{jsxref("Atomics.load()")}}</dt> - <dd>Cette méthode renvoie la valeur à la position indiquée dans le tableau.</dd> - <dt>{{jsxref("Atomics.or()")}}</dt> - <dd>Cette méthode calcule un OU binaire entre la valeur fournie et la position indiquée dans le tableau. Elle renvoie l'ancienne valeur qui était à cette position.</dd> - <dt>{{jsxref("Atomics.store()")}}</dt> - <dd>Cette méthode stocke une valeur à une position indiquée dans le tableau. Elle renvoie la valeur.</dd> - <dt>{{jsxref("Atomics.sub()")}}</dt> - <dd>Cette méthode soustrait la valeur fournie à la position indiquée dans le tableau. Elle renvoie l'ancienne valeur qui était contenue à cette position.</dd> - <dt>{{jsxref("Atomics.xor()")}}</dt> - <dd>Cette méthode calcule un OU exclusif binaire sur une position donnée dans le tableau. Elle renvoie l'ancienne valeur qui était à cette position.</dd> -</dl> - -<h3 id="Attente_et_notification_(wait_et_notify)">Attente et notification (<code>wait</code> et <code>notify</code>)</h3> - -<p>Le méthodes <code>wait</code>() et <code>notify()</code> sont basées sur les <em>futex</em> Linux (selon le vocabulaire employé sur Linux où ça signifie « <em>fast user-space mutex</em> » ou encore « mutex rapide pour l'espace utilisateur ») fournissent des outils pour attendre jusqu'à ce qu'une condition donnée soit vérifiée. Généralement ces méthodes sont utilisées pour bloquer des opérations.</p> - -<dl> - <dt>{{jsxref("Atomics.wait()")}}</dt> - <dd>Cette méthode vérifie qu'une position donnée du tableau contient bien une valeur donnée puis dort ou expire. Elle renvoie une des chaînes suivantes <code>"ok"</code>, <code>"not-equal"</code>, <code>"timed-out"</code>. Si l'agent appelant ne permet pas d'attente, cela lèvera une exception <code>Error</code> (la plupart des navigateurs ne permettront pas que <code>futexWait()</code> soit utilisé sur le <em>thread</em> principal du navigateur).</dd> - <dt>{{jsxref("Atomics.notify()")}}</dt> - <dd>Cette méthode notifient les agents qui attendent dans la file d'attente à une position donnée. Elle renvoie le nombre d'agents notifiés.</dd> - <dt>{{jsxref("Atomics.isLockFree()")}}</dt> - <dd>Une primitive d'optimisation qui peut être utilisée afin de déterminer s'il faut utiliser des verrous (<em>locks</em>) ou des opérations atomiques. Elle renvoie <code>true</code> si la taille donnée est l'une des propriétés <code>BYTES_PER_ELEMENT</code> des types <code>TypedArray</code> et qu'on peut donc implémenter l'opération de façon atomique plutôt que d'utiliser un verrou.</dd> -</dl> - -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">État</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-atomics-object', 'Atomics')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td> </td> - </tr> - <tr> - <td>{{SpecName('ES8', '#sec-atomics-object', 'Atomics')}}</td> - <td>{{Spec2('ES8')}}</td> - <td>Définition initiale.</td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - -<p>{{Compat("javascript.builtins.Atomics")}}</p> - -<h3 id="Notes_de_compatibilité">Notes de compatibilité</h3> - -<p>Avant Firefox 48 {{geckoRelease(48)}}, les noms les plus récents et la sémantique la plus récente n'étaient pas encore implémentés. Les changements qui ont eu lieu entre la version 46 et la version 48 de Firefox sont :</p> - -<ul> - <li>Les méthodes <code>Atomics.futexWakeOrRequeue()</code> et <code>Atomics.fence()</code> sont désormais complètement retirées (cf. {{bug(1259544)}} et {{bug(1225028)}}).</li> - <li>Les méthodes {{jsxref("Atomics.wait()")}} et {{jsxref("Atomics.wake()")}} qui étaient nommées <code>Atomics.futexWait()</code> ete <code>Atomics.futexWake()</code> (cf. {{bug(1260910)}}). Les anciens noms seront définitivement supprimés à partir de la version 49 ({{bug(1262062)}}). <code>Atomics.wake()</code> a été renommé en <code>Atomics.notify()</code> à partir de la version 63.</li> - <li>Les propriétés <code>Atomics.OK</code>, <code>Atomics.TIMEDOUT</code>, <code>Atomics.NOTEQUAL</code> ont été retirées. La méthode {{jsxref("Atomics.wait()")}} renvoie désormais les chaînes de caractères <code>"ok"</code>, <code>"timed-out"</code> ou <code>"not-equal"</code> (cf. {{bug(1260835)}}).</li> - <li> - <p>Le paramètre <code>count</code> de la méthode {{jsxref("Atomics.wake()")}} a été modifié, sa valeur par défaut est désormais <code>+Infinity</code> et non <code>0</code> ({{bug(1253350)}}).</p> - </li> -</ul> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("ArrayBuffer")}}</li> - <li><a href="/fr/docs/Web/JavaScript/Tableaux_typés">Les tableaux typés en JavaScript</a></li> - <li><a href="/fr/docs/Web/API/Web_Workers_API">Web Workers</a></li> - <li><a href="https://github.com/lars-t-hansen/parlib-simple">parlib-simple </a>– un bibliothèque simple qui fournit des abstractions pour synchronisers et distribuer des tâches.</li> - <li><a href="https://github.com/tc39/ecmascript_sharedmem/blob/master/TUTORIAL.md">La mémoire partagée – un rapide tutoriel</a></li> - <li><a href="https://hacks.mozilla.org/2016/05/a-taste-of-javascripts-new-parallel-primitives/">A Taste of JavaScript’s New Parallel Primitives – Mozilla Hacks (en anglais)</a></li> -</ul> +{{JSRef}} + +L'objet **`Atomics`** fournit des opérations atomiques sous la forme de méthodes statiques. Celles-ci sont utilisées avec les objets {{jsxref("SharedArrayBuffer")}}. + +Les opérations atomiques sont installées sur un module `Atomics`. À la différence des autres objets globaux, `Atomics` n'est pas un constructeur. Pour cette raison, il ne peut être utilisé avec l'opérateur {{jsxref("Opérateurs/L_opérateur_new")}} et il ne peut pas être appelé comme une fonction. Les propriétés et les méthodes d'`Atomics` sont statiques (`Atomics` fonctionne ainsi comme l'objet {{jsxref("Math")}}). + +## Propriétés + +- `Atomics[Symbol.toStringTag]` + - : La valeur de cette propriété vaut `"Atomics"`. + +## Méthodes + +### Opérations atomiques + +Lorsque la mémoire est partagée, plusieurs _threads_ peuvent lire et écrire sur les mêmes données en mémoire. Les opérations atomiques permettent de s'assurer que des valeurs prévisibles sont écrites et lues, que les opérations sont finies avant que la prochaine débute et que les opérations ne sont pas interrompues. + +- {{jsxref("Atomics.add()")}} + - : Cette méthode ajoute la valeur fournie à la position indiquée dans le tableau. Elle renvoie l'ancienne valeur qui était à cette position. +- {{jsxref("Atomics.and()")}} + - : Cette méthode calcule un ET binaire sur la position indiquée dans le tableau. Elle renvoie l'ancienne valeur qui était à cette position. +- {{jsxref("Atomics.compareExchange()")}} + - : Cette méthode stocke la valeur fournie à la position indiquée dans le tableau si elle est égale à une valeur donnée. Elle renvoie l'ancienne valeur. +- {{jsxref("Atomics.exchange()")}} + - : Cette méthode stocke la valeur fournie à la position indiquée dans le tableau. Elle renvoie l'ancienne valeur. +- {{jsxref("Atomics.load()")}} + - : Cette méthode renvoie la valeur à la position indiquée dans le tableau. +- {{jsxref("Atomics.or()")}} + - : Cette méthode calcule un OU binaire entre la valeur fournie et la position indiquée dans le tableau. Elle renvoie l'ancienne valeur qui était à cette position. +- {{jsxref("Atomics.store()")}} + - : Cette méthode stocke une valeur à une position indiquée dans le tableau. Elle renvoie la valeur. +- {{jsxref("Atomics.sub()")}} + - : Cette méthode soustrait la valeur fournie à la position indiquée dans le tableau. Elle renvoie l'ancienne valeur qui était contenue à cette position. +- {{jsxref("Atomics.xor()")}} + - : Cette méthode calcule un OU exclusif binaire sur une position donnée dans le tableau. Elle renvoie l'ancienne valeur qui était à cette position. + +### Attente et notification (`wait` et `notify`) + +Le méthodes `wait`() et `notify()` sont basées sur les _futex_ Linux (selon le vocabulaire employé sur Linux où ça signifie « _fast user-space mutex_ » ou encore « mutex rapide pour l'espace utilisateur ») fournissent des outils pour attendre jusqu'à ce qu'une condition donnée soit vérifiée. Généralement ces méthodes sont utilisées pour bloquer des opérations. + +- {{jsxref("Atomics.wait()")}} + - : Cette méthode vérifie qu'une position donnée du tableau contient bien une valeur donnée puis dort ou expire. Elle renvoie une des chaînes suivantes `"ok"`, `"not-equal"`, `"timed-out"`. Si l'agent appelant ne permet pas d'attente, cela lèvera une exception `Error` (la plupart des navigateurs ne permettront pas que `futexWait()` soit utilisé sur le _thread_ principal du navigateur). +- {{jsxref("Atomics.notify()")}} + - : Cette méthode notifient les agents qui attendent dans la file d'attente à une position donnée. Elle renvoie le nombre d'agents notifiés. +- {{jsxref("Atomics.isLockFree()")}} + - : Une primitive d'optimisation qui peut être utilisée afin de déterminer s'il faut utiliser des verrous (_locks_) ou des opérations atomiques. Elle renvoie `true` si la taille donnée est l'une des propriétés `BYTES_PER_ELEMENT` des types `TypedArray` et qu'on peut donc implémenter l'opération de façon atomique plutôt que d'utiliser un verrou. + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- | +| {{SpecName('ESDraft', '#sec-atomics-object', 'Atomics')}} | {{Spec2('ESDraft')}} | | +| {{SpecName('ES8', '#sec-atomics-object', 'Atomics')}} | {{Spec2('ES8')}} | Définition initiale. | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Atomics")}} + +### Notes de compatibilité + +Avant Firefox 48 {{geckoRelease(48)}}, les noms les plus récents et la sémantique la plus récente n'étaient pas encore implémentés. Les changements qui ont eu lieu entre la version 46 et la version 48 de Firefox sont : + +- Les méthodes `Atomics.futexWakeOrRequeue()` et `Atomics.fence()` sont désormais complètement retirées (cf. {{bug(1259544)}} et {{bug(1225028)}}). +- Les méthodes {{jsxref("Atomics.wait()")}} et {{jsxref("Atomics.wake()")}} qui étaient nommées `Atomics.futexWait()` ete `Atomics.futexWake()` (cf. {{bug(1260910)}}). Les anciens noms seront définitivement supprimés à partir de la version 49 ({{bug(1262062)}}). `Atomics.wake()` a été renommé en `Atomics.notify()` à partir de la version 63. +- Les propriétés `Atomics.OK`, `Atomics.TIMEDOUT`, `Atomics.NOTEQUAL` ont été retirées. La méthode {{jsxref("Atomics.wait()")}} renvoie désormais les chaînes de caractères `"ok"`, `"timed-out"` ou `"not-equal"` (cf. {{bug(1260835)}}). +- Le paramètre `count` de la méthode {{jsxref("Atomics.wake()")}} a été modifié, sa valeur par défaut est désormais `+Infinity` et non `0` ({{bug(1253350)}}). + +## Voir aussi + +- {{jsxref("ArrayBuffer")}} +- [Les tableaux typés en JavaScript](/fr/docs/Web/JavaScript/Tableaux_typés) +- [Web Workers](/fr/docs/Web/API/Web_Workers_API) +- [parlib-simple ](https://github.com/lars-t-hansen/parlib-simple)– un bibliothèque simple qui fournit des abstractions pour synchronisers et distribuer des tâches. +- [La mémoire partagée – un rapide tutoriel](https://github.com/tc39/ecmascript_sharedmem/blob/master/TUTORIAL.md) +- [A Taste of JavaScript’s New Parallel Primitives – Mozilla Hacks (en anglais)](https://hacks.mozilla.org/2016/05/a-taste-of-javascripts-new-parallel-primitives/) diff --git a/files/fr/web/javascript/reference/global_objects/atomics/islockfree/index.md b/files/fr/web/javascript/reference/global_objects/atomics/islockfree/index.md index be1df1cda2..a13dde87ca 100644 --- a/files/fr/web/javascript/reference/global_objects/atomics/islockfree/index.md +++ b/files/fr/web/javascript/reference/global_objects/atomics/islockfree/index.md @@ -10,62 +10,48 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/isLockFree original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/isLockFree --- -<div>{{JSRef}}</div> +{{JSRef}} -<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.isLockFree()</code></strong> est utilisée afin de déterminer si on doit utiliser des verrous (<em>locks</em>) ou des opérations atomiques. Elle renvoie <code>true</code> si la taille donnée correspond à une des propriétés <code><a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray/BYTES_PER_ELEMENT">BYTES_PER_ELEMENT</a></code> d'un des types <code>TypedArray</code>.</p> +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`](/fr/docs/Web/JavaScript/Reference/Objets_globaux/TypedArray/BYTES_PER_ELEMENT) d'un des types `TypedArray`. -<div>{{EmbedInteractiveExample("pages/js/atomics-islockfree.html")}}</div> +{{EmbedInteractiveExample("pages/js/atomics-islockfree.html")}} -<h2 id="Syntaxe">Syntaxe</h2> +## Syntaxe -<pre class="syntaxbox">Atomics.isLockFree(taille) -</pre> + Atomics.isLockFree(taille) -<h3 id="Paramètres">Paramètres</h3> +### Paramètres -<dl> - <dt><code>taille</code></dt> - <dd>La taille en octets qu'on souhaite vérifier.</dd> -</dl> +- `taille` + - : La taille en octets qu'on souhaite vérifier. -<h3 id="Valeur_de_retour">Valeur de retour</h3> +### Valeur de retour -<p>Un {{jsxref("Boolean","booléen","",1)}} indiquant si l'opération se déroule sans verrou.</p> +Un {{jsxref("Boolean","booléen","",1)}} indiquant si l'opération se déroule sans verrou. -<h2 id="Exemples">Exemples</h2> +## Exemples -<pre class="brush: js">Atomics.isLockFree(1); // true +```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</pre> - -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">État</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-atomics.islockfree', 'Atomics.isLockFree')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>Définition initiale avec ES2017.</td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - -<p>{{Compat("javascript.builtins.Atomics.isLockFree")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("Atomics")}}</li> -</ul> +Atomics.isLockFree(8); // true +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------------------- | +| {{SpecName('ESDraft', '#sec-atomics.islockfree', 'Atomics.isLockFree')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Atomics.isLockFree")}} + +## Voir aussi + +- {{jsxref("Atomics")}} diff --git a/files/fr/web/javascript/reference/global_objects/atomics/load/index.md b/files/fr/web/javascript/reference/global_objects/atomics/load/index.md index 8e692f4ce8..9ada195398 100644 --- a/files/fr/web/javascript/reference/global_objects/atomics/load/index.md +++ b/files/fr/web/javascript/reference/global_objects/atomics/load/index.md @@ -10,70 +10,54 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/load original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/load --- -<div>{{JSRef}}</div> +{{JSRef}} -<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.load()</code></strong> renvoie une valeur située à une position donnée du tableau.</p> +La méthode statique **`Atomics`\*\***`.load()`\*\* renvoie une valeur située à une position donnée du tableau. -<div>{{EmbedInteractiveExample("pages/js/atomics-load.html")}}</div> +{{EmbedInteractiveExample("pages/js/atomics-load.html")}} -<h2 id="Syntaxe">Syntaxe</h2> +## Syntaxe -<pre class="syntaxbox">Atomics.load(typedArray, index) -</pre> + Atomics.load(typedArray, index) -<h3 id="Paramètres">Paramètres</h3> +### Paramètres -<dl> - <dt><code>typedArray</code></dt> - <dd>Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.</dd> - <dt><code>index</code></dt> - <dd>La position du tableau <code>typedArray</code> qu'on souhaite charger.</dd> -</dl> +- `typedArray` + - : Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}. +- `index` + - : La position du tableau `typedArray` qu'on souhaite charger. -<h3 id="Valeur_de_retour">Valeur de retour</h3> +### Valeur de retour -<p>La valeur à la position indiquée (<code>typedArray[index]</code>).</p> +La valeur à la position indiquée (`typedArray[index]`). -<h3 id="Exceptions_levées">Exceptions levées</h3> +### Exceptions levées -<ul> - <li>Cette méthode lève {{jsxref("TypeError")}} si le type de <code>typedArray</code> n'est pas un des types entiers autorisés.</li> - <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas tableau typé partagé.</li> - <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li> -</ul> +- Cette méthode lève {{jsxref("TypeError")}} si le type de `typedArray` n'est pas un des types entiers autorisés. +- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas tableau typé partagé. +- Cette méthode lève {{jsxref("RangeError")}} si `index` est en dehors des limites de `typedArray`. -<h2 id="Exemples">Exemples</h2> +## Exemples -<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +```js +var sab = new SharedArrayBuffer(1024); var ta = new Uint8Array(sab); Atomics.add(ta, 0, 12); -Atomics.load(ta, 0); // 12</pre> - -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">État</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-atomics.load', 'Atomics.load')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>Définition initiale avec ES2017.</td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - -<p>{{Compat("javascript.builtins.Atomics.load")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("Atomics")}}</li> - <li>{{jsxref("Atomics.store()")}}</li> -</ul> +Atomics.load(ta, 0); // 12 +``` + +## Spécifications + +| Spécification | État | Commentaires | +| -------------------------------------------------------------------------------- | ---------------------------- | -------------------------------- | +| {{SpecName('ESDraft', '#sec-atomics.load', 'Atomics.load')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Atomics.load")}} + +## Voir aussi + +- {{jsxref("Atomics")}} +- {{jsxref("Atomics.store()")}} diff --git a/files/fr/web/javascript/reference/global_objects/atomics/notify/index.md b/files/fr/web/javascript/reference/global_objects/atomics/notify/index.md index 81135aa541..ca6dd91a0a 100644 --- a/files/fr/web/javascript/reference/global_objects/atomics/notify/index.md +++ b/files/fr/web/javascript/reference/global_objects/atomics/notify/index.md @@ -10,84 +10,69 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/notify original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/notify --- -<div>{{JSRef}}</div> +{{JSRef}} -<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.notify()</code></strong> permet de réveiller des agents dormants qui sont dans la file d'attente.</p> +La méthode statique **`Atomics`\*\***`.notify()`\*\* permet de réveiller des agents dormants qui sont dans la file d'attente. -<div class="note"> -<p><strong>Note :</strong> Cette opération ne fonctionne que sur un tableau typé partagé de type {{jsxref("Int32Array")}}.</p> -</div> +> **Note :** Cette opération ne fonctionne que sur un tableau typé partagé de type {{jsxref("Int32Array")}}. -<h2 id="Syntaxe">Syntaxe</h2> +## Syntaxe -<pre class="syntaxbox">Atomics.notify(typedArray, index, count) -</pre> + Atomics.notify(typedArray, index, count) -<h3 id="Paramètres">Paramètres</h3> +### Paramètres -<dl> - <dt><code>typedArray</code></dt> - <dd>Un table typé partagé de type {{jsxref("Int32Array")}}.</dd> - <dt><code>index</code></dt> - <dd>La position sur le tableau <code>typedArray</code> pour laquelle réveiller les agents.</dd> - <dt><code>count</code></dt> - <dd>Le nombre d'agents dormants à réveiller.</dd> -</dl> +- `typedArray` + - : Un table typé partagé de type {{jsxref("Int32Array")}}. +- `index` + - : La position sur le tableau `typedArray` pour laquelle réveiller les agents. +- `count` + - : Le nombre d'agents dormants à réveiller. -<h3 id="Valeur_de_retour">Valeur de retour</h3> +### Valeur de retour -<p>Le nombre d'agents réveillés.</p> +Le nombre d'agents réveillés. -<h3 id="Exceptions_levées">Exceptions levées</h3> +### Exceptions levées -<ul> - <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas un tableau typé partagé de type{{jsxref("Int32Array")}}.</li> - <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li> -</ul> +- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas un tableau typé partagé de type{{jsxref("Int32Array")}}. +- Cette méthode lève {{jsxref("RangeError")}} si `index` est en dehors des limites de `typedArray`. -<h2 id="Exemples">Exemples</h2> +## Exemples -<p>Soit un tableau typé partagé <code>Int32Array</code>:</p> +Soit un tableau typé partagé `Int32Array`: -<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +```js +var sab = new SharedArrayBuffer(1024); var int32 = new Int32Array(sab); -</pre> +``` -<p>Un <em>thread</em> 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 <em>thread</em> d'écriture a enregistré une nouvelle valeur, le <em>thread</em> de lecture sera réveillé par le <em>thread</em> d'écriture et renverra la nouvelle valeur (123).</p> +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). -<pre class="brush: js">Atomics.wait(int32, 0, 0); -console.log(int32[0]); // 123</pre> +```js +Atomics.wait(int32, 0, 0); +console.log(int32[0]); // 123 +``` -<p>Un <em>thread</em> d'écriture stocke une nouvelle valeur et notifie le <em>thread</em> de lecture une fois que la valeur a bien été écrite :</p> +Un _thread_ d'écriture stocke une nouvelle valeur et notifie le _thread_ de lecture une fois que la valeur a bien été écrite : -<pre class="brush: js">console.log(int32[0]); // 0; +```js +console.log(int32[0]); // 0; Atomics.store(int32, 0, 123); -Atomics.notify(int32, 0, 1);</pre> - -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">Statut</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-atomics.notify', 'Atomics.notify')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>Définition initiale avec ES2017.</td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - -<p>{{Compat("javascript.builtins.Atomics.notify")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("Atomics")}}</li> - <li>{{jsxref("Atomics.wait()")}}</li> -</ul> +Atomics.notify(int32, 0, 1); +``` + +## Spécifications + +| Spécification | Statut | Commentaires | +| ------------------------------------------------------------------------------------ | ---------------------------- | -------------------------------- | +| {{SpecName('ESDraft', '#sec-atomics.notify', 'Atomics.notify')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Atomics.notify")}} + +## Voir aussi + +- {{jsxref("Atomics")}} +- {{jsxref("Atomics.wait()")}} diff --git a/files/fr/web/javascript/reference/global_objects/atomics/or/index.md b/files/fr/web/javascript/reference/global_objects/atomics/or/index.md index 0147a2d36e..26c37fcd96 100644 --- a/files/fr/web/javascript/reference/global_objects/atomics/or/index.md +++ b/files/fr/web/javascript/reference/global_objects/atomics/or/index.md @@ -10,118 +10,76 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/or original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/or --- -<div>{{JSRef}}</div> - -<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.or()</code></strong> 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.</p> - -<div>{{EmbedInteractiveExample("pages/js/atomics-or.html")}}</div> - -<h2 id="Syntaxe">Syntaxe</h2> - -<pre class="syntaxbox">Atomics.or(typedArray, index, value) -</pre> - -<h3 id="Paramètres">Paramètres</h3> - -<dl> - <dt><code>typedArray</code></dt> - <dd>Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.</dd> - <dt><code>index</code></dt> - <dd>La position du tableau <code>typedArray</code> sur laquelle calculer le OU binaire.</dd> - <dt><code>valeur</code></dt> - <dd>Le nombre avec lequel calculer le OU binaire.</dd> -</dl> - -<h3 id="Valeur_de_retour">Valeur de retour</h3> - -<p>L'ancienne valeur contenue à l'emplacement du tableau (<code>typedArray[index]</code>).</p> - -<h3 id="Exceptions_levées">Exceptions levées</h3> - -<ul> - <li>Cette méthode lève {{jsxref("TypeError")}} si le type de <code>typedArray</code> n'est pas un des types entiers autorisés.</li> - <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas tableau typé partagé.</li> - <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li> -</ul> - -<h2 id="Description">Description</h2> - -<p>L'opération binaire OU renvoie 1 si <code>a</code> ou <code>b</code> valent 1. La table de vérité de cette opération est :</p> - -<table class="standard-table"> - <thead> - <tr> - <th><code>a</code></th> - <th><code>b</code></th> - <th><code>a | b</code></th> - </tr> - </thead> - <tbody> - <tr> - <td>0</td> - <td>0</td> - <td>0</td> - </tr> - <tr> - <td>0</td> - <td>1</td> - <td>1</td> - </tr> - <tr> - <td>1</td> - <td>0</td> - <td>1</td> - </tr> - <tr> - <td>1</td> - <td>1</td> - <td>1</td> - </tr> - </tbody> -</table> - -<p>Par exemple, un OU binaire appliqué entre 5 et 1 (<code>5 | 1</code>) renvoie <code>0101</code>, ce qui correspond à 5 en notation décimale.</p> - -<pre>5 0101 -1 0001 - ---- -5 0101 -</pre> - -<h2 id="Exemples">Exemples</h2> - -<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +{{JSRef}} + +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. + +{{EmbedInteractiveExample("pages/js/atomics-or.html")}} + +## Syntaxe + + Atomics.or(typedArray, index, value) + +### Paramètres + +- `typedArray` + - : Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("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 {{jsxref("TypeError")}} si le type de `typedArray` n'est pas un des types entiers autorisés. +- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas tableau typé partagé. +- Cette méthode lève {{jsxref("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</pre> - -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">État</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-atomics.or', 'Atomics.or')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>Définition initiale avec 2017.</td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - -<p>{{Compat("javascript.builtins.Atomics.or")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("Atomics")}}</li> - <li>{{jsxref("Atomics.and()")}}</li> - <li>{{jsxref("Atomics.xor()")}}</li> -</ul> +Atomics.load(ta, 0); // 3 +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | ------------------------------ | +| {{SpecName('ESDraft', '#sec-atomics.or', 'Atomics.or')}} | {{Spec2('ESDraft')}} | Définition initiale avec 2017. | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Atomics.or")}} + +## Voir aussi + +- {{jsxref("Atomics")}} +- {{jsxref("Atomics.and()")}} +- {{jsxref("Atomics.xor()")}} diff --git a/files/fr/web/javascript/reference/global_objects/atomics/store/index.md b/files/fr/web/javascript/reference/global_objects/atomics/store/index.md index 4f31079d58..bb609861db 100644 --- a/files/fr/web/javascript/reference/global_objects/atomics/store/index.md +++ b/files/fr/web/javascript/reference/global_objects/atomics/store/index.md @@ -10,43 +10,39 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/store original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/store --- -<div>{{JSRef}}</div> +{{JSRef}} -<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.store()</code></strong> enregistre une valeur donnée à un emplacement donné du tableau partagé et renvoie cette valeur.</p> +La méthode statique **`Atomics`\*\***`.store()`\*\* enregistre une valeur donnée à un emplacement donné du tableau partagé et renvoie cette valeur. -<div>{{EmbedInteractiveExample("pages/js/atomics-store.html")}}</div> +{{EmbedInteractiveExample("pages/js/atomics-store.html")}} -<h2 id="Syntaxe">Syntaxe</h2> +## Syntaxe -<pre class="syntaxbox">Atomics.store(typedArray, index, valeur) -</pre> + Atomics.store(typedArray, index, valeur) -<h3 id="Paramètres">Paramètres</h3> +### Paramètres -<dl> - <dt><code>typedArray</code></dt> - <dd>Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.</dd> - <dt><code>index</code></dt> - <dd>La position du tableau <code>typedArray</code> à laquelle on souhaite stocker la valeur.</dd> - <dt><code>valeur</code></dt> - <dd>Le nombre à enregistrer.</dd> -</dl> +- `typedArray` + - : Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}. +- `index` + - : La position du tableau `typedArray` à laquelle on souhaite stocker la valeur. +- `valeur` + - : Le nombre à enregistrer. -<h3 id="Valeur_de_retour">Valeur de retour</h3> +### Valeur de retour -<p>La valeur qui a été enregistrée.</p> +La valeur qui a été enregistrée. -<h3 id="Exceptions">Exceptions</h3> +### Exceptions -<ul> - <li>Cette méthode lève {{jsxref("TypeError")}} si le type de <code>typedArray</code> n'est pas un des types entiers autorisés.</li> - <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas tableau typé partagé.</li> - <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li> -</ul> +- Cette méthode lève {{jsxref("TypeError")}} si le type de `typedArray` n'est pas un des types entiers autorisés. +- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas tableau typé partagé. +- Cette méthode lève {{jsxref("RangeError")}} si `index` est en dehors des limites de `typedArray`. -<h2 id="Exemples">Exemples</h2> +## Exemples -<pre class="brush: js">var buffer = new ArrayBuffer(4); // Buffer classique +```js +var buffer = new ArrayBuffer(4); // Buffer classique var float32 = new Float32Array(buffer); // Nombre flottant var uint32 = new Uint32Array(buffer); // Représentation IEEE754 @@ -55,33 +51,19 @@ console.log("0x" + uint32[0].toString(16)); uint32[0] = 0x3f000000; /// Représentation sur 32 bits de 0.5 (IEEE754) console.log(float32[0]); +``` -</pre> +## Spécifications -<h2 id="Spécifications">Spécifications</h2> +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------------------ | ---------------------------- | -------------------------------- | +| {{SpecName('ESDraft', '#sec-atomics.store', 'Atomics.store')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. | -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">État</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-atomics.store', 'Atomics.store')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>Définition initiale avec ES2017.</td> - </tr> - </tbody> -</table> +## Compatibilité des navigateurs -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> +{{Compat("javascript.builtins.Atomics.store")}} -<p>{{Compat("javascript.builtins.Atomics.store")}}</p> +## Voir aussi -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("Atomics")}}</li> - <li>{{jsxref("Atomics.load()")}}</li> -</ul> +- {{jsxref("Atomics")}} +- {{jsxref("Atomics.load()")}} diff --git a/files/fr/web/javascript/reference/global_objects/atomics/sub/index.md b/files/fr/web/javascript/reference/global_objects/atomics/sub/index.md index 313fc0577e..d219dfead1 100644 --- a/files/fr/web/javascript/reference/global_objects/atomics/sub/index.md +++ b/files/fr/web/javascript/reference/global_objects/atomics/sub/index.md @@ -10,74 +10,57 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/sub original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/sub --- -<div>{{JSRef}}</div> +{{JSRef}} -<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.sub()</code></strong> 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.</p> +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. -<div>{{EmbedInteractiveExample("pages/js/atomics-sub.html")}}</div> +{{EmbedInteractiveExample("pages/js/atomics-sub.html")}} -<h2 id="Syntaxe">Syntaxe</h2> +## Syntaxe -<pre class="syntaxbox">Atomics.sub(typedArray, index, valeur) -</pre> + Atomics.sub(typedArray, index, valeur) -<h3 id="Paramètres">Paramètres</h3> +### Paramètres -<dl> - <dt><code>typedArray</code></dt> - <dd>Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.</dd> - <dt><code>index</code></dt> - <dd>La position du tableau typé <code>typedArray</code> à laquelle on veut soustraire <code>valeur</code>.</dd> - <dt><code>valeur</code></dt> - <dd>La quantité qu'on souhaite soustraire.</dd> -</dl> +- `typedArray` + - : Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}. +- `index` + - : La position du tableau typé `typedArray` à laquelle on veut soustraire `valeur`. +- `valeur` + - : La quantité qu'on souhaite soustraire. -<h3 id="Valeur_de_retour">Valeur de retour</h3> +### Valeur de retour -<p>L'ancienne valeur qui était contenue à (<code>typedArray[index]</code>).</p> +L'ancienne valeur qui était contenue à (`typedArray[index]`). -<h3 id="Exceptions_levées">Exceptions levées</h3> +### Exceptions levées -<ul> - <li>Cette méthode lève {{jsxref("TypeError")}} si le type de <code>typedArray</code> n'est pas un des types entiers autorisés.</li> - <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas tableau typé partagé.</li> - <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li> -</ul> +- Cette méthode lève {{jsxref("TypeError")}} si le type de `typedArray` n'est pas un des types entiers autorisés. +- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas tableau typé partagé. +- Cette méthode lève {{jsxref("RangeError")}} si `index` est en dehors des limites de `typedArray`. -<h2 id="Exemples">Exemples</h2> +## Exemples -<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +```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 -</pre> - -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">État</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-atomics.sub', 'Atomics.sub')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>Définition initiale avec ES2017.</td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - -<p>{{Compat("javascript.builtins.Atomics.sub")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("Atomics")}}</li> - <li>{{jsxref("Atomics.add()")}}</li> -</ul> +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | -------------------------------- | +| {{SpecName('ESDraft', '#sec-atomics.sub', 'Atomics.sub')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Atomics.sub")}} + +## Voir aussi + +- {{jsxref("Atomics")}} +- {{jsxref("Atomics.add()")}} diff --git a/files/fr/web/javascript/reference/global_objects/atomics/wait/index.md b/files/fr/web/javascript/reference/global_objects/atomics/wait/index.md index 0a25246d86..ac14c69920 100644 --- a/files/fr/web/javascript/reference/global_objects/atomics/wait/index.md +++ b/files/fr/web/javascript/reference/global_objects/atomics/wait/index.md @@ -10,86 +10,71 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/wait original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/wait --- -<div>{{JSRef}}</div> +{{JSRef}} -<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.wait()</code></strong> permet de vérifier qu'un emplacement d'un tableau {{jsxref("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 <code>"ok"</code>, <code>"not-equal"</code> ou <code>"timed-out"</code>.</p> +La méthode statique **`Atomics`\*\***`.wait()`\*\* permet de vérifier qu'un emplacement d'un tableau {{jsxref("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"`. -<div class="note"> -<p><strong>Note :</strong> Cette opération ne fonctionne qu'avec un tableau typé partagé {{jsxref("Int32Array")}} et peut ne pas être autorisée sur le <em>thread</em> principal.</p> -</div> +> **Note :** Cette opération ne fonctionne qu'avec un tableau typé partagé {{jsxref("Int32Array")}} et peut ne pas être autorisée sur le _thread_ principal. -<h2 id="Syntaxe">Syntaxe</h2> +## Syntaxe -<pre class="syntaxbox">Atomics.wait(typedArray, index, valeur[, timeout]) -</pre> + Atomics.wait(typedArray, index, valeur[, timeout]) -<h3 id="Paramètres">Paramètres</h3> +### Paramètres -<dl> - <dt><code>typedArray</code></dt> - <dd>Un tableau typé partagé de type {{jsxref("Int32Array")}}.</dd> - <dt><code>index</code></dt> - <dd>La position du tableau typé <code>typedArray</code> sur laquelle on attend un changement.</dd> - <dt><code>valeur</code></dt> - <dd>La valeur attendue qu'on souhaite tester.</dd> - <dt><code>timeout</code> {{optional_inline}}</dt> - <dd>Le temps à attendre pour le changement de valeur, exprimé en millisecondes. La valeur par défaut est {{jsxref("Infinity")}}.</dd> -</dl> +- `typedArray` + - : Un tableau typé partagé de type {{jsxref("Int32Array")}}. +- `index` + - : La position du tableau typé `typedArray` sur laquelle on attend un changement. +- `valeur` + - : La valeur attendue qu'on souhaite tester. +- `timeout` {{optional_inline}} + - : Le temps à attendre pour le changement de valeur, exprimé en millisecondes. La valeur par défaut est {{jsxref("Infinity")}}. -<h3 id="Valeur_de_retour">Valeur de retour</h3> +### Valeur de retour -<p>Une chaîne de caractères ({{jsxref("String")}} qui vaut <code>"ok"</code>, <code>"not-equal"</code> ou <code>"timed-out"</code> selon le cas.</p> +Une chaîne de caractères ({{jsxref("String")}} qui vaut `"ok"`, `"not-equal"` ou `"timed-out"` selon le cas. -<h3 id="Exceptions_levées">Exceptions levées</h3> +### Exceptions levées -<ul> - <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas un tableau typé partagé de type {{jsxref("Int32Array")}}.</li> - <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li> -</ul> +- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas un tableau typé partagé de type {{jsxref("Int32Array")}}. +- Cette méthode lève {{jsxref("RangeError")}} si `index` est en dehors des limites de `typedArray`. -<h2 id="Exemples">Exemples</h2> +## Exemples -<p>Soit un tableau typé partagé <code>Int32Array</code>:</p> +Soit un tableau typé partagé `Int32Array`: -<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +```js +var sab = new SharedArrayBuffer(1024); var int32 = new Int32Array(sab); -</pre> +``` -<p>Un <em>thread</em> 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 <em>thread</em> d'écriture a enregistré une nouvelle valeur, le <em>thread</em> de lecture sera notifié par le <em>thread</em> d'écriture et renverra la nouvelle valeur (123).</p> +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). -<pre class="brush: js">Atomics.wait(int32, 0, 0); -console.log(int32[0]); // 123</pre> +```js +Atomics.wait(int32, 0, 0); +console.log(int32[0]); // 123 +``` -<p>Un <em>thread</em> d'écriture stocke une nouvelle valeur et notifie le <em>thread</em> de lecture une fois que la valeur a bien été écrite :</p> +Un _thread_ d'écriture stocke une nouvelle valeur et notifie le _thread_ de lecture une fois que la valeur a bien été écrite : -<pre class="brush: js">console.log(int32[0]); // 0; +```js +console.log(int32[0]); // 0; Atomics.store(int32, 0, 123); -Atomics.notify(int32, 0, 1);</pre> - -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">État</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-atomics.wait', 'Atomics.wait')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>Définition initiale avec ES2017.</td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - -<p>{{Compat("javascript.builtins.Atomics.wait")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("Atomics")}}</li> - <li>{{jsxref("Atomics.notify()")}}</li> -</ul> +Atomics.notify(int32, 0, 1); +``` + +## Spécifications + +| Spécification | État | Commentaires | +| -------------------------------------------------------------------------------- | ---------------------------- | -------------------------------- | +| {{SpecName('ESDraft', '#sec-atomics.wait', 'Atomics.wait')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Atomics.wait")}} + +## Voir aussi + +- {{jsxref("Atomics")}} +- {{jsxref("Atomics.notify()")}} diff --git a/files/fr/web/javascript/reference/global_objects/atomics/xor/index.md b/files/fr/web/javascript/reference/global_objects/atomics/xor/index.md index c3de46ad67..935579982a 100644 --- a/files/fr/web/javascript/reference/global_objects/atomics/xor/index.md +++ b/files/fr/web/javascript/reference/global_objects/atomics/xor/index.md @@ -10,118 +10,76 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/xor original_slug: Web/JavaScript/Reference/Objets_globaux/Atomics/xor --- -<div>{{JSRef}}</div> - -<p>La méthode statique <code><strong>Atomics</strong></code><strong><code>.xor()</code></strong> 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.</p> - -<div>{{EmbedInteractiveExample("pages/js/atomics-xor.html")}}</div> - -<h2 id="Syntaxe">Syntaxe</h2> - -<pre class="syntaxbox">Atomics.xor(typedArray, index, valeur) -</pre> - -<h3 id="Paramètres">Paramètres</h3> - -<dl> - <dt><code>typedArray</code></dt> - <dd>Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("Uint32Array")}}.</dd> - <dt><code>index</code></dt> - <dd>La position du tableau <code>typedArray</code> à laquelle calculer le OU exclusif binaire.</dd> - <dt><code>valeur</code></dt> - <dd>La valeur avec laquelle on souhaite calculer le OU exclusif binaire.</dd> -</dl> - -<h3 id="Valeur_de_retour">Valeur de retour</h3> - -<p>L'ancienne valeur située à cet emplacement du tableau (<code>typedArray[index]</code>).</p> - -<h3 id="Exceptions">Exceptions</h3> - -<ul> - <li>Cette méthode lève {{jsxref("TypeError")}} si le type de <code>typedArray</code> n'est pas un des types entiers autorisés.</li> - <li>Cette méthode lève {{jsxref("TypeError")}} si <code>typedArray</code> n'est pas tableau typé partagé.</li> - <li>Cette méthode lève {{jsxref("RangeError")}} si <code>index</code> est en dehors des limites de <code>typedArray</code>.</li> -</ul> - -<h2 id="Description">Description</h2> - -<p>L'opération binaire OU exclusif (XOR) renvoie 1 si <code>a</code> et <code>b</code> sont différents. La table de vérité correspondante est :</p> - -<table class="standard-table"> - <thead> - <tr> - <th><code>a</code></th> - <th><code>b</code></th> - <th><code>a ^ b</code></th> - </tr> - </thead> - <tbody> - <tr> - <td>0</td> - <td>0</td> - <td>0</td> - </tr> - <tr> - <td>0</td> - <td>1</td> - <td>1</td> - </tr> - <tr> - <td>1</td> - <td>0</td> - <td>1</td> - </tr> - <tr> - <td>1</td> - <td>1</td> - <td>0</td> - </tr> - </tbody> -</table> - -<p>Par exemple, le calcul d'un OU exclusif binaire entre 5 et 1 (<code>5 ^ 1</code>) renvoie <code>0100</code>, qui correspond à 4 en notation décimale.</p> - -<pre>5 0101 -1 0001 - ---- -4 0100 -</pre> - -<h2 id="Exemples">Exemples</h2> - -<pre class="brush: js">var sab = new SharedArrayBuffer(1024); +{{JSRef}} + +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. + +{{EmbedInteractiveExample("pages/js/atomics-xor.html")}} + +## Syntaxe + + Atomics.xor(typedArray, index, valeur) + +### Paramètres + +- `typedArray` + - : Un tableau typé entier partagé parmi {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} ou {{jsxref("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 {{jsxref("TypeError")}} si le type de `typedArray` n'est pas un des types entiers autorisés. +- Cette méthode lève {{jsxref("TypeError")}} si `typedArray` n'est pas tableau typé partagé. +- Cette méthode lève {{jsxref("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</pre> - -<h2 id="Spécifications">Spécifications</h2> - -<table class="standard-table"> - <tbody> - <tr> - <th scope="col">Spécification</th> - <th scope="col">État</th> - <th scope="col">Commentaires</th> - </tr> - <tr> - <td>{{SpecName('ESDraft', '#sec-atomics.xor', 'Atomics.xor')}}</td> - <td>{{Spec2('ESDraft')}}</td> - <td>Définition initiale avec ES2017.</td> - </tr> - </tbody> -</table> - -<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> - -<p>{{Compat("javascript.builtins.Atomics.xor")}}</p> - -<h2 id="Voir_aussi">Voir aussi</h2> - -<ul> - <li>{{jsxref("Atomics")}}</li> - <li>{{jsxref("Atomics.and()")}}</li> - <li>{{jsxref("Atomics.or()")}}</li> -</ul> +Atomics.load(ta, 0); // 4 +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | -------------------------------- | +| {{SpecName('ESDraft', '#sec-atomics.xor', 'Atomics.xor')}} | {{Spec2('ESDraft')}} | Définition initiale avec ES2017. | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Atomics.xor")}} + +## Voir aussi + +- {{jsxref("Atomics")}} +- {{jsxref("Atomics.and()")}} +- {{jsxref("Atomics.or()")}} |