String.prototype.indexOf()
==========================

La méthode **`indexOf()`** renvoie l'indice de la première occurence de la valeur cherchée au sein de la chaîne courante (à partir de `indexDébut`). Elle renvoie -1 si la valeur cherchée n'est pas trouvée.

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

**Note :** Pour la méthode associée aux tableaux, voir la page `Array.prototype.indexOf()`.

Syntaxe
-------


```js
str.indexOf(valeurRecherchée);
str.indexOf(valeurRecherchée, indexDébut);
```

### Paramètres

`valeurRecherchée`

Une chaîne représentant la valeur qu'on cherche dans la chaîne courante. Si aucune valeur n'est fournie explicitement, `valeurRecherchée` sera convertie en `"undefined"` et c'est cette chaîne qui sera recherchée.

`indexDébut`

Paramètre optionnel. L'indice à partir duquel commencer la recherche, effectuée du début vers la fin de la liste. Cela peut être n'importe quel entier. La valeur par défaut est 0. Si `indexDébut < 0` la chaîne sera parcourue en entier (ce qui équivaut à utiliser 0). Si `indexDébut >= str.length`, la méthode renverra -1 sauf si `valeurRecherchée` est la chaîne vide, auquel cas, la méthode renverra `str.length`.

### Valeur de retour

L'indice de la première occurrence de la valeur indiquée, `-1` si elle n'est pas trouvée. Si la valeur recherchée est la chaîne vide, une correspondance sera trouvée à n'importe quel index entre `0` et `str.length`.

Description
-----------

Les caractères dans une chaîne de caractères sont indexés de la gauche à la droite. L'indice du premier caractère est 0, celui du dernier caractère (d'une chaîne `str`) est `str.length - 1.`


```js
"Blue Whale".indexOf("Blue"); // retourne 0
"Blue Whale".indexOf("Blute"); // retourne -1
"Blue Whale".indexOf("Whale", 0); // retourne 5
"Blue Whale".indexOf("Whale", 5); // retourne 5
"Blue Whale".indexOf(""); // retourne 0
"Blue Whale".indexOf("", 9); // retourne 9
"Blue Whale".indexOf("", 10); // retourne 10
"Blue Whale".indexOf("", 11); // retourne 10
```

### Sensibilité à la casse

La méthode `indexOf()` est sensible à la casse. Par exemple, l'expression suivante retourne -1 :


```js
"Blue Whale".indexOf("blue"); // retourne -1
```


Attention : `0` n'est pas une valeur qui peut être évaluée à `true` et `-1` n'est pas une valeur qui peut être évaluée à `false`. Ainsi, si on souhaite tester si une chaîne de caractères existe au sein d'une autre chaîne de caractères, on procèdera de cette façon (ou on utilisera `String.prototype.includes()`


```js
"Blue Whale".indexOf("Blue") != -1; // true
"Blue Whale".indexOf("Bloe") != -1; // false
```

Exemples
--------

### Utiliser `indexOf()` et `lastIndexOf()`

L'exemple suivant utilise `indexOf()` et `lastIndexOf()` pour localiser différentes valeurs dans la chaîne de caractères "`Brave new world`".


```js
const uneChaîne = "Brave new world";

console.log("Indice du premier w " + uneChaîne.indexOf("w"));
// Affiche 8
console.log("Indice du dernier w " + uneChaîne.lastIndexOf("w"));
// Affiche 10

console.log("Indice du premier 'new' " + uneChaîne.indexOf("new"));
// Affiche 6
console.log("Indice du dernier 'new' " + uneChaîne.lastIndexOf("new"));
// Affiche 6
```

### `indexOf()` et la sensibilité à la casse

L'exemple suivant définit 2 chaînes de caractères. Ces variables contiennent la meme chaîne de caractères sauf que la seconde chaîne de caractères contient des lettres majuscules. La première méthode `writeln` affiche 19. Cependant, comme la méthode `indexOf` est sensible à la casse, la chaîne de caractères "`cheddar`" n'est pas trouvée dans `myCapString`, donc le second résultat affiche -1.


```js
const maChaîne = "brie, reblochon, cheddar";
const maChaîneMajuscules = "Brie, Reblochon, Cheddar";

console.log('maChaîne.indexOf("cheddar") is ' + maChaîne.indexOf("cheddar"));
// Affiche 19
console.log(
  'maChaîneMajuscules.indexOf("cheddar") is ' +
    maChaîneMajuscules.indexOf("cheddar"),
);
// Affiche -1
```

### Utiliser `indexOf()` pour compter le nombre d'occurences dans une chaîne de caractères

L'exemple suivant utilise la variable `count` pour stocker le nombre d'occurences de la lettre `x` dans la chaîne de caractère `str` :


```js
const str = "Chaîne x de test x";
let count = 0;
let pos = str.indexOf("x");

while (pos != -1) {
  count++;
  pos = str.indexOf("x", pos + 1);
}
console.log(count); // Affiche 2
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.indexof |

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

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

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

* `String.prototype.charAt()`
* `String.prototype.lastIndexOf()`
* `String.prototype.includes()`
* `String.prototype.split()`
* `Array.prototype.indexOf()`