Un guide sur le type de données de chaîne principale en JavaScript

JavaScript, étant un langage polyvalent, offre une pléthore 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!

10. remplacer()

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

let str = "JavaScript is awesome!";
let newStr = str.replace("awesome", "fantastic");
console.log(newStr); // Output: JavaScript is fantastic!

11. recherche()

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

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

12. tranche()

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

let str = "JavaScript";
console.log(str.slice(0, 4)); // Output: 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, World!";
let arr = str.split(", ");
console.log(arr); // Output: [ 'Hello', 'World!' ]

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

15. sous-chaîne()

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

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

16. toLowerCase()

Convertit une chaîne en lettres minuscules.

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

17. toUpperCase()

Convertit une chaîne en lettres majuscules.

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

18. couper()

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

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

19. trimStart()

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

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

20. trimEnd()

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

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

21. valeurDe()

Renvoie la valeur primitive d'un objet String.

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

Littéraux de modèle

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

let name = "John";
let greeting = `Hello, ${name}! How are you?`;
console.log(greeting); // Output: Hello, John! How are you?

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 = String.raw`Hello\nWorld!`;
console.log(str); // Output: Hello\nWorld!

Exemples pratiques

Exemple 1 : Inverser une chaîne

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

Exemple 2 : Vérification des palindromes

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

Exemple 3 : Mettre en majuscule la première lettre de chaque mot

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

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.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!