diff options
Diffstat (limited to 'files/fr/web/javascript/reference/objets_globaux/array/indexof/index.html')
| -rw-r--r-- | files/fr/web/javascript/reference/objets_globaux/array/indexof/index.html | 214 |
1 files changed, 214 insertions, 0 deletions
diff --git a/files/fr/web/javascript/reference/objets_globaux/array/indexof/index.html b/files/fr/web/javascript/reference/objets_globaux/array/indexof/index.html new file mode 100644 index 0000000000..5ff4981c2e --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/array/indexof/index.html @@ -0,0 +1,214 @@ +--- +title: Array.prototype.indexOf() +slug: Web/JavaScript/Reference/Objets_globaux/Array/indexOf +tags: + - Array + - JavaScript + - Méthode + - Prototype + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/indexOf +--- +<div>{{JSRef}}</div> + +<p>La méthode <code><strong>indexOf()</strong></code> renvoie le premier indice pour lequel on trouve un élément donné dans un tableau. Si l'élément cherché n'est pas présent dans le tableau, la méthode renverra -1.</p> + +<div class="note"> +<p><strong>Note :</strong> pour la méthode associée aux chaînes de caractères, voir la page {{jsxref("String.prototype.indexOf()")}}.</p> +</div> + +<div>{{EmbedInteractiveExample("pages/js/array-indexof.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>arr</var>.indexOf(<var>élémentRecherché</var>) +<var>arr</var>.indexOf(<var>élémentRecherché</var>, indiceDébut) +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>élémentRecherché</code></dt> + <dd>L'élément qu'on cherche dans le tableau</dd> + <dt><code>indiceDébut</code> {{optional_inline}}</dt> + <dd>L'index à partir duquel commencer la recherche. La valeur par défaut est 0 (le tableau sera parcouru dans sa totalité). Si l'index est plus grand ou égal à la longueur du tableau, la méthode renverra -1. Si l'index est négatif, la recherche commencera d'autant d'éléments, à partir de la fin du tableau. À noter que même si l'index est négatif, la recherche s'effectue toujours du début jusqu'à la fin du tableau. Si l'index fourni est inférieur à 0, le tableau sera entièrement parcouru.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Le premier index de l'élément dans le tableau ou -1 si la valeur n'est pas trouvée.</p> + +<h2 id="Description">Description</h2> + +<p><code>indexOf</code> compare <code>élémentRecherché</code> aux éléments contenus dans le tableau en utilisant une <a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_de_comparaison#.C3.89galit.C3.A9_stricte_(.3D.3D.3D)">égalité stricte</a> (la même méthode utilisée par l'opérateur <code>===</code>).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_indexOf()">Utiliser <code>indexOf()</code></h3> + +<p>Dans l'exemple qui suit, on peut utiliser <code>indexOf</code> afin de trouver l'emplacement d'un élément dans un tableau.</p> + +<pre class="brush: js">var tableau = [2, 9, 9]; +tableau.indexOf(2); // 0 +tableau.indexOf(7); // -1 +tableau.indexOf(9, 2); // 2 +tableau.indexOf(2, -1); // -1 +tableau.indexOf(2, -3); // 0</pre> + +<h3 id="Trouver_toutes_les_occurences_d'un_élément">Trouver toutes les occurences d'un élément</h3> + +<p>Dans l'exemple qui suit, on utilise <code>indexOf()</code> afin de trouver tous les indices d'un élément dans un tableau. On peut utiliser la méthode {{jsxref("Array.prototype.push", "push")}} afin d'ajouter ces indices dans un autre tableau.</p> + +<pre class="brush: js">var indices = []; +var tableau = ['a', 'b', 'a', 'c', 'a', 'd']; +var élément = 'a'; +var idx = tableau.indexOf(élément); +while (idx != -1) { + indices.push(idx); + idx = tableau.indexOf(élément, idx + 1); +} +console.log(indices); +// [0, 2, 4]</pre> + +<h3 id="Trouver_si_un_élément_existe_et_l'ajouter_dans_le_tableau_si_ce_n'est_pas_le_cas">Trouver si un élément existe et l'ajouter dans le tableau si ce n'est pas le cas</h3> + +<pre class="brush: js">function mettreAJourLegumes(tabLégumes, légume) { + if (tabLégumes.indexOf(légume) === -1) { + tabLégumes.push(légume); + console.log('Le nouveau tableau est : ' + tabLégumes); + } else if (tabLégumes.indexOf(légume) > -1) { + console.log(légume + ' existe déjà dans le tableau.'); + } +} + +var tabLégumes = ['pomme de terre', 'tomate', 'poivron']; + +mettreAJourLegumes(tabLégumes, 'épinard'); +// Le nouveau tableau est : pomme de terre,tomate,poivron,épinard +mettreAJourLegumes(tabLégumes, 'épinard'); +// épinard existe déjà dans le tableau.</pre> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<p><code>indexOf</code> fut ajouté avec la cinquième édition du standard ECMA-262 ; il peut donc ne pas être présent dans tous les navigateurs web. Vous pouvez contourner ce problème en insérant le code suivant au début de vos scripts. Il permet d'utiliser <code>indexOf</code> dans les environnements qui ne le supportent pas nativement. L'algorithme est le même que celui spécifié dans ECMAScript 5 si on a bien {{jsxref("TypeError", "TypeError")}} et {{jsxref("Math.abs")}} qui ont leurs valeurs originales :</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.14 +// Référence : http://es5.github.io/#x15.4.4.14 +if (!Array.prototype.indexOf) { + Array.prototype.indexOf = function(searchElement, fromIndex) { + + var k; + + // 1. Soit O le résultat de l'appel à ToObject avec + // this en argument. + if (this == null) { + throw new TypeError('"this" vaut null ou n est pas défini'); + } + + var O = Object(this); + + // 2. Soit lenValue le résultat de l'appel de la + // méthode interne Get de O avec l'argument + // "length". + // 3. Soit len le résultat de ToUint32(lenValue). + var len = O.length >>> 0; + + // 4. Si len vaut 0, on renvoie -1. + if (len === 0) { + return -1; + } + + // 5. Si l'argument fromIndex a été utilisé, soit + // n le résultat de ToInteger(fromIndex) + // 0 sinon + var n = +fromIndex || 0; + + if (Math.abs(n) === Infinity) { + n = 0; + } + + // 6. Si n >= len, on renvoie -1. + if (n >= len) { + return -1; + } + + // 7. Si n >= 0, soit k égal à n. + // 8. Sinon, si n<0, soit k égal à len - abs(n). + // Si k est inférieur à 0, on ramène k égal à 0. + k = Math.max(n >= 0 ? n : len - Math.abs(n), 0); + + // 9. On répète tant que k < len + while (k < len) { + // a. Soit Pk égal à ToString(k). + // Ceci est implicite pour l'opérande gauche de in + // b. Soit kPresent le résultat de l'appel de la + // méthode interne HasProperty de O avec Pk en + // argument. Cette étape peut être combinée avec + // l'étape c + // c. Si kPresent vaut true, alors + // i. soit elementK le résultat de l'appel de la + // méthode interne Get de O avec ToString(k) en + // argument + // ii. Soit same le résultat de l'application de + // l'algorithme d'égalité stricte entre + // searchElement et elementK. + // iii. Si same vaut true, on renvoie k. + if (k in O && O[k] === searchElement) { + return k; + } + k++; + } + return -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('ES5.1', '#sec-15.4.4.14', 'Array.prototype.indexOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.indexof', 'Array.prototype.indexOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.indexof', 'Array.prototype.indexOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<div> +<div class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à consulter <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> et à nous envoyer une<em>pull request</em>.</div> + +<p>{{Compat("javascript.builtins.Array.indexOf")}}</p> +</div> + +<h2 id="Notes_de_compatibilité">Notes de compatibilité</h2> + +<ul> + <li>À partir de Firefox 47 ({{geckoRelease(47)}}), cette méthode ne renverra plus <code>-0</code>. Ainsi, <code>[0].indexOf(0, -0)</code> renverra toujours <code>+0</code> (cf. {{bug(1242043)}}).</li> +</ul> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Array.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("TypedArray.prototype.indexOf()")}}</li> +</ul> |