Chaînes

Tout ensemble de caractères (lettres, chiffres, symboles, etc.) entre un ensemble de guillemets doubles ("), de guillemets simples (') ou d'accents graves (`) est une chaîne primitive. Vous avez déjà vu quelques exemples de chaînes dans ce cours: les instances de console.log du module précédent contenaient des primitives de chaîne.

console.log( "Hello, World." );
> Hello, World.

"Hello, World." est une primitive de chaîne. Vous obtenez le même résultat avec des guillemets simples ou des accents graves:

console.log( 'Hello, World.' );
> Hello, World.

console.log(`Hello, World.`);
> Hello, World.

Une série de caractères placés entre guillemets est appelée littéral de chaîne. Les guillemets simples et doubles se comportent de la même manière, et l'un peut contenir l'autre en tant que caractère dans la chaîne elle-même:

console.log( "I'm a string." );
> I'm a string.

console.log( '"A string," I said.' );
> "A string," I said.

Une instance du même caractère englobant dans la chaîne "ferme" la chaîne, ce qui provoque probablement des erreurs:

console.log( '"I'm a string," I said.' );
> Uncaught SyntaxError: missing ) after argument list

Pour éviter cela, échappez le caractère à l'aide d'une barre oblique inverse (``):

console.log( '"I\'m a string," I said.' );
> "I'm a string," I said.

Objet chaîne

Lorsqu'il est appelé en tant que fonction, l'objet String convertit (par coercition) une valeur spécifiée en littéral de chaîne.

let myString = String( 10 );

myString
> "10"

typeof myString
> string

Comme détaillé dans la section Héritage prototypique, vous aurez rarement besoin d'utiliser l'objet String en tant que constructeur. Elle crée un objet de chaîne contenant la valeur spécifiée, ainsi que les méthodes et propriétés déjà fournies par l'objet String, au lieu d'un littéral de chaîne.

let stringObj = new String( "My new string." );

typeof stringObj
> object

stringObj
> String { "My new string." }

Concaténation

Lorsqu'il est utilisé dans le contexte de chaînes plutôt que de nombres, un signe plus unique (+) agit comme un opérateur de concaténation, combinant plusieurs valeurs de chaîne en une seule chaîne:

console.log( "My" + " string." );
> My string.

Littéraux de chaîne et littéraux de modèle

Les guillemets simples, les guillemets doubles et les accents graves peuvent être utilisés de manière interchangeable pour créer des primitives de chaîne. Toutefois, vous pouvez également utiliser des accents graves pour spécifier des littéraux de modèle (parfois appelés "chaînes de modèle"). Contrairement aux littéraux de chaîne créés par des guillemets simples ou doubles, les littéraux de modèle permettent les chaînes multilignes et l'interpolation de chaîne.

const myString = "This
is a string.";
> Uncaught SyntaxError: "" string literal contains an unescaped line break

const myString = `This
is a string.`;

console.log( myString );

> This
is a string.

Les littéraux de modèle peuvent contenir des expressions d'espace réservé marquées par un signe dollar et des accolades (${}). Ces espaces réservés sont "interpolés" par défaut, ce qui signifie que le résultat de l'expression remplace l'espace réservé dans la chaîne finale.

console.log( "The result is " + ( 2 + 4 ) + "." );
> The result is 6.

console.log( `The result is ${ 2 + 4 }.` );
> The result is 6.

Un littéral de modèle peut être transmis à une fonction personnalisée pour créer un modèle tagué. Il s'agit d'un appel de fonction qui utilise un seul littéral de modèle comme ensemble d'arguments et qui permet de remplir ses espaces réservés en fonction de la logique définie par l'auteur.

Le premier argument d'une fonction de balise contient un tableau de valeurs de chaîne, et les autres arguments définissent les espaces réservés. Ce tableau de valeurs de chaîne est créé en "divisant" le littéral de modèle au niveau de chaque espace réservé qu'il contient. Le premier élément du tableau contient tous les caractères jusqu'au premier espace réservé, le deuxième élément contient des caractères entre les premier et deuxième espaces réservés, et ainsi de suite. Chaque espace réservé est transmis à la fonction de balise en tant que valeur autonome avec un espace réservé associé.

const myNoun = "template literal";

function myTagFunction( myStrings, myPlaceholder ) {
    const myInitialString = myStrings[ 0 ];
    console.log( `${ myInitialString }modified ${ myPlaceholder }.` );
}

myTagFunction`I'm a ${ myNoun }.`;
> "I'm a modified template literal."

Testez vos connaissances