String

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

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.

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

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.

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

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

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.`;

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.

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.

String.prototype.length

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

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.

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>

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]));
}

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