JavaScript, étant un langage polyvalent, offre une multitude de fonctions pour travailler avec des chaînes. Les chaînes sont l’un des types de données les plus fondamentaux dans tout langage de programmation, et comprendre comment les manipuler efficacement peut améliorer considérablement vos compétences en codage. Dans cet article, nous approfondirons les fonctions de chaîne JavaScript, en fournissant des explications détaillées, des exemples et des commentaires pour vous aider à les maîtriser.

Introduction aux chaînes en JavaScript

En JavaScript, une chaîne est une séquence de caractères utilisée pour représenter du texte. Les chaînes sont immuables, ce qui signifie qu’une fois créées, elles ne peuvent pas être modifiées. Au lieu de cela, les opérations sur les chaînes créent de nouvelles chaînes.

let greeting = "Hello, World!";
console.log(greeting); // Output: Hello, World!

Création de chaînes

Les chaînes peuvent être créées à l'aide de guillemets simples, de guillemets doubles ou de guillemets inversés pour les littéraux de modèle.

let singleQuoteStr = 'Hello';
let doubleQuoteStr = "Hello";
let templateLiteralStr = `Hello, ${singleQuoteStr}`;
console.log(templateLiteralStr); // Output: Hello, Hello

Propriétés de chaîne

• length : renvoie la longueur de la chaîne.

let str = "JavaScript";
console.log(str.length); // Output: 10

Méthodes de chaîne

1. charAt()

Renvoie le caractère à un index spécifié.

let str = "JavaScript";
console.log(str.charAt(0)); // Output: J

2. charCodeAt()

Renvoie l'Unicode du caractère à un index spécifié.

let str = "JavaScript";
console.log(str.charCodeAt(0)); // Output: 74

3. concaténer()

Concatène deux chaînes ou plus et renvoie une nouvelle chaîne.

let str1 = "Hello, ";
let str2 = "World!";
let result = str1.concat(str2);
console.log(result); // Output: Hello, World!

4. inclut()

Vérifie si une chaîne contient une valeur spécifiée, renvoyant vrai ou faux.

let str = "JavaScript is awesome!";
console.log(str.includes("awesome")); // Output: true

5. se termineAvec()

Vérifie si une chaîne se termine par une valeur spécifiée, renvoyant vrai ou faux.

let str = "Hello, World!";
console.log(str.endsWith("World!")); // Output: true

6. indexDe()

Renvoie l'index de la première occurrence d'une valeur spécifiée, ou -1 si elle n'est pas trouvée.

let str = "JavaScript is awesome!";
console.log(str.indexOf("is")); // Output: 11

7. dernierIndexOf()

Renvoie l'index de la dernière occurrence d'une valeur spécifiée, ou -1 si elle n'est pas trouvée.

let str = "JavaScript is awesome! JavaScript is fun!";
console.log(str.lastIndexOf("JavaScript")); // Output: 22

8. correspondance()

Récupère les correspondances lors de la correspondance d'une chaîne avec une expression régulière.

let str = "JavaScript is awesome!";
let regex = /is/g;
console.log(str.match(regex)); // Output: [ 'is', 'is' ]

9. répéter()

Renvoie une nouvelle chaîne avec un nombre spécifié de copies de la chaîne sur laquelle elle a été appelée.

let str = "Hello!";
console.log(str.repeat(3)); // Output: Hello!Hello!Hello!

let str = "Bonjour !"; console.log(str.repeat(3)); // Sortie : Bonjour ! Bonjour ! Bonjour !

10. remplacer()

Remplace une valeur spécifiée par une autre valeur dans une chaîne.

let str = "Hello!";
console.log(str.repeat(3)); // Output: Hello!Hello!Hello!

let str = "JavaScript est génial !"; let newStr = str.replace("génial", "fantastique"); console.log(newStr); // Résultat : JavaScript est fantastique !

11. recherche()

Recherche dans une chaîne une valeur spécifiée et renvoie la position de la correspondance.

let str = "Hello!";
console.log(str.repeat(3)); // Output: Hello!Hello!Hello!

let str = "JavaScript est génial !"; console.log(str.search("génial")); // Sortie : 15

12. tranche()

Extrait une partie d'une chaîne et la renvoie sous la forme d'une nouvelle chaîne.

let str = "Hello!";
console.log(str.repeat(3)); // Output: Hello!Hello!Hello!

let str = "JavaScript"; console.log(str.slice(0, 4)); // Sortie : Java

13. diviser()

Divise une chaîne en un tableau de sous-chaînes en fonction d'un séparateur spécifié.

let str = "Hello!";
console.log(str.repeat(3)); // Output: Hello!Hello!Hello!

let str = "Bonjour le monde !"; let arr = str.split(", "); console.log(arr); // Sortie :

14. commenceAvec()

Vérifie si une chaîne commence par une valeur spécifiée, renvoyant vrai ou faux.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "Bonjour le monde !"; console.log(str.startsWith("Bonjour")); // Sortie : vrai

15. sous-chaîne()

Extrait les caractères d'une chaîne entre deux indices spécifiés.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "JavaScript"; console.log(str.substring(0, 4)); // Sortie : Java

16. toLowerCase()

Convertit une chaîne en lettres minuscules.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "JavaScript"; console.log(str.toLowerCase()); // Sortie : javascript

17. toUpperCase()

Convertit une chaîne en lettres majuscules.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "JavaScript"; console.log(str.toUpperCase()); // Sortie : JAVASCRIPT

18. couper()

Supprime les espaces aux deux extrémités d'une chaîne.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = " JavaScript "; console.log(str.trim()); // Sortie : JavaScript

19. trimStart()

Supprime les espaces au début d'une chaîne.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "JavaScript"; console.log(str.trimStart()); // Sortie : JavaScript

20. trimEnd()

Supprime les espaces à la fin d'une chaîne.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = "JavaScript"; console.log(str.trimEnd()); // Sortie : JavaScript

21. valeurDe()

Renvoie la valeur primitive d'un objet String.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = new String("JavaScript"); console.log(str.valueOf()); // Sortie : JavaScript

Littéraux de modèle

Les littéraux de modèle permettent d'intégrer des expressions, ce qui facilite la concaténation de chaînes et les chaînes multilignes.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let nom = "Jean"; let Greeting = `Bonjour, ${name} ! Comment vas-tu ? console.log(salutation); // Résultat : Bonjour, John ! Comment vas-tu?

String.raw()

Renvoie une chaîne créée à partir d'une chaîne de modèle brute, permettant l'accès aux chaînes brutes au fur et à mesure de leur écriture.

let str = "Hello, World!";
console.log(str.startsWith("Hello")); // Output: true

let str = String.raw`Bonjour\nMonde !`; console.log(str); // Sortie : Bonjour\nMonde !

Exemples pratiques

function reverseString(str) {
    return str.split('').reverse().join('');
}
console.log(reverseString("JavaScript")); // Output: tpircSavaJ

fonction reverseString(str) { return str.split('').reverse().join(''); } console.log(reverseString("JavaScript")); // Sortie : tpircSavaJ

function isPalindrome(str) {
    let cleanedStr = str.replace(/[\W_]/g, '').toLowerCase();
    return cleanedStr === cleanedStr.split('').reverse().join('');
}
console.log(isPalindrome("A man, a plan, a canal, Panama")); // Output: true

fonction estPalindrome(str) { let cleanStr = str.replace(/[\W_]/g, '').toLowerCase(); return cleanStr === cleaningStr.split('').reverse().join(''); } console.log(isPalindrome("Un homme, un plan, un canal, Panama")); // Sortie : vrai

function capitalizeWords(str) {
    return str.split(' ').map(word => word.charAt(0).toUpperCase()   word.slice(1)).join(' ');
}
console.log(capitalizeWords("hello world")); // Output: Hello World

fonction majusculeMots(str) { return str.split(' ').map(word => word.charAt(0).toUpperCase() word.slice(1)).join(' '); } console.log(capitalizeWords("bonjour tout le monde")); // Sortie : Bonjour tout le monde

Conclusion

La maîtrise des fonctions de chaîne JavaScript est cruciale pour une manipulation efficace du texte et des données. Des opérations de base telles que la concaténation et le découpage aux fonctions plus avancées telles que la correspondance d'expressions régulières et les littéraux de modèles, JavaScript fournit un riche ensemble d'outils pour travailler avec des chaînes. En comprenant et en utilisant ces fonctions, vous pouvez écrire du code plus propre et plus efficace et relever un large éventail de défis de programmation.

Ce guide complet a couvert les fonctions de chaîne les plus importantes en JavaScript, avec des exemples et des explications. Pratiquez ces fonctions et expérimentez différents cas d'utilisation pour consolider votre compréhension et améliorer vos compétences en codage.