diff options
Diffstat (limited to 'files/fr/web/javascript/reference/objets_globaux/set')
12 files changed, 1182 insertions, 0 deletions
diff --git a/files/fr/web/javascript/reference/objets_globaux/set/@@iterator/index.html b/files/fr/web/javascript/reference/objets_globaux/set/@@iterator/index.html new file mode 100644 index 0000000000..de86a491fa --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/set/@@iterator/index.html @@ -0,0 +1,92 @@ +--- +title: 'Set.prototype[@@iterator]()' +slug: Web/JavaScript/Reference/Objets_globaux/Set/@@iterator +tags: + - ECMAScript 2015 + - Iterator + - JavaScript + - Méthode + - Prototype + - Reference + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set/@@iterator +--- +<div>{{JSRef}}</div> + +<p>La valeur initiale de la propriété <code><strong>@@iterator</strong></code> est le même objet fonction que la valeur initiale de la propriété {{jsxref("Set.prototype.values()", "Set.prototype.values")}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/set-prototype-@@iterator.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>monSet</var>[Symbol.iterator]</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>La fonction associée au symbole <code>@@iterator</code> de l'objet. Par défaut, c'est la fonction {{jsxref("Set.prototype.values()","values()")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_iterator()">Utiliser <code>[@@iterator]()</code></h3> + +<pre class="brush:js">const monSet = new Set(); +monSet.add("0"); +monSet.add(1); +monSet.add({}); + +const setIter = monSet[Symbol.iterator](); + +console.log(setIter.next().value); // "0" +console.log(setIter.next().value); // 1 +console.log(setIter.next().value); // {} +</pre> + +<h3 id="Utiliser_iterator()_avec_une_boucle_for..of">Utiliser <code>[@@iterator]()</code> avec une boucle <code>for..of</code></h3> + +<pre class="brush:js">const monSet= new Set(); +monSet.add("0"); +monSet.add(1); +monSet.add({}); + +for (const v of monSet) { + console.log(v); +} +</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('ES2015', '#sec-set.prototype-@@iterator', 'Set.prototype[@@iterator]')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype-@@iterator', 'Set.prototype[@@iterator]')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> + +<p>{{Compat("javascript.builtins.Set.@@iterator")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Set.prototype.entries()")}}</li> + <li>{{jsxref("Set.prototype.values","Set.prototype.keys()")}}</li> + <li>{{jsxref("Set.prototype.values()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/set/@@species/index.html b/files/fr/web/javascript/reference/objets_globaux/set/@@species/index.html new file mode 100644 index 0000000000..dbf3152c4d --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/set/@@species/index.html @@ -0,0 +1,72 @@ +--- +title: 'get Set[@@species]' +slug: Web/JavaScript/Reference/Objets_globaux/Set/@@species +tags: + - ECMAScript 2015 + - JavaScript + - Propriété + - Reference + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set/@@species +--- +<div>{{JSRef}}</div> + +<p><code><strong>Set[@@species]</strong></code> renvoie le constructeur <code>Set</code>.</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Set[Symbol.species] +</pre> + +<h2 id="Description">Description</h2> + +<p>L'accesseur <code>species</code> renvoie le constructeur par défaut pour les objets <code>Set</code>. Les constructeurs pour les classes filles peuvent surcharger cette propriété afin de modifier le constructeur utilisé lors de l'affectation.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>La propriété <code>species</code> renvoie la fonction utilisée comme constructeur par défaut, dans le cas des objets <code>Set</code>, c'est le constructeur <code>Set</code> :</p> + +<pre class="brush: js">Set[Symbol.species]; // function Set()</pre> + +<p>Pour les objets dérivés (par exemple une classe <code>MonSet</code> que vous auriez construite), la propriété species pour <code>MonSet</code> sera le constructeur <code>MonSet</code>. Cependant, si vous souhaitez surcharger ce comportement afin de renvoyer le constructeur <code>Set</code> dans les méthodes des classes dérivées, vous pourrez utiliser :</p> + +<pre class="brush: js">class MonSet extends Set + // On surcharge la propriété species de MonSet + // avec le constructeur Set de la classe parente + static get [Symbol.species()]() { return Set;} +}</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('ES2015', '#sec-get-set-@@species', 'get Set [ @@species ]')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-get-set-@@species', 'get Set [ @@species ]')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> + +<p>{{Compat("javascript.builtins.Set.@@species")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Symbol.species")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/set/add/index.html b/files/fr/web/javascript/reference/objets_globaux/set/add/index.html new file mode 100644 index 0000000000..2ccda95513 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/set/add/index.html @@ -0,0 +1,81 @@ +--- +title: Set.prototype.add() +slug: Web/JavaScript/Reference/Objets_globaux/Set/add +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Prototype + - Reference + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set/add +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>add()</strong></code> permet d'ajouter un nouvel élément ayant une valeur donnée à un ensemble <code>Set</code>. Cette valeur sera ajoutée à la fin de l'objet <code>Set</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/set-prototype-add.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>monSet</var>.add(<var>valeur</var>);</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>valeur</code></dt> + <dd>Ce paramètre est obligatoire. La valeur de l'élément qu'on souhaite ajouter à l'objet <code>Set</code>.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>L'objet <code>Set</code> (ce qui permet de chaîner une suite d'instructions utilisant cette méthode).</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">var monSet = new Set(); + +monSet.add(1); +monSet.add(5).add("du texte"); // ajouts en chaîne + +console.log(monSet); +// Set [1, 5, "du texte"] +</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('ES2015', '#sec-set.prototype.add', 'Set.prototype.add')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.add', 'Set.prototype.add')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> + +<p>{{Compat("javascript.builtins.Set.add")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.delete()")}}</li> + <li>{{jsxref("Set.prototype.has()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/set/clear/index.html b/files/fr/web/javascript/reference/objets_globaux/set/clear/index.html new file mode 100644 index 0000000000..1c6beb30c4 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/set/clear/index.html @@ -0,0 +1,77 @@ +--- +title: Set.prototype.clear() +slug: Web/JavaScript/Reference/Objets_globaux/Set/clear +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Prototype + - Reference + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set/clear +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>clear()</strong></code> permet de retirer tous les éléments d'un ensemble <code>Set</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/set-prototype-clear.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>monSet</var>.clear();</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">var monSet = new Set(); +monSet.add(1); +monSet.add("toto"); + +monSet.size; // 2 +monSet.has("toto"); // true + +monSet.clear(); + +monSet.size; // 0 +monSet.has("truc") // false +</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('ES2015', '#sec-set.prototype.clear', 'Set.prototype.clear')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.clear', 'Set.prototype.clear')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> + +<p>{{Compat("javascript.builtins.Set.clear")}}</p> + +<h3 id="Voir_aussi">Voir aussi</h3> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.delete()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/set/delete/index.html b/files/fr/web/javascript/reference/objets_globaux/set/delete/index.html new file mode 100644 index 0000000000..eff24aa6d9 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/set/delete/index.html @@ -0,0 +1,96 @@ +--- +title: Set.prototype.delete() +slug: Web/JavaScript/Reference/Objets_globaux/Set/delete +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Prototype + - Reference + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set/delete +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>delete()</strong></code> permet de retirer un élément donné d'un objet <code>Set</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/set-prototype-delete.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>monSet</var>.delete(<var>valeur</var>);</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>valeur</code></dt> + <dd>Ce paramètre est obligatoire. Il représente la valeur de l'élément qu'on souhaite retirer de l'objet <code>Set</code>.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p><code>true</code> si un élément de l'objet <code>Set</code> a été retiré lors de l'opération, <code>false</code> sinon.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_la_méthode_delete()">Utiliser la méthode <code>delete()</code></h3> + +<pre class="brush: js">var monSet = new Set(); +monSet.add("toto"); + +monSet.delete("truc"); // Renvoie false. Aucun élément "truc" n'a pu être supprimé. +monSet.delete("toto"); // Renvoie true. L'élément a pu être supprimé. + +monSet.has("toto"); // Renvoie false. L'élément "toto" ne fait plus partie de l'ensemble. +</pre> + +<h3 id="Utiliser_delete()_avec_forEach()">Utiliser <code>delete()</code> avec <code>forEach()</code></h3> + +<pre class="brush: js">var objetSet = new Set(); +objetSet.add({x: 10, y: 20}); // On ajoute un nouvel objet dans l'ensemble +objetSet.add({x: 20, y: 30}); // On ajoute un nouvel objet dans l'ensemble + +// On supprime les points de l'ensemble pour lesquels +// x est supérieur à 10 +objetSet.forEach(function(point){ + if(point.x > 10){ + objetSet.delete(point); + } +});</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('ES2015', '#sec-set.prototype.delete', 'Set.prototype.delete')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.delete', 'Set.prototype.delete')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> + +<p>{{Compat("javascript.builtins.Set.delete")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.clear()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/set/entries/index.html b/files/fr/web/javascript/reference/objets_globaux/set/entries/index.html new file mode 100644 index 0000000000..0e791e4c8d --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/set/entries/index.html @@ -0,0 +1,77 @@ +--- +title: Set.prototype.entries() +slug: Web/JavaScript/Reference/Objets_globaux/Set/entries +tags: + - ECMAScript 2015 + - Iterator + - JavaScript + - Méthode + - Prototype + - Reference + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set/entries +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>entries()</strong></code> renvoie un nouvel objet <code><a href="/fr/docs/Web/JavaScript/Guide/iterateurs_et_generateurs#Itérateurs">Iterator</a></code> qui contient un tableau composé de <strong><code>[valeur, valeur]</code></strong> pour chaque élément de l'objet <code>Set</code>, dans leur ordre d'insertion. En raison de leur structure, les objets <code>Set</code> n'ont pas de clé (<code>key</code>), à la différence des objets <code>Map</code>. Pour garder une structure et une API sembables à celle d'un objet <code>Map</code>, chaque entrée (<em>entry</em>) aura la même valeur pour la <em>clé</em> (<em>key</em>) et pour la <em>valeur </em>(<em>value</em>), c'est pourquoi un tableau de<code> [valeur, valeur]</code> est renvoyé.</p> + +<div>{{EmbedInteractiveExample("pages/js/set-prototype-entries.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>monSet</var>.entries()</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un nouvel objet <code>Iterator</code> qui contient un tableau de tuples [<code>valeur, valeur</code>] pour chaque élément de l'ensemble, dans leur ordre d'insertion.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush:js">var monSet = new Set(); +monSet.add("totobidule"); +monSet.add(1); +monSet.add("machin"); + +var setIter = monSet.entries(); + +console.log(setIter.next().value); // ["totobidule", "totobidule"] +console.log(setIter.next().value); // [1, 1] +console.log(setIter.next().value); // ["machin", "machin"] +</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('ES2015', '#sec-set.prototype.entries', 'Set.prototype.entries')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.entries', 'Set.prototype.entries')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> + +<p>{{Compat("javascript.builtins.Set.entries")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Set.prototype.values","Set.prototype.keys()")}}</li> + <li>{{jsxref("Set.prototype.values()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/set/foreach/index.html b/files/fr/web/javascript/reference/objets_globaux/set/foreach/index.html new file mode 100644 index 0000000000..e3b14c4eb8 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/set/foreach/index.html @@ -0,0 +1,115 @@ +--- +title: Set.prototype.forEach() +slug: Web/JavaScript/Reference/Objets_globaux/Set/forEach +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Prototype + - Reference + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set/forEach +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>forEach()</strong></code> permet d'exécuter une fonction donnée, une fois pour chaque valeur de l'ensemble <code>Set</code>. L'ordre appliqué est celui dans lequel les valeurs ont été ajoutées à l'ensemble.</p> + +<div>{{EmbedInteractiveExample("pages/js/set-prototype-foreach.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>monSet</var>.forEach(<var>callback</var>[, <var>thisArg</var>])</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>{{jsxref("undefined")}}.</p> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>La fonction qu'on souhaite exécuter pour chaque élément et qui sera appelée avec trois arguments :</dd> + <dd> + <dl> + <dt><code>valeurCourante</code>, <code>cléCourante</code></dt> + <dd>L'élément courant appartenant à l'ensemble <code>Set</code>. Un ensemble n'ayant pas de clé, c'est la même valeur qui est passée pour deux arguments de la fonction de rappel.</dd> + <dt><code>set</code></dt> + <dd>L'objet <code>Set</code> courant (celui sur lequel <code>forEach()</code> a été appelé).</dd> + </dl> + </dd> + <dt><code>thisArg</code></dt> + <dd>Paramètre optionnel. La valeur à utiliser comme <code>this</code> lors de l'exécution de <code>callback</code>.</dd> +</dl> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>forEach()</code> exécute la fonction <code>callback</code> fournie pour chaque valeur contenue au sein de l'objet <code>Set</code>. Elle n'est pas appelée pour les valeurs qui ont été supprimées. Cependant, elle est exécutée si jamais la valeur vaut <code>undefined</code>.</p> + +<p><code>callback</code> est appelé avec <strong>trois arguments</strong> :</p> + +<ul> + <li>la <strong>valeur de l'élément</strong></li> + <li>la <strong>clé de l'élément</strong></li> + <li>l'objet <strong><code>Set</code> qui est parcouru</strong></li> +</ul> + +<p>Les objets <code>Set</code> n'ont pas de clé (<em>key</em>). Cependant les deux premiers arguments correspondent à la <strong>valeur</strong> contenue dans l'objet {{jsxref("Set")}}. Cela permet d'utiliser les fonctions callback de façon cohérente avec les méthodes <code>forEach()</code> de {{jsxref("Map.foreach", "Map")}} et {{jsxref("Array.forEach","Array")}}.</p> + +<p>Si un paramètre <code>thisArg</code> est fourni, il sera passé à la fonction <code>callback</code> lors de l'appel comme valeur <code>this</code>. Par défaut, la valeur {{jsxref("undefined")}} sera passée comme argument <code>this</code>. La valeur <code>this</code> effectivement reçue par la fonction <code>callback</code> est déterminée selon <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/L_opérateur_this">les règles usuelles de détermination de <code>this</code> par une fonction</a>.</p> + +<p>Chacune des valeurs sera traitée une fois sauf si celle-ci a été supprimée puis réajoutée avant la fin de <code>forEach</code>. <code>callback</code> n'est pas appelé pour les valeurs qui sont supprimés avant le passage de la fonction. Les valeurs qui sont ajoutées avant que <code>forEach</code> ait parcouru l'ensemble seront traitées</p> + +<p><code>forEach</code> exécute la fonction <code>callback</code> une fois pour chaque élément de l'objet <code>Set</code>. Cette méthode ne renvoie pas de valeur.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>Le code qui suit permet d'enregistrer une ligne pour chaque élément contenu dans l'objet <code>Set</code> :</p> + +<pre class="brush:js">function logSetElements(valeur1, valeur2, set) { + console.log("s[" + valeur1 + "] = " + valeur2); +} + +new Set(["toto", "truc", undefined]).forEach(logSetElements); + +// affichera : +// "s[toto] = toto" +// "s[truc] = truc" +// "s[undefined] = undefined" +</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('ES2015', '#sec-set.prototype.foreach', 'Set.prototype.forEach')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.foreach', 'Set.prototype.forEach')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> + +<p>{{Compat("javascript.builtins.Set.forEach")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Map.prototype.forEach()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/set/has/index.html b/files/fr/web/javascript/reference/objets_globaux/set/has/index.html new file mode 100644 index 0000000000..08f9fcb55f --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/set/has/index.html @@ -0,0 +1,91 @@ +--- +title: Set.prototype.has() +slug: Web/JavaScript/Reference/Objets_globaux/Set/has +tags: + - ECMAScript 2015 + - JavaScript + - Méthode + - Prototype + - Reference + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set/has +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>has()</strong></code> renvoie un booléen qui indique s'il existe un élément de l'ensemble <code>Set</code> avec une certaine valeur.</p> + +<div>{{EmbedInteractiveExample("pages/js/set-prototype-has.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>monSet</var>.has(<var>valeur</var>);</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>valeur</code></dt> + <dd>Ce paramètre est obligatoire. C'est la valeur dont on souhaite savoir si elle est présente ou non dans l'objet <code>Set</code>.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un booléen : <code>true</code> s'il existe un élément avec la valeur donnée au sein du <code>Set</code>, <code>false</code> sinon.</p> + +<div class="note"> +<p><strong>Note :</strong> L'existence d'un élément avec la valeur testée est vérifiée avec <a href="/fr/docs/Web/JavaScript/Les_différents_tests_d_égalité#Égalité_de_valeurs_nulles">l'algorithme d'égalité des valeurs nulles (<code><em>sameValueZero</em></code>)</a>.</p> +</div> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">var monSet = new Set(); +monSet.add("toto"); + +monSet.has("toto"); // renvoie true +monSet.has("truc"); // renvoie false + +var set1 = new Set(); +var obj1 = {'cle1': 1}; +set1.add(obj1); + +set1.has(obj1); // renvoie true +set1.has({'cle1': 1}); // renvoie false car ce sont deux objets distincts +set1.add({'cle1': 1}); // set1 contient désormais 2 éléments +</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('ES2015', '#sec-set.prototype.has', 'Set.prototype.has')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.has', 'Set.prototype.has')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> + +<p>{{Compat("javascript.builtins.Set.has")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.add()")}}</li> + <li>{{jsxref("Set.prototype.delete()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/set/index.html b/files/fr/web/javascript/reference/objets_globaux/set/index.html new file mode 100644 index 0000000000..9b44936cbc --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/set/index.html @@ -0,0 +1,249 @@ +--- +title: Set +slug: Web/JavaScript/Reference/Objets_globaux/Set +tags: + - ECMAScript 2015 + - JavaScript + - Reference + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set +--- +<div>{{JSRef}}</div> + +<p>L'objet <strong><code>Set</code></strong> (Ensemble en français) permet de stocker des valeurs <em>uniques</em>, de n'importe quel type, que ce soit des valeurs d'un {{Glossary("Primitive", "type primitif")}} ou des objets.</p> + +<div>{{EmbedInteractiveExample("pages/js/set-prototype-constructor.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"> new Set([itérable]);</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>itérable</code></dt> + <dd>Paramètre optionnel. Si un objet <a href="/fr/docs/Web/JavaScript/Reference/Instructions/for...of">itérable </a>est donné comme argument, l'ensemble de ses éléments sera ajouté au nouvel objet Set. Si {{jsxref("null")}} est fourni comme argument ou qu'aucun argument n'est fourni, il sera traité comme {{jsxref("undefined")}}.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un nouvel objet <code>Set</code>.</p> + +<h2 id="Description">Description</h2> + +<p>Les objets <code>Set</code> sont des ensembles de valeurs. Il est possible d'itérer sur les éléments contenus dans l'objet <code>Set</code> dans leur ordre d'insertion. <strong>Une valeur donnée ne peut apparaître qu'une seule fois par <code>Set</code>.</strong></p> + +<h3 id="Égalité_des_valeurs">Égalité des valeurs</h3> + +<p>Chaque valeur d'un <code>Set</code> doit être unique, il faut donc tester l'égalité des valeurs contenues. Cette égalité n'est pas la même que celle de l'opérateur ===. Notamment, pour les objets <code>Set</code>, <code>+0</code> (qui, selon l'égalité stricte, est égal à <code>-0</code>) et <code>-0</code> sont des valeurs différentes. Cela a toutefois été changé avec la dernière version d'ECMAScript 2015 (ES6). Voir le tableau de compatibilité ci-après quant à la prise en charge de l'égalité des clés pour <code>0</code> et <code>-0</code>.</p> + +<p>{{jsxref("NaN")}} and {{jsxref("undefined")}} peuvent être enregistrés dans un objet <code>Set</code>. <code>NaN</code> est considéré comme <code>NaN</code> (bien que <code>NaN !== NaN</code>).</p> + +<h2 id="Propriétés">Propriétés</h2> + +<dl> + <dt><code>Set.length</code></dt> + <dd>La valeur de la propriété <code>length</code> est 0. + <div class="note"><strong>Note :</strong> Pour compter le nombre d'éléments d'un objet <code>Set</code>, on utilisera {{jsxref("Set.prototype.size")}}.</div> + </dd> + <dt>{{jsxref("Set.@@species", "get Set[@@species]")}}</dt> + <dd>Le constructeur utilisé pour créer des objets dérivés.</dd> + <dt>{{jsxref("Set.prototype")}}</dt> + <dd>Représente le prototype du constructeur <code>Set</code>. Cela permet d'ajouter des propriétés à tous les objets <code>Set</code>.</dd> +</dl> + +<h2 id="Instances_de_Set">Instances de <code>Set</code></h2> + +<p>Toutes les instances de <code>Set</code> héritent de {{jsxref("Set.prototype")}}.</p> + +<h3 id="Propriétés_2">Propriétés</h3> + +<p>{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/Set/prototype','Propriétés')}}</p> + +<h3 id="Méthodes">Méthodes</h3> + +<p>{{page('fr/docs/Web/JavaScript/Reference/Objets_globaux/Set/prototype','Méthodes')}}</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_l'objet_Set">Utiliser l'objet <code>Set</code></h3> + +<pre class="brush: js">var monSet = new Set(); + +monSet.add(1); // { 1 } +monSet.add(5); // { 1, 5 } +monSet.add("du texte");// { 1, 5, "du texte" } + +monSet.has(1); // true +monSet.has(3); // false, 3 n'a pas été ajouté à l'ensemble +monSet.has(5); // true +monSet.has(Math.sqrt(25)); // true +monSet.has("Du Texte".toLowerCase()); // true + +monSet.size; // 3 + +monSet.delete(5); // retire 5 du set +monSet.has(5); // false, 5 a été retiré de l'ensemble + +monSet.size; // 2, on a retiré une valeur de l'ensemble +console.log(monSet); // Set [ 1, "du texte" ] +</pre> + +<h3 id="Itérer_sur_des_ensembles_(Set)">Itérer sur des ensembles (<code>Set</code>)</h3> + +<pre class="brush: js">// On itère sur les différents éléments de l'ensemble +// ici on affiche : 1, "du texte" +for (let item of monSet) console.log(item); + +// ici on affiche les clés de l'ensemble : 1, "du texte" +for (let item of monSet.keys()) console.log(item); + +// ici on affiche les valeurs de l'ensemble : 1, "du texte" +for (let item of monSet.values()) console.log(item); + +// ici on affiche les clés de l'ensemble : 1, "du texte" +//(ici, les clés et les valeurs sont les mêmes) +for (let [clé, valeur] of monSet.entries()) console.log(clé); + +// Une méthode de conversion avec Array.from +var monTableau = Array.from(monSet); // [1, "du texte"] + +// Cela fonctionnera également dans un document HTML +monSet.add(document.body); +monSet.has(document.querySelector("body")); // true + +// convertir un tableau (Array) en ensemble (Set) et vice versa +monSet2 = new Set([1,2,3,4]); +monSet2.size; // 4 +[...monSet2]; // [1,2,3,4] + +// L'intersection peut être calculée avec +var intersection = new Set([...set1].filter(x => set2.has(x))); + +// La différence pourra être simulée avec +var différence = new Set([...set1].filter(x => !set2.has(x))); + +// On peut itérer sur les entrées d'un ensemble avec forEach +mySet.forEach(function(value) { + console.log(value); +}); + +// 1 +// 2 +// 3 +// 4</pre> + +<h3 id="Implémenter_des_opérations_ensemblistes">Implémenter des opérations ensemblistes</h3> + +<pre class="brush: js">function isSuperset(set, subset) { + for (var elem of subset) { + if (!set.has(elem)) { + return false; + } + } + return true; +} + +function union(setA, setB) { + var union = new Set(setA); + for (var elem of setB) { + union.add(elem); + } + return union; +} + +function intersection(setA, setB) { + var intersection = new Set(); + for (var elem of setB) { + if (setA.has(elem)) { + intersection.add(elem); + } + } + return intersection; +} + +function difference (setA, setB) { + var difference = new Set(setA); + for (var elem of setB) { + difference.delete(elem); + } + return difference; +} + +// Exemples +var setA = new Set([1,2,3,4]), + setB = new Set([2,3]), + setC = new Set([3,4,5,6]); + +isSuperset(setA, setB); // => true +union(setA, setC); // => Set [1, 2, 3, 4, 5, 6] +intersection(setA, setC); // => Set [3, 4] +difference(setA, setC); // => Set [1, 2] +</pre> + +<h3 id="Les_relations_avec_les_objets_Array">Les relations avec les objets <code>Array</code></h3> + +<pre class="brush: js">var monTableau = ["valeur1", "valeur2", "valeur3"]; + +// On peut utiliser le constructeur Set pour transformer un Array en Set +var monSet = new Set(monTableau); + +monSet.has("valeur1"); // renvoie true + +// Et utiliser l'opérateur de décomposition pour transformer un Set en Array. +console.log([...monSet]); // affichera la même chose que monTableau</pre> + +<h3 id="Les_relations_avec_les_objets_String">Les relations avec les objets <code>String</code></h3> + +<pre>var maChaine = "CouCou"; + +var monEnsemble = new Set(maChaine); +// Set {"C","o","u" } +monEnsemble.size; // 3 +</pre> + +<h3 id="Dédoublonner_un_tableau">Dédoublonner un tableau</h3> + +<pre class="brush: js">const nombres = [2,3,4,4,2,2,2,4,4,5,5,6,6,7,5,32,3,4,5]; +console.log([...new Set(nombres)]); +// affichera [2, 3, 4, 5, 6, 7, 32]</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES2015', '#sec-set-objects', 'Set')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set-objects', 'Set')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> + +<p>{{Compat("javascript.builtins.Set")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakSet")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/set/prototype/index.html b/files/fr/web/javascript/reference/objets_globaux/set/prototype/index.html new file mode 100644 index 0000000000..995407dbfc --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/set/prototype/index.html @@ -0,0 +1,87 @@ +--- +title: Set.prototype +slug: Web/JavaScript/Reference/Objets_globaux/Set/prototype +tags: + - ECMAScript 2015 + - JavaScript + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Set +--- +<div>{{JSRef}}</div> + +<p>La propriété <code><strong>Set.prototype</strong></code> représente le prototype pour le constructeur {{jsxref("Set")}}.</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description">Description</h2> + +<p>Les instances de {{jsxref("Set")}} héritent de {{jsxref("Set.prototype")}}. Le prototype peut être utilisé afin d'ajouter des propriétés (valeurs ou méthodes) à toutes les instances de <code>Set</code>.</p> + +<h2 id="Propriétés">Propriétés</h2> + +<dl> + <dt><code>Set.prototype.constructor</code></dt> + <dd>Renvoie la fonction qui crée le prototype d'une instance. Par défaut, ce sera la fonction {{jsxref("Set")}}.</dd> + <dt>{{jsxref("Set.prototype.size")}}</dt> + <dd>Renvoie le nombre de valeurs contenues dans l'objet <code>Set</code>.</dd> +</dl> + +<h2 id="Méthodes">Méthodes</h2> + +<dl> + <dt>{{jsxref("Set.add", "Set.prototype.add(valeur)")}}</dt> + <dd>Ajoute un nouvel élément à l'objet <code>Set</code> avec la valeur donnée. La valeur de retour est l'objet <code>Set</code>.</dd> + <dt>{{jsxref("Set.prototype.clear()")}}</dt> + <dd>Retire tous les éléments de l'objet <code>Set</code>.</dd> + <dt>{{jsxref("Set.delete", "Set.prototype.delete(valeur)")}}</dt> + <dd>Retire l'élément associé à la <code>valeur</code> et renvoie la valeur que <code>Set.prototype.has(valeur)</code> aurait renvoyé. <code>Set.prototype.has(valeur)</code> renverra <code>false</code> après la suppression.</dd> + <dt>{{jsxref("Set.prototype.entries()")}}</dt> + <dd>Renvoie un nouvel objet <code>Iterator</code> qui contient un tableau de<strong> <code>[valeur, valeur]</code></strong> pour chaque élément de l'objet <code>Set</code>, dans l'ordre dans lequel les valeurs ont été insérées. On aura donc une structure semblable à un objet <code>Map</code>. Ici, chaque entrée aura la même valeur pour la <em>clé</em> et la <em>valeur</em>.</dd> + <dt>{{jsxref("Set.forEach", "Set.prototype.forEach(fnCallback[, thisArg])")}}</dt> + <dd>Appelle la fonction <code>fnCallback</code> pour chaque valeur présente dans l'objet <code>Set</code>, dans l'ordre dans lequel elles ont été insérées. Si un paramètre <code>thisArg</code> est fourni à <code>forEach</code>, il sera utilisé comme valeur de <code>this</code> pour chaque appel de la fonction de callback.</dd> + <dt>{{jsxref("Set.has", "Set.prototype.has(valeur)")}}</dt> + <dd>Renvoie un booléen qui indique si un des éléments de l'ensemble possède cette valeur.</dd> + <dt>{{jsxref("Set.prototype.values()","Set.prototype.keys()")}}</dt> + <dd>Cette fonction correspond à la fonction <strong><code>values()</code></strong> et renvoie un nouvel objet <code>Iterator</code> qui contient les valeurs correspondant à chaque élément de <code>Set</code> dans l'ordre dans lequel ils ont été insérés.</dd> + <dt>{{jsxref("Set.prototype.values()")}}</dt> + <dd>Renvoie un nouvel objet <code>Iterator</code> qui contient les valeurs pour chacun des éléments de l'objet <code>Set</code>, dans l'ordre dans lequel ils ont été insérés.</dd> + <dt>{{jsxref("Set.prototype.@@iterator()","Set.prototype[@@iterator]()")}}</dt> + <dd>Renvoie un nouvel objet <code>Iterator</code> qui contient les valeurs pour chaque élément de l'objet <code>Set</code> dans leur ordre d'insertion.</dd> +</dl> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES2015', '#sec-set.prototype', 'Set.prototype')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype', 'Set.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> + +<p>{{Compat("javascript.builtins.Set.prototype")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Map.prototype")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/set/size/index.html b/files/fr/web/javascript/reference/objets_globaux/set/size/index.html new file mode 100644 index 0000000000..83a5b8c9b7 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/set/size/index.html @@ -0,0 +1,67 @@ +--- +title: Set.prototype.size +slug: Web/JavaScript/Reference/Objets_globaux/Set/size +tags: + - ECMAScript 2015 + - JavaScript + - Propriété + - Prototype + - Reference + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set/size +--- +<div>{{JSRef}}</div> + +<p>L'accesseur <code><strong>size</strong></code> est une propriété qui renvoie le nombre d'éléments contenus dans un objet {{jsxref("Set")}}. Un objet <code>Set</code> correspondant à un ensemble, chaque élément qu'il contient y est unique.</p> + +<div>{{EmbedInteractiveExample("pages/js/set-prototype-size.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Description">Description</h2> + +<p>La valeur de <code>size</code> est un entier représentant le nombre d'éléments contenus dans l'ensemble. Le mutateur associée pour <code>size</code> vaut {{jsxref("undefined")}}. Cette propriété ne peut pas être changée directement.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush:js">var monSet = new Set(); +monSet.add(1); +monSet.add(5); +monSet.add("du texte") + +monSet.size; // 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('ES2015', '#sec-get-set.prototype.size', 'Set.prototype.size')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-get-set.prototype.size', 'Set.prototype.size')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> + +<p>{{Compat("javascript.builtins.Set.size")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Set")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/set/values/index.html b/files/fr/web/javascript/reference/objets_globaux/set/values/index.html new file mode 100644 index 0000000000..2e1ab4b178 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/set/values/index.html @@ -0,0 +1,78 @@ +--- +title: Set.prototype.values() +slug: Web/JavaScript/Reference/Objets_globaux/Set/values +tags: + - ECMAScript 2015 + - Iterator + - JavaScript + - Méthode + - Prototype + - Reference + - set +translation_of: Web/JavaScript/Reference/Global_Objects/Set/values +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>values()</strong></code> renvoie un nouvel objet {{jsxref("Iterator")}} qui contient les valeurs de chaque élément de l'objet <code>Set</code>, dans leur ordre d'insertion.</p> + +<p>La méthode <strong><code>keys()</code></strong> est un alias pour cette méthode (afin de conserver une certaine similarité avec les objets {{jsxref("Map")}}) et se comportera exactement de la même façon en renvoyant les <strong>valeurs</strong> des éléments du <code>Set</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/set-prototype-values.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox"><var>monSet</var>.values(); +</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un nouvel objet <code>Iterator</code> qui contient les valeurs de chaque élément de l'ensemble <code>Set</code>, dans leur ordre d'insertion.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush:js">var monSet = new Set(); +monSet.add("toto"); +monSet.add("truc"); +monSet.add("machin"); + +var setIter = monSet.values(); + +console.log(setIter.next().value); // "toto" +console.log(setIter.next().value); // "truc" +console.log(setIter.next().value); // "machin"</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('ES2015', '#sec-set.prototype.values', 'Set.prototype.values')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-set.prototype.values', 'Set.prototype.values')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div class="hidden">Ce tableau de compatibilité a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div> + +<p>{{Compat("javascript.builtins.Set.values")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Set.prototype.entries()")}}</li> +</ul> |