Chaînes

N'importe quel jeu de caractères (lettres, chiffres, symboles, etc.) entre un ensemble de Guillemets doubles ("), guillemets simples (') ou guillemets obliques (`) est une primitive de chaîne. Vous avez déjà vu quelques exemples de chaînes dans ce cours: les instances de console.log du module précédent contenaient les 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 une guillemets ou guillemets obliques:

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 doubles et simples 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 "fers" la 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 un littéral de chaîne.

let myString = String( 10 );

myString
> "10"

typeof myString
> string

Comme détaillé dans la section sur l'héritage des prototypes, vous aurez rarement besoin d'utiliser l'objet String comme constructeur. Il crée un objet de chaîne contenant la valeur spécifiée, ainsi que les méthodes et les propriétés déjà fournies par l'objet String, au lieu d'une chaîne littérale.

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 chiffres, un seul signe plus (+) 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 guillemets obliques peuvent être utilisés de manière interchangeable pour en créant des primitives de chaîne. Cependant, vous pouvez également utiliser des accents graves pour spécifier littéraux de modèle (parfois appelés "chaînes de modèle"). Contrairement au Les littéraux de chaîne créés avec des guillemets simples ou doubles, les littéraux de modèle permettent pour 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 d'un signe dollar et des accolades (${}). Ces espaces réservés sont "interpolés" par défaut, Cela signifie que le résultat de l'expression remplace l'espace réservé dans le .

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é, un appel de fonction qui utilise un seul modèle comme un ensemble d'arguments et permet à ses espaces réservés de s'afficher en fonction 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 créée par "splitting" le littéral de modèle pour chaque espace réservé qu'il contient. La le premier élément du tableau contient tous les caractères jusqu'au premier espace réservé, le deuxième élément contient tout caractère compris entre le premier et le deuxième des espaces réservés, et ainsi de suite. Chaque espace réservé est transmis à la fonction de tag 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