Chaînes en JavaScript

En JavaScript, les chaînes sont utilisées pour stocker et manipuler le texte. Il n'existe pas de type distinct pour un seul caractère. Le format interne des chaînes est toujours UTF-16.

Une chaîne représente zéro ou plusieurs caractères qui sont écrits entre guillemets.

À propos des guillemets

Nous pouvons distinguer les guillemets simples, les guillemets doubles, et les backticks:

let single = 'single-quoted';
let double = "double-quoted"; 
let backticks = `backticks`;

Les guillemets doubles et simples sont identiques. En revanche, les backticks sont différents. Vous pouvez les utiliser pour intégrer n'importe quelle expression dans la chaîne en l'enveloppant dans ${…} comme suit:

Strings in javascript
let str = "W3Docs"; console.log(`Welcome to ${str}`); // Welcome to W3Docs

L'un des avantages essentiels des backticks est qu'ils permettent à une chaîne de s'étendre sur plusieurs lignes comme ceci:

Strings in javascript
let languagesList = `Languages: * Javascript * Php * Java `; console.log(languagesList); // a list of languages, multiple lines

Mais, notez que les guillemets simples et les guillemets doubles ne fonctionneront pas dans ce cas. Si vous les utilisez en essayant d'appliquer plusieurs lignes, une erreur se produira:

let guestList = "Guests: // Error: Unexpected token ILLEGAL 
* John ";

Les guillemets simples et doubles sont apparus plus tôt que les backticks. Ainsi, les backticks sont plus fonctionnels.

Vous pouvez également spécifier une “fonction de modèle” avant le premier backtick. La syntaxe ressemblera à ceci:

func `string`

En règle générale, la fonction func est appelée automatiquement. Elle reçoit à la fois la chaîne et les expressions intégrées les traitant. En utilisant cette fonctionnalité, vous pouvez rapidement mettre en œuvre un templating personnalisé. Cependant, les développeurs l'utilisent rarement en pratique.

Caractères spéciaux

Vous pouvez créer des chaînes multilignes avec des guillemets doubles et simples à l'aide de \n, comme cela:

Strings in javascript
let languagesList = "Languages:\n * Javascript\n * Php\n * Java"; console.log(languagesList); // a multiline list of languages

Il existe d'autres caractères spéciaux moins courants.

Voici quelques-uns d'entre eux dans la liste ci-dessous:

  • \', \" ces caractères spéciaux sont utilisés pour les guillemets
  • \r - retour à la ligne. Ce caractère n'est plus utilisé seul. Une combinaison de deux caractères \r\n est utilisée pour représenter un saut de ligne dans les fichiers texte Windows.
  • \\ - backslash
  • \t - tabulation
  • \xXX - caractère unicode avec un unicode hexadécimal particulier XX
  • \uXXXX - c'est le symbole unicode avec le code hexadécimal XXXX en encodage UTF-16. Il doit comporter exactement 4 chiffres.

Voici des exemples avec des codes unicode:

Unicode strings in javascript
console.log("\u00E9"); // é console.log("\u{03BB}"); // λ

Prenez en compte que tous les caractères spéciaux commencent par un backslash. Il est aussi connu comme un “caractère d'échappement”.

Vous pouvez également l'utiliser si vous souhaitez mettre un guillemet dans la chaîne.

Voici un exemple:

Strings in javascript
console.log('This\'s the W3Docs site!'); // This’s the W3Docs site

Aussi, considérez que le backslash est principalement utilisé pour corriger la lecture de la chaîne par JavaScript, après quoi il disparaît. Dans la mémoire de la chaîne, vous ne pouvez trouver aucun \ . Mais lorsque vous avez besoin d'afficher un vrai backslash dans la chaîne, vous devez le doubler comme dans cet exemple:

Strings in javascript
console.log(`The backslash: \\`); // The backslash: \ let backslash = "aa ///\\"; // This is correct // let backslash = "aa ///\"; // This is not. console.log(backslash);

La Longueur de la Chaîne

La propriété length est utilisée pour trouver la longueur d'une chaîne:

Strings length in javascript
console.log(`W3Docs\n`.length); // 7

Notez que \n est un caractère spécial. Par conséquent, la longueur doit être 7.

Parfois, les développeurs font une faute de frappe sur cette propriété en appelant str.length() au lieu de simplement str.length. Cela ne fonctionnera pas.

Accéder aux Caractères

Les crochets carrés[pos] sont principalement utilisés pour obtenir un caractère à une position [pos]. Vous pouvez le faire en appelant également la méthode str.charAt(pos). Le tout premier caractère doit commencer à partir de zéro:

Character at a position strings in javascript
let str = `Welcome`; // the first character console.log(str[0]); // W console.log(str.charAt(0)); // W // the last character console.log(str[str.length - 1]); // e

Les développeurs modernes préfèrent utiliser les crochets carrés, tandis que le charAt est rarement utilisé

Les Chaînes sont Immuables

Il n'est pas possible de modifier les chaînes en JavaScript. Regardez cet exemple pour vous assurer que cela ne fonctionnera pas:

Change character at a position strings in javascript
let str = 'Welcome'; str[0] = 'w'; console.log(str[0]);

La pratique courante consiste à créer une nouvelle chaîne en l'assignant à str au lieu de l'ancienne comme ceci:

Character at a position strings in javascript
let str = 'Hi'; str = 'h' + str[1]; // replace the string console.log(str); // hi

Changement de Cas

Nous pouvons distinguer deux méthodes de changement de cas. Les voici:

toUpperCase change strings in javascript
console.log('Welcome to W3Docs'.toUpperCase()); // WELCOME TO W3DOCS console.log('Welcome to W3Docs'.toLowerCase()); // welcome to w3docs

Dans un autre scénario, si un seul caractère doit être en minuscule, utilisez cette méthode:

toLowerCase change strings in javascript
console.log('Welcome to W3Docs' [0].toLowerCase()); // 'w'

Recherche d'une Sous-chaîne

Découvrons les moyens de rechercher une sous-chaîne à l'intérieur d'une chaîne.

str.indexOf

Il s'agit de la première méthode qui est utilisée pour rechercher le substr dans str. Elle commence à partir de la position particulière pos et retourne cette position lorsque la correspondance est trouvée, ou -1, dans le cas où rien n'est trouvé.

Jetons un œil à l'exemple suivant:

Index strings in javascript
let str = 'Welcome to W3Docs'; console.log(str.indexOf('Welcome')); // 0, because 'Welcome' is found at the beginning console.log(str.indexOf('welcome')); // -1, not found, the search is case-sensitive console.log(str.indexOf("W3Docs")); // 11, "W3Docs" is found at the position 11

str.lastIndexOf(substr, position)

Cette méthode recherche de la fin d'une chaîne vers le début. Les occurrences seront répertoriées dans l'ordre inverse.

Notez une légère difficulté avec indexOf à l'intérieur du test if. Il ne peut pas être mis dans if de cette façon:

Index strings in javascript
let str = "Welcome to W3Docs"; if (str.indexOf("Welcome")) { console.log("Thank you"); // doesn't work! }

Il est donc nécessaire de vérifier le -1, comme suit:

Index strings in javascript
let str = "Welcome to W3Docs"; if (str.indexOf("Welcome") != -1) { console.log("Thank you"); // works now }

Includes, startsWith, endsWith

La méthode plus récente str.includes(substr, pos) est capable de retourner true/false en fonction de la présence ou non du substr dans la str.

Agissez comme dans l'exemple, si vous avez besoin de tester la correspondance sans avoir besoin de sa position en même temps:

Includes strings in javascript
console.log("Welcome to W3Docs".includes("Welcome")); // true console.log("Hi".includes("Bye")); // false

Le second argument de str.includes est la position à partir de laquelle vous commencez la recherche. Voici un exemple:

Includes strings in javascript
console.log("Welcome".includes("come")); // true console.log("Welcome".includes("come", 5)); // false, from position 5 there is no "come"

Obtenir une Sous-chaîne

JavaScript comprend trois méthodes pour obtenir une sous-chaîne: substring, substr, et slice.

str.slice(start [, end])

Cette méthode est utilisée pour retourner la partie de la chaîne de start à end.

Par exemple:

The slice method in javascript strings
let str = "welcome"; console.log(str.slice(0, 6)); // 'welcom', the substring from 0 to 6 (not including 6) console.log(str.slice(0, 1)); // 'w', from 0 to 1, but not including 1, so only character at 0

Si un second argument est absent, le slice ira jusqu'à la fin, comme ceci:

Slice in javascript strings
let str = "welcome"; console.log(str.slice(3)); // 'come', from the 3-position till the end

Pour start/end vous pouvez également utiliser des valeurs négatives.

Par exemple:

The slice in javascript strings
let str = "welcome "; // start at the 5th position from the right, end at the 1st from the right console.log(str.slice(-5, -1)); // 'come'

str.substring(start [, end])

Cette méthode est utilisée pour retourner la partie de la chaîne entre le start et le end.

Il ressemble beaucoup à slice. La différence la plus notable est qu'avec cette méthode, le start peut être supérieur au end.

Par exemple:

The substring in javascript strings
let str = "welcome"; // these are same for substring console.log(str.substring(3, 6)); // "com" console.log(str.substring(6, 3)); // "com" // ...but not for slice: console.log(str.slice(3, 6)); // "com" (the same) console.log(str.slice(6, 3)); // "" (an empty string)

str.substr(start [, length])

Cette méthode retourne la partie de la chaîne à partir du start, avec une longueur déterminée. Il diffère des méthodes précédentes. Cette méthode vous aidera à spécifier la length au lieu de la position de fin.

Par exemple:

The substr in javascript strings
let str = "welcome"; console.log(str.substr(3, 4)); // 'come', from the 3-position get 4 characters

Le premier argument peut être négatif pour compter à partir de la fin:

The substr in javascript strings
let str = "welcome"; console.log(str.substr(-4, 2)); // 'co', from the 4th position get 2 characters

Comparaison des Chaînes

Il est essentiel de savoir que les chaînes doivent être comparées caractère par caractère dans l'ordre alphabétique.

Il est préférable de prendre également en compte les caractéristiques suivantes:

  1. Une minuscule est plus grande qu'une majuscule, comme ceci:
    Comparison in javascript strings
    console.log('a' > 'Z'); // true
  2. Les lettres comportant des signes diacritiques sont considérées comme étant “hors de l'ordre”.

Par exemple:

Comparison in javascript strings
console.log('Germany' > 'England'); // true

Maintenant, commençons à examiner la représentation interne des chaînes en JavaScript.

En JavaScript, nous codons toutes les chaînes à l'aide de UTF-16. Cela signifie que chacun des caractères a un code numérique approprié.

str.codePointAt(pos)

Il est utilisé pour retourner le code pour le caractère à la position pos :

Return the code for the character at position javascript string
// different case letters have different codes console.log("w".codePointAt(0)); // 119 console.log("W".codePointAt(0)); // 87

String.fromCodePoint(code)

Crée un caractère par le code numérique:

Character's numeric code javascript string
console.log(String.fromCodePoint(80)); // P

Les caractères Unicode peuvent également être ajoutés par leurs codes en appliquant \u suivi du code hexadécimal.

Par exemple:

Unicode characters javascript string
// 90 is 5a in hexadecimal system console.log('\u005a'); // Z

Regardons les caractères avec les codes 65..220 et faisons une chaîne d'eux:

Unicode characters javascript string
let str = ''; for (let i = 65; i <= 220; i++) { str += String.fromCodePoint(i); } console.log(str); // ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„ // ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁ ÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜ

Ici, vous pouvez constater que les caractères en majuscules vont d'abord, puis plusieurs caractères spéciaux, et enfin, Ö à la fin de la sortie.

Heure du Quiz : Testez Vos Compétences!

Prêt à relever le défi de ce que vous avez appris ? Plongez dans nos quiz interactifs pour approfondir votre compréhension et renforcer vos connaissances de manière ludique.

Trouvez-vous cela utile?