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() :

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`;
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() :

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 :

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 :

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 à :

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.

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 :

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().

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

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 :

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.

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) (en-US)
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 :

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

Spécifications

Specification
ECMAScript Language Specification (ECMAScript)
# sec-string-objects

Compatibilité des navigateurs

BCD tables only load in the browser

Voir aussi