String
======

Un objet **`String`** est utilisé afin de représenter et de manipuler une chaîne de caractères.

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

Les chaînes de caractères sont utiles pour stocker des données qui peuvent être représentées sous forme de texte. Parmi les opérations les plus utilisées pour manipuler les chaînes de caractères, on a : la vérification de leur longueur avec `length`, la construction et la concaténation avec les opérateurs `+` et `+=`, la recherche de sous-chaîne avec les méthodes `includes()` ou `indexOf()` ou encore l'extraction de sous-chaînes avec la méthode `substring()`.

### Créer des chaînes de caractères

Il est possible de créer des chaînes de caractères comme des valeurs primitives ou comme des objets avec le constructeur `String()` :


```js
const string1 = "Une chaîne de caractères primitive";
const string2 = "Là encore une valeur de chaîne de caractères primitive";
const string3 = `Et ici aussi`;
```



```js
const string4 = new String("Un objet String");
```


Les valeurs primitives ou les objets représentant des chaînes de caractères peuvent être utilisés de façon interchangeable dans la plupart des situations. Voir ci-après Chaînes de caractères : valeurs primitives et objets.

Les valeurs littérales pour les chaînes de caractères peuvent être indiquées avec des simples quotes (`'`), des doubles quotes (`"`) ou encore par des accents graves (```). Cette dernière forme permet de définir un littéral de gabarit de chaîne de caractères avec lequel on pourra interpoler des expressions dans une chaîne de caractères.

### Accéder à un caractère

Il existe deux façons d'accéder à un caractère dans une chaîne. La première façon consiste à utiliser la méthode `charAt()` :


```js
return "chat".charAt(2); // renvoie "a"
```


La seconde méthode, introduite avec ECMAScript 5, est de manipuler la chaîne comme un tableau, où les caractères sont les éléments du tableau et ont un indice correspondant à leur position :


```js
return "chat"[2]; // renvoie "a"
```


En utilisant la seconde notation, il est impossible de supprimer ou d'affecter une valeur à ces propriétés. En effet, les propriétés concernées ne sont ni accessibles en écriture ni configurables. Pour plus d'informations, voir la page de `Object.defineProperty()`.

### Comparer des chaînes de caractères

Les développeurs C utilisent la fonction `strcmp()` pour comparer des chaînes de caractères. En JavaScript, il est possible d'utiliser les opérateurs inférieur et supérieur :


```js
let a = "a";
let b = "b";
if (a < b) {
  // true
  console.log(a + " est inférieure à " + b);
} else if (a > b) {
  console.log(a + " est supérieure à " + b);
} else {
  console.log(a + " et " + b + " sont égales.");
}
```


On peut obtenir un résultat semblable avec la méthode `localeCompare()` qui permet de prendre en compte la locale utilisée et qui est héritée par toutes les instances de `String`.

On notera que `a == b` compare les chaînes de caractères `a` et `b` de façon sensible à la casse. Si on souhaite comparer des chaînes sans être sensible à la casse, on pourra utiliser une fonction semblable à :


```js
function isEqual(str1, str2) {
  return str1.toUpperCase() === str2.toUpperCase();
}
```


On utilise ici une conversion en majuscules plutôt qu'en minuscules, car cela cause certains problèmes de conversion pour certains caractères UTF-8.

### Les différences entre les objets `String` et le type primitif pour les chaînes de caractères

En JavaScript, on distingue d'une part les objets `String` et d'autre par les valeurs primitives qui sont des chaînes de caractères (il en va de même pour les booléens/`Boolean` et les nombres/`Number`).

Les valeurs littérales (délimitées par des simples quotes, des doubles quotes ou des accents graves et les chaînes de caractères renvoyées par les appels à `String` sans le mot-clé `new` sont des chaînes de caractères primitives. JavaScript convertit automatiquement les valeurs primitives en objets `String` et il est donc possible d'utiliser les méthodes objet de `String` sur les chaînes de caractères primitives. Dans les contextes où une méthode est appelée sur une chaîne de caractères primitive ou alors qu'on recherche une propriété, JavaScript convertira implicitement la valeur primitive et appellera la méthode ou accèdera à la propriété correspondante.


```js
let s_prim = "toto";
let s_obj = new String(s_prim);

console.log(typeof s_prim); // affiche "string"
console.log(typeof s_obj); // affiche "object"
```


Les chaînes primitives et les objets `String` renvoient des résultats différents lorsqu'ils sont évalués avec `eval()`. Les chaînes primitives sont traitées comme du code source, tandis que les objets `String` sont traités comme tous les autres objets, en renvoyant l'objet. Par exemple :


```js
let s1 = "2 + 2"; // crée une chaîne primitive
let s2 = new String("2 + 2"); // crée un objet String
console.log(eval(s1)); // renvoie le nombre 4
console.log(eval(s2)); // renvoie la chaîne "2 + 2"
```


Pour ces raisons, il peut y avoir certains problèmes quand le code attend une chaîne primitive plutôt qu'un objet `String`. Toutefois, cette distinction est rarement nécessaire en pratique.

Un objet `String` peut toujours être converti en son équivalent primitif grâce à la méthode `valueOf()`.


```js
console.log(eval(s2.valueOf())); // renvoie 4
```

### Échappement des caractères

En dehors des caractères classiques, des caractères spéciaux peuvent être encodés grâce à l'échappement :

| Code | Résultat |
| --- | --- |
| `\0` | Caractère nul (U+0000 NULL) |
| `\'` | simple quote (U+0027 APOSTROPHE) |
| `\"` | double quote (U+0022 QUOTATION MARK) |
| `\\` | barre oblique inversée (U+005C REVERSE SOLIDUS) |
| `\n` | nouvelle ligne (U+000A LINE FEED; LF) |
| `\r` | retour chariot (U+000D CARRIAGE RETURN; CR) |
| `\v` | tabulation verticale (U+000B LINE TABULATION) |
| `\t` | tabulation (U+0009 CHARACTER TABULATION) |
| `\b` | retour arrière (U+0008 BACKSPACE) |
| `\f` | saut de page (U+000C FORM FEED) |
| `\uXXXX` (`XXXX` étant 4 chiffres hexadécimaux pour l'intervalle of 0x0000 - 0xFFFF) | Point de code Unicode entre U+0000 et U+FFFF (représente le plan Unicode multilingue basique) |
| `\u{X}` ... `\u{XXXXXX}` (`X…XXXXXX` étant 1 à 6 chiffres hexadécimaux pour l'intervalle 0x0 - 0x10FFFF) | Point de code Unicode entre U+0000 et U+10FFFF (représente l'intégralité d'Unicode) |
| `\xXX` (`XX` étant 2 chiffres hexadécimaux pour l'intervalle 0x00 - 0xFF) | Point de code Unicode entre U+0000 et U+00FF (correspond à Basic Latin et Latin-1 supplement ; équivalent à ISO-8859-1) |

### Littéraux pour les chaînes longues

Il peut arriver que le code contienne des chaînes plutôt longues. Plutôt que d'avoir des lignes qui s'étirent sur tout le fichier et dans un éditeur de code, il est possible de casser la chaîne sur plusieurs lignes sans que cela modifie le contenu de la chaîne. Il existe deux façons de faire.

#### Méthode 1


```js
let chaineLongue =
  "Voici une très longue chaîne qui a besoin " +
  " d'être passée à la ligne parce que sinon " +
  " ça risque de devenir illisible.";
```


#### Méthode 2

On peut sinon utiliser le caractère barre oblique inversée "\" à la fin de chaque ligne pour indiquer que la chaîne continue sur la ligne suivante. Il faut bien faire attention à ce que la barre oblique soit bien le dernier caractère de la ligne avant le saut de ligne. Sinon, cela ne fonctionnera pas. Voilà comment se présente cette forme :


```js
let chaineLongue =
  "Voici une très longue chaîne qui a besoin \
d'être passée à la ligne parce que sinon \
ça risque de devenir illisible.";
```


#### Méthode 3

Si les sauts de ligne doivent faire partie du résultat, on peut utiliser l'accent grave comme délimiteur de chaîne. Celui-ci permet d'utiliser des sauts de ligne à l'intérieur de la valeur littérale.


```js
let chaineLongue = `Voici une très longue chaîne qui a besoin
d'être passée à la ligne parce que sinon
ça risque de devenir illisible.`;
```

Constructeur
------------

`String()`

Crée un nouvel `String`. S'il est appelé comme une fonction plutôt que comme un constructeur, il effectue une conversion de la valeur en chaîne de caractères.

Méthodes statiques
------------------

`String.fromCharCode(num1 [, ...[,numN]])`

Renvoie une chaîne de caractères créée en utilisant la séquence indiquée de valeurs Unicode.

`String.fromCodePoint(num1 [, ...[,numN]])`

Renvoie une chaîne de caractères créée en utilisant la séquence indiquée de points de code.

`String.raw()`

Renvoie une chaîne de caractères créée à partir d'un gabarit de chaîne de caractères brut.

Propriétés des instances
------------------------

`String.prototype.length`

Cette propriété indique la longueur de la chaîne de caractères. Elle est en lecture seule.

Méthodes des instances
----------------------

`String.prototype.at(index)`
Expérimental

Renvoie le caractère (exactement un seul codet UTF-16) à l'indice indiqué par `index`. Les indices négatifs sont acceptés, dans ce cas ils indiquent la position par rapport au dernier caractère.

`String.prototype.charAt(index)`

Renvoie le caractère (exactement un seul codet UTF-16) à l'indice indiqué par `index`.

`String.prototype.charCodeAt(index)`

Renvoie un nombre qui est la valeur du codet UTF-16 à l'indice indiqué par `index`.

`String.prototype.codePointAt(pos)`

Renvoie un entier positif qui correspond à la valeur du codet UTF-16 à la position indiquée par `pos`.

`String.prototype.concat(str [,...strN ])`

Combine le texte de deux (ou plusieurs) chaînes en une nouvelle chaîne de caractères.

`String.prototype.includes(searchString [, position])`

Détermine si la chaîne de caractères courante contient `searchString`.

`String.prototype.endsWith(searchString [, length])`

Détermine si la chaîne de caractères courante se termine par `searchString`.

`String.prototype.indexOf(searchValue [, fromIndex])`

Renvoie l'indice, au sein de la chaîne courante, de la première occurrence de `searchValue` ou `-1` si ce motif n'est pas trouvé.

`String.prototype.lastIndexOf(searchValue [, fromIndex])`

Renvoie l'indice, au sein de la chaîne courant, de la dernière occurrence de `searchValue` ou `-1` si ce motif n'est pas trouvé.

`String.prototype.localeCompare(compareString [, locales [, options]])`

Renvoie un nombre indiquant si la chaîne courante vient avant ou après (ou est équivalente à ) `compareString` pour l'ordre de tri.

`String.prototype.match(regexp)`

Permet de tester la correspondance d'une expression rationnelle entre `regexp` et la chaîne de caractères courante.

`String.prototype.matchAll(regexp)`

Renvoie un itérateur contenant l'ensemble des correspondances de l'expression rationnelle `regexp` au sein de la chaîne de caractères courante.

`String.prototype.normalize([form])`

Renvoie la forme Unicode normalisée de la chaîne courante.

`String.prototype.padEnd(targetLength [, padString])`

Complète la chaîne courante à la fin avec une chaîne donnée afin d'obtenir une longueur cible `targetLength` et renvoie la chaîne ainsi construite.

`String.prototype.padStart(targetLength [, padString])`

Complète la chaîne courante au début avec une chaîne donnée afin d'obtenir une longueur cible `targetLength` et renvoie la chaîne ainsi construite.

`String.prototype.repeat(count)`

Renvoie une chaîne de caractères qui est la répétition (`count` fois) de la chaîne de caractères courante.

`String.prototype.replace(searchFor, replaceWith)`

Remplace les occurrences de `searchFor` par `replaceWith`. `searchFor` peut être une chaîne de caractères ou une expression rationnelle et `replaceWith` peut être une chaîne de caractères ou une fonction.

`String.prototype.replaceAll(searchFor, replaceWith)`

Remplace toutes les occurrences de `searchFor` avec `replaceWith`. `searchFor` peut être une chaîne de caractères ou une expression rationnelle et `replaceWith` peut être une chaîne de caractères ou une fonction.

`String.prototype.search(regexp)`

Recherche une correspondance entre une expression rationnelle `regexp` et la chaîne de caractères courante.

`String.prototype.slice(beginIndex[, endIndex])`

Extrait une section de la chaîne de caractères et renvoie une nouvelle chaîne de caractères.

`String.prototype.split([sep [, limit] ])`

Renvoie un tableau de chaînes de caractères composé des fragments de la chaîne courante scindée à chaque occurrence de la sous-chaîne `sep`.

`String.prototype.startsWith(searchString [, length])`

Détermine si la chaîne courante commence par la chaîne de caractères indiquée en paramètre (`searchString`).

`String.prototype.substring(indexStart [, indexEnd])`

Renvoie une nouvelle chaîne de caractères contenant les caractères de la chaîne courante, situés à partir de l'indice donné ou entre les indices donnés.

`String.prototype.toLocaleLowerCase( [locale, ...locales])`

Renvoie une conversion en minuscules de la chaîne de caractères courante qui respecte la locale indiquée.

Pour la plupart des langues, cela renverra la même valeur que `toLowerCase()`.

`String.prototype.toLocaleUpperCase( [locale, ...locales])`

Renvoie une conversion en majuscules de la chaîne de caractères courante qui respecte la locale indiquée.

Pour la plupart des langues, cela renverra la même valeur que `toUpperCase()`.

`String.prototype.toLowerCase()`

Renvoie la valeur de la chaîne de caractères, convertie en minuscules.

`String.prototype.toString()`

Renvoie une chaîne de caractères représentant l'objet courant. Surcharge la méthode `Object.prototype.toString()`.

`String.prototype.toUpperCase()`

Renvoie la valeur de la chaîne de caractères, convertie en majuscules.

`String.prototype.trim()`

Retire les blancs situés au début et à la fin de la chaîne de caractères.

`String.prototype.trimStart()`

Retire les blancs situés au début de la chaîne de caractères.

`String.prototype.trimEnd()`

Retire les blancs situés à la fin de la chaîne de caractères.

`String.prototype.valueOf()`

Renvoie la valeur primitive de l'objet courant. Surcharge la méthode `Object.prototype.valueOf()`.

`String.prototype.@@iterator()`

Renvoie un nouvel objet itérateur qui permet d'itérer sur les points de code composant la chaîne de caractère. Chaque point de code est renvoyé comme une chaîne de caractères.

Méthodes de conversion HTML
---------------------------

**Attention :** Ces méthodes sont dépréciées et ne doivent plus être utilisées.

Elles ont des possibilités limitées et ne concernent qu'une petite sous-partie des éléments et attributs HTML disponibles.

`String.prototype.anchor()`

`<a name="name">` (cible hypertexte)

`String.prototype.big()`

`<big>`

`String.prototype.blink()`

`<blink>`

`String.prototype.bold()`

`<b>`

`String.prototype.fixed()`

`<tt>`

`String.prototype.fontcolor()`

`<font color="color">`

`String.prototype.fontsize()`

`<font size="size">`

`String.prototype.italics()`

`<i>`

`String.prototype.link()`

`<a href="url">` (lien d'une URL)

`String.prototype.small()`

`<small>`

`String.prototype.strike()`

`<strike>`

`String.prototype.sub()`

`<sub>`

`String.prototype.sup()`

`<sup>`

Exemples
--------

### Conversion en chaîne de caractères

Il est possible d'utiliser `String` comme une alternative à `toString()` car cela permet de traiter les valeurs `null`, `undefined` et les symboles. Ainsi :


```js
let chainesSortie = [];
for (let i = 0, n = valeursEntree.length; i < n; ++i) {
  chainesSortie.push(String(valeursEntree[i]));
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-string-objects |

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

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

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

* Formatage du texte dans le guide JavaScript
* `RegExp`
* `DOMString`
* Les chaînes binaires