Guide des méthodes JS [chaînes de caractères]
Tags: javascript, beginners, string, french
Published: 2023-06-14 10:12:50

Cet article recense les méthodes Javascript permettant de manipuler des chaînes de caractères les plus utilisées. Si tu souhaites lire un résumé plus court, je t'encourage à consulter [cet article](https://dev.to/kureru/javascript-12-methodes-essentielles-pour-les-chaines-de-caracteres-5b6).

Voici la liste des méthodes mentionnées dans cet article : 

- [.charAt()](#.charat())
- [.charCodeAt()](#.charCodeAt())
- [.concat()](#.concat())
- [.includes()](#.includes())
- [.indexOf()](#.indexOf())
- [.match()](#.match())
- [.repeat()](#.repeat())
- [.replace()](#.replace())
- [.search()](#.search())
- [.slice()](#.slice())
- [.split()](#.split())
- [.substr()](#.substr())
- [.toLowerCase()](#.toLowerCase())
- [.toUpperCase()](#.toUpperCase())
- [.trim()](#.trim())


## `.charAt()`

### Définition
La méthode charAt() renvoie une nouvelle chaîne de caractère contenant le caractère à l'indice indiqué en argument.

### Syntaxe 
`str.charAt(indice)` 

- `str` : chaîne sur laquelle on effectue l'opération
- `indice` :  indice du caractère que l'on souhaite récupérer

### Complexité temporelle
La complexité temporelle de la méthode .charAt() est O(1), ce qui signifie que le temps d'exécution de la méthode ne dépend pas de la longueur de la chaîne. Peu importe la taille de la chaîne, la méthode charAt() renvoie le caractère à l'index spécifié en temps constant.

### Cas d'usage

**Accéder au premier caractère d'une chaîne**
```javascript

const str = "Hello, world!";
const firstCharacter = str.charAt(0);
console.log(firstCharacter); // Output: "H"
```

Ce code utilise charAt(0) pour accéder au premier caractère de la chaîne str et le stocke dans la variable firstCharacter.

**Parcourir une chaîne caractère par caractère**
```javascript
const str = "Hello";
for (let i = 0; i < str.length; i++) {
  const character = str.charAt(i);
  console.log(character);
}
```

Dans cet exemple, nous utilisons charAt(i) à l'intérieur d'une boucle for pour parcourir chaque caractère de la chaîne str. À chaque itération, le caractère à l'index i est récupéré et affiché.

**Vérifier si une chaîne contient un caractère spécifique**
```javascript
const str = "Hello, world!";
const index = str.indexOf("w");
if (index !== -1) {
  const character = str.charAt(index);
  console.log(character); // Output: "w"
} else {
  console.log("Le caractère spécifié n'a pas été trouvé.");
}
```
Dans ce cas, nous utilisons indexOf("w") pour trouver l'index de la première occurrence du caractère "w" dans la chaîne str. Si l'index est différent de -1, cela signifie que le caractère a été trouvé, alors nous utilisons charAt(index) pour récupérer le caractère correspondant à cet index.




## `.charCodeAt()`

### Définition
La méthode .charCodeAt() renvoie le <u>code Unicode</u> d'un caractère situé à un index donné dans la chaîne. 

<u>Le code Unicode</u> représente un identifiant numérique unique attribué à chaque caractère dans le système Unicode.

### Syntaxe 
`str.charCodeAt(indice)` 

- `str` : chaîne sur laquelle on effectue l'opération
- `indice` :  indice du caractère dont on souhaite obtenir le code Unicode. 

### Complexité temporelle
La complexité temporelle de la méthode `.charCodeAt()` est O(1). Comme pour `.charAt()`, cela signifie que le temps d'exécution de la méthode ne dépend pas de la longueur de la chaîne.

### Cas d'usage

**Obtenir le code Unicode d'un caractère spécifique**

```javascript
const str = "Hello";
const charCode = str.charCodeAt(0);
console.log(charCode); // Sortie : 72
```

Ce code utilise `charCodeAt(0)` pour obtenir le code Unicode du premier caractère de la chaîne str.

**Parcourir une chaîne et afficher les codes Unicode de chaque caractère**

```javascript
const str = "Hello";
for (let i = 0; i < str.length; i++) {
  const charCode = str.charCodeAt(i);
  console.log(charCode);
}
```

Dans cet exemple, nous utilisons `charCodeAt(i)` à l'intérieur d'une boucle for pour parcourir chaque caractère de la chaîne str et afficher son code Unicode.

**Vérifier si une chaîne contient un caractère spécial en utilisant son code Unicode**
```javascript
const str = "Hello, world!";
const targetCharCode = 33; // Code Unicode du point d'exclamation
for (let i = 0; i < str.length; i++) {
  const charCode = str.charCodeAt(i);
  if (charCode === targetCharCode) {
    console.log("Le caractère spécial a été trouvé à l'index", i);
    break;
  }
}
```

Dans cet exemple, nous utilisons `charCodeAt(i)` pour obtenir le code Unicode de chaque caractère de la chaîne str. Nous comparons ensuite ces codes avec le code Unicode du caractère spécial recherché (dans ce cas, le point d'exclamation) pour vérifier s'il est présent dans la chaîne. Si nous trouvons le caractère spécial, nous affichons son index et nous quittons la boucle avec break.



## `.concat()`

### Définition
La méthode .concat() est une méthode de chaîne de caractères en JavaScript qui permet de concaténer, c'est-à-dire de fusionner, deux ou plusieurs chaînes en une seule chaîne. Elle renvoie une nouvelle chaîne qui est le résultat de la concaténation des chaînes d'origine.

### Syntaxe 
`str.concat(string2, string3, ..., stringN)` 

- `str` : chaîne d'origine à laquelle on ajoute d'autres chaînes
- `string2, string3, ..., stringN` :  la ou les chaîne(s) à concaténer avec la chaîne d'origine. 


### Complexité temporelle
La complexité temporelle de la méthode `.concat()` dépend de la longueur totale des chaînes à concaténer. Dans le pire des cas, où la longueur totale des chaînes est grande, la complexité peut être linéaire, soit O(n), où n est la longueur totale des chaînes.

### Cas d'usage

**Concaténer deux chaînes**
```javascript
const str1 = "Hello";
const str2 = " world!";
const concatenated = str1.concat(str2);
console.log(concatenated); // Sortie : "Hello world!"
```

Dans cet exemple, nous utilisons `.concat()` pour concaténer les chaînes str1 et str2 en une seule chaîne, qui est ensuite stockée dans la variable concatenated.

**Concaténer plusieurs chaînes**

```javascript
const str1 = "Hello";
const str2 = ", ";
const str3 = "world";
const str4 = "!";
const concatenated = str1.concat(str2, str3, str4);
console.log(concatenated); // Sortie : "Hello, world!"
```

Dans cet exemple, nous utilisons `.concat()` pour concaténer les chaînes str1, str2, str3 et str4 en une seule chaîne, qui est ensuite stockée dans la variable concatenated.

**Concaténer une chaîne avec une valeur non textuelle**
```javascript
const str1 = "The value is: ";
const value = 42;
const concatenated = str1.concat(value);
console.log(concatenated); // Sortie : "The value is: 42"
```

Dans cet exemple, nous utilisons .concat() pour concaténer la chaîne str1 avec la valeur numérique value. La méthode .concat() convertit automatiquement la valeur non textuelle en une chaîne avant de la concaténer avec la chaîne d'origine.


## `.includes()`

### Définition
La méthode `.includes()` permet de déterminer si une chaîne de caractères contient une autre chaîne spécifiée. Elle effectue une recherche de correspondance et renvoie un booléen indiquant si la sous-chaîne est présente ou non.

### Syntaxe 
`str.includes(élémentRecherché)` 

- `str` : chaîne où l'on effectue la recherche
- `élémentRecherché` :  la sous-chaîne que l'on cherche


### Complexité temporelle
La complexité temporelle de la méthode `.includes()` est linéaire, soit O(n), où n est la longueur de la chaîne principale. Cela signifie que le temps d'exécution de la méthode dépend de la longueur de la chaîne sur laquelle elle est appelée.

### Cas d'usage

**Vérifier si une chaîne contient une sous-chaîne**

```javascript
const str = "Hello, world!";
const hasSubstring = str.includes("world");
console.log(hasSubstring); // Sortie : true
```

Dans cet exemple, nous utilisons `.includes()` pour vérifier si la chaîne str contient la sous-chaîne "world". La méthode renvoie true car la sous-chaîne est présente dans la chaîne principale.

**Vérifier si une chaîne contient un caractère spécifique**

```javascript
const str = "Hello, world!";
const hasCharacter = str.includes("o");
console.log(hasCharacter); // Sortie : true
```

Dans cet exemple, nous utilisons `.includes()` pour vérifier si la chaîne str contient le caractère "o". La méthode renvoie true car le caractère est présent dans la chaîne principale.

**Vérifier si une chaîne ne contient pas une sous-chaîne**

```javascript
const str = "Hello, world!";
const hasSubstring = str.includes("foo");
console.log(hasSubstring); // Sortie : false
```

Dans cet exemple, nous utilisons `.includes()` pour vérifier si la chaîne str contient la sous-chaîne "foo". La méthode renvoie false car la sous-chaîne n'est pas présente dans la chaîne principale.



## `.indexOf()`

### Définition
La méthode `.indexOf()` recherche la première occurrence d'une sous-chaîne dans la chaîne principale et renvoie l'indice de cette occurrence. Si la sous-chaîne n'est pas trouvée, elle renvoie -1.

### Syntaxe 
`str.indexOf(sousChaine, elementDepart)` 

- `str` : La chaîne dans laquelle on recherche la sous-chaîne.
- `sousChaine` : chaîne que l'on recherche
- `elementDepart` : (facultatif)  L'indice à partir duquel la recherche doit commencer. Par défaut, la recherche commence à l'indice 0.


### Complexité temporelle
La complexité temporelle de la méthode `.indexOf()` dépend de la longueur de la chaîne principale. Dans le pire des cas, où la sous-chaîne n'est pas trouvée ou est située à la fin de la chaîne, la complexité est linéaire, soit O(n), où n est la longueur de la chaîne principale.

### Cas d'usage



**Rechercher la première occurrence d'une sous-chaîne**
```javascript
const str = "Hello, world!";
const index = str.indexOf("world");
console.log(index); // Sortie : 7
```

Dans cet exemple, nous utilisons `.indexOf()` pour rechercher la première occurrence de la sous-chaîne "world" dans la chaîne str. La méthode renvoie l'index 7, qui est la position où la sous-chaîne commence dans la chaîne principale.

**Rechercher une sous-chaîne à partir d'un index spécifique**
```javascript
const str = "Hello, world!";
const index = str.indexOf("o", 5);
console.log(index); // Sortie : 8
```

Dans cet exemple, nous utilisons `.indexOf()` pour rechercher la première occurrence du caractère "o" dans la chaîne str, à partir de l'index 5. La méthode renvoie l'index 8, qui est la position de la première occurrence du caractère "o" après l'index spécifié.

**Vérifier si une sous-chaîne existe dans la chaîne principale**

```javascript
const str = "Hello, world!";
const substring = "foo";
const index = str.indexOf(substring);
if (index !== -1) {
  console.log("La sous-chaîne existe à l'index", index);
} else {
  console.log("La sous-chaîne n'existe pas dans la chaîne principale.");
}
```
Dans cet exemple, nous utilisons `.indexOf()` pour rechercher la première occurrence de la sous-chaîne "foo" dans la chaîne str. Si la sous-chaîne est trouvée (c'est-à-dire si l'index n'est pas -1), nous affichons un message indiquant l'index où la sous-chaîne commence. Sinon, nous indiquons que la sous-chaîne n'existe pas dans la chaîne principale.

## `.match()`

### Définition
La méthode `.match()` recherche les correspondances d'une expression régulière dans une chaîne de caractères et renvoie un tableau contenant les correspondances trouvées. Si aucune correspondance n'est trouvée, la méthode renvoie null.

### Syntaxe 
`str.match(regexp)` 

- `str` : La chaîne dans laquelle on recherche les correspondances.
- `regexp` : une expression régulière utilisée pour rechercher les correspondances dans la chaîne


### Complexité temporelle
La complexité temporelle de la méthode .match() dépend de la taille de la chaîne de caractères et de la complexité de l'expression régulière. Dans certains cas, la complexité peut être élevée, en particulier avec des expressions régulières complexes. Dans le pire des cas, elle peut avoir une complexité exponentielle. Il est important de noter que la complexité dépend de l'expression régulière elle-même, et non de la méthode .match().

### Cas d'usage

**Obtenir les correspondances d'un motif dans une chaîne **

```javascript
const str = "Hello, world!";
const matches = str.match(/o/g);
console.log(matches); // Sortie : ["o", "o"]
``` 
Dans cet exemple, nous utilisons `.match()` avec l'expression régulière /o/g pour rechercher toutes les occurrences de la lettre "o" dans la chaîne str. La méthode renvoie un tableau contenant les correspondances trouvées, c'est-à-dire ["o", "o"].

**Utiliser une expression régulière avec des groupes de capture **

```javascript
const str = "Hello, world!";
const matches = str.match(/(H\w+)\s*,\s*(\w+)/);
console.log(matches); // Sortie : ["Hello, world!", "Hello", "world"]
```

Dans cet exemple, nous utilisons `.match()` avec l'expression régulière /(H\w+)\s*,\s*(\w+)/ pour rechercher une correspondance qui correspond à un mot commençant par "H" suivi de tous les caractères alphanumériques (\w+), suivi d'une virgule, suivie de zéro ou plusieurs espaces (\s*), suivis d'un autre mot. La méthode renvoie un tableau contenant la correspondance complète ainsi que les groupes de capture, c'est-à-dire ["Hello, world!", "Hello", "world"].

**Utiliser une expression régulière avec le drapeau "i" pour une recherche insensible à la casse**

```javascript
const str = "Hello, world!";
const matches = str.match(/WORLD/i);
console.log(matches); // Sortie : ["world"]
```

Dans cet exemple, nous utilisons `.match()` avec l'expression régulière /WORLD/i et le drapeau "i" pour rechercher une correspondance insensible à la casse du mot "WORLD" dans la chaîne str. La méthode renvoie un tableau contenant la correspondance trouvée, c'est-à-dire ["world"].







## `.repeat()`

### Définition
La méthode `.repeat()` répète une chaîne de caractères un certain nombre de fois et renvoie une nouvelle chaîne contenant les répétitions. Elle crée une nouvelle chaîne en concaténant la chaîne originale autant de fois que spécifié.

### Syntaxe 
`str.repeat(count)` 

- `str` : La chaîne de caractères à répéter
- `count` : Le nombre de fois que vous souhaitez répéter la chaîne. Doit être un nombre entier positif.


### Complexité temporelle
La complexité temporelle de la méthode `.repeat()` est linéaire, soit O(n), où n est le nombre de répétitions spécifié par le paramètre count. Cela signifie que le temps d'exécution de la méthode est proportionnel au nombre de répétitions.

### Cas d'usage

**Répéter une chaîne un nombre fixe de fois**

```javascript
const str = "Hello ";
const repeatedStr = str.repeat(3);
console.log(repeatedStr); // Sortie : "Hello Hello Hello "
```

Dans cet exemple, nous utilisons .repeat() pour répéter la chaîne "Hello " trois fois. La méthode renvoie une nouvelle chaîne contenant la chaîne originale répétée, c'est-à-dire "Hello Hello Hello ".

**Répéter une chaîne un nombre de fois dynamique**
```javascript
const str = "abc";
const count = 4;
const repeatedStr = str.repeat(count);
console.log(repeatedStr); // Sortie : "abcabcabcabc"
```
Dans cet exemple, nous utilisons `.repeat()` pour répéter la chaîne "abc" un nombre dynamique de fois défini par la variable count (dans ce cas, 4). La méthode renvoie une nouvelle chaîne contenant la chaîne originale répétée quatre fois, c'est-à-dire "abcabcabcabc".

**Répéter une chaîne avec un paramètre nul ou négatif**
```javascript
const str = "Hello";
const count = 0;
const repeatedStr = str.repeat(count);
console.log(repeatedStr); // Sortie : ""
```
Dans cet exemple, nous utilisons `.repeat()` avec un paramètre count égal à zéro. Comme zéro signifie qu'il n'y a pas de répétition, la méthode renvoie une chaîne vide (""). Si count était négatif, la méthode renverrait également une chaîne vide.






## `.replace()`

### Définition
La méthode `.replace()` recherche des occurrences d'une sous-chaîne dans une chaîne de caractères et les remplace par une autre sous-chaîne spécifiée. Elle renvoie une nouvelle chaîne résultante avec les remplacements effectués.

### Syntaxe 
`str.replace(chaineARemplacer, nouvelleChaine)` 

- `str` : La chaîne de caractères dans laquelle on effectue les remplacements
- `chaineARemplacer` : La sous-chaîne que vous souhaitez rechercher et remplacer.
- `nouvelleChaine` : La sous-chaîne qui va remplacer les occurrences trouvées.

* Il est également possible d'utiliser une expression régulière comme searchValue pour effectuer des remplacements plus complexes.


### Complexité temporelle
La complexité temporelle de la méthode `.replace()` dépend de la taille de la chaîne de caractères et de la complexité de la recherche et du remplacement effectués. Dans la plupart des cas, la complexité est linéaire, soit O(n), où n est la longueur de la chaîne de caractères. Cependant, lorsqu'une expression régulière est utilisée pour la recherche, la complexité peut varier en fonction de la complexité de l'expression régulière elle-même.

### Cas d'usage

** Remplacer une occurrence spécifique dans une chaîne**

```javascript
const str = "Hello, World!";
const newStr = str.replace("World", "Universe");
console.log(newStr); // Sortie : "Hello, Universe!"
```

Dans cet exemple, nous utilisons `.replace()` pour rechercher la première occurrence de la sous-chaîne "World" dans la chaîne str et la remplacer par la sous-chaîne "Universe". La méthode renvoie une nouvelle chaîne contenant les remplacements, c'est-à-dire "Hello, Universe!".

**Utiliser une expression régulière pour effectuer des remplacements globaux**
```javascript
const str = "Hello, Hello, Hello!";
const newStr = str.replace(/Hello/g, "Hi");
console.log(newStr); // Sortie : "Hi, Hi, Hi!"
```

Dans cet exemple, nous utilisons `.replace()` avec l'expression régulière /Hello/g pour rechercher toutes les occurrences de la sous-chaîne "Hello" dans la chaîne str et les remplacer par la sous-chaîne "Hi". En utilisant le drapeau "g" de l'expression régulière, tous les Hello sont remplacés. La méthode renvoie une nouvelle chaîne avec les remplacements effectués, c'est-à-dire "Hi, Hi, Hi!".

**Utiliser une fonction de remplacement dynamique**
```javascript
const str = "Hello, World!";
const newStr = str.replace("World", (match) => match.toUpperCase());
console.log(newStr); // Sortie : "Hello, WORLD!"
```

Dans cet exemple, nous utilisons `.replace()` pour rechercher la sous-chaîne "World" dans la chaîne str et effectuer un remplacement dynamique à l'aide d'une fonction de rappel. La fonction de rappel reçoit en argument la correspondance trouvée, et nous l'utilisons pour convertir la correspondance en majuscules à l'aide de la méthode toUpperCase(). La méthode renvoie une nouvelle chaîne avec les remplacements effectués, c'est-à-dire "Hello, WORLD!".










## `.search()`

### Définition
La méthode `search()` recherche une correspondance entre une expression régulière et une chaîne de caractères, renvoyant l'index de la première occurrence de la correspondance.

### Syntaxe 
`str.search(expressionReguliere)` 

- `str` : La chaîne de caractères sur laquelle on effectue la recherche
- `chaineARemplacer` : La sous-chaîne que vous souhaitez rechercher et remplacer.
- `expressionReguliere` : Une expression régulière pour spécifier le motif à rechercher.


### Complexité temporelle
La complexité temporelle de la méthode `search()` dépend de la complexité de l'expression régulière fournie. Dans le pire des cas, la complexité peut être linéaire en fonction de la taille de la chaîne et de l'expression régulière.

### Cas d'usage

**Rechercher la position d'un mot dans une chaîne**

```javascript
const str = "Hello, world! Welcome to JavaScript.";
const position = str.search("world");
console.log(position); // Output: 7
Dans cet exemple, search("world") recherche le mot "world" dans la chaîne str et renvoie l'index de la première occurrence trouvée, qui est 7.
```

**Utiliser une expression régulière pour la recherche**

```javascript
const str = "Hello, world! Welcome to JavaScript.";
const position = str.search(/w\w+/i);
console.log(position); // Output: 7
Ici, nous utilisons une expression régulière /w\w+/i pour rechercher le premier mot commençant par "w" (indépendamment de la casse) dans la chaîne str. La méthode search() renvoie l'index de la première occurrence du mot correspondant, qui est 7.
```

**Vérifier la présence d'un motif dans une chaîne**

```javascript
const str = "Hello, world! Welcome to JavaScript.";
const pattern = /javascript/i;
if (str.search(pattern) !== -1) {
  console.log("Le motif 'JavaScript' a été trouvé.");
} else {
  console.log("Le motif 'JavaScript' n'a pas été trouvé.");
}
```

Dans cet exemple, nous utilisons une expression régulière /javascript/i pour rechercher le mot "JavaScript" (indépendamment de la casse) dans la chaîne str. Si la méthode search() renvoie une valeur différente de -1, cela signifie que le motif a été trouvé et nous affichons un message correspondant.


## `.slice()`

### Définition
La méthode `slice()` extrait une partie d'une chaîne de caractères et renvoie une nouvelle chaîne contenant cette portion. Elle prend en compte les index de début et de fin spécifiés, permettant de délimiter la portion à extraire.

### Syntaxe 
`str.slice(début, fin)` 

- `str` : La chaîne sur laquelle on effectue l'extraction.
- `début` : L'index de départ de la portion à extraire. Si début est négatif, il est traité comme str.length + début, où str.length est la longueur de la chaîne.
- `fin` : (Optionnel) L'index de fin de la portion à extraire (non inclus). Si fin est négatif, il est traité comme str.length + fin.

### Complexité temporelle
La complexité temporelle de la méthode `slice()` est linéaire en fonction de la taille de la portion extraite. Dans le pire des cas, si la portion extraite est la chaîne d'origine, la complexité serait linéaire par rapport à la taille de la chaîne.

### Cas d'usage

**Extraire une sous-chaîne d'une chaîne**

```javascript
const str = "Hello, world!";
const subStr = str.slice(7, 12);
console.log(subStr); // Output: "world"
```

Dans cet exemple, slice(7, 12) extrait la portion de la chaîne str comprise entre les index 7 et 11 (12 est exclu). La sous-chaîne extraite est "world".

**Utiliser des indices négatifs pour extraire une portion depuis la fin**

```javascript
const str = "Hello, world!";
const subStr = str.slice(-6, -1);
console.log(subStr); // Output: "world"
```

Ici, slice(-6, -1) extrait la portion de la chaîne str comprise entre les 6 derniers caractères et l'avant-dernier caractère. La sous-chaîne extraite est toujours "world".

**Extraire une portion jusqu'à la fin de la chaîne**

```javascript
const str = "Hello, world!";
const subStr = str.slice(7);
console.log(subStr); // Output: "world!"
```

Dans cet exemple, slice(7) extrait la portion de la chaîne str à partir de l'index 7 jusqu'à la fin de la chaîne. La sous-chaîne extraite est "world!".







## `.split()`

### Définition
La méthode `split()` divise une chaîne de caractères en utilisant un séparateur spécifié et renvoie un tableau de sous-chaînes. Le séparateur peut être un caractère, une sous-chaîne ou une expression régulière. Les portions de la chaîne entre les occurrences du séparateur sont extraites en tant qu'éléments du tableau résultant.

### Syntaxe 
`str.split(séparateur, limite)` 

- `str` : La chaîne à diviser.
- `séparateur` : Le séparateur utilisé pour diviser la chaîne. Il peut être un caractère, une sous-chaîne ou une expression régulière. Si aucun séparateur n'est spécifié, la méthode renverra un tableau contenant la chaîne entière comme seul élément.
- `limite` : (Optionnel) Un entier indiquant le nombre maximum de divisions à effectuer. Si cette limite est atteinte, les éléments restants sont ajoutés tels quels dans le tableau résultant. Si limite est négatif, aucune limite ne sera appliquée.


### Complexité temporelle
La complexité temporelle de la méthode `split()` dépend de la taille de la chaîne d'entrée et du séparateur utilisé. Dans le pire des cas, la complexité peut être linéaire par rapport à la taille de la chaîne.

### Cas d'usage

**Diviser une chaîne en fonction d'un séparateur**

```javascript
const str = "Hello, world!";
const result = str.split(", ");
console.log(result); // Output: ["Hello", "world!"]
```

Dans cet exemple, split(", ") divise la chaîne str en utilisant la virgule suivie d'un espace comme séparateur. Le tableau résultant contient les sous-chaînes "Hello" et "world!".

**Diviser une chaîne en utilisant une expression régulière**

```javascript
const str = "Hello, world!";
const result = str.split(/[o,]/);
console.log(result); // Output: ["Hell", " w", "rld!"]
```

Ici, split(/[o,]/) divise la chaîne str en utilisant une expression régulière qui correspond à la lettre "o" ou à la virgule. Le tableau résultant contient les sous-chaînes "Hell", " w" et "rld!".

**Limiter le nombre de divisions effectuées**

```javascript
const str = "Hello, world, how, are, you";
const result = str.split(", ", 3);
console.log(result); // Output: ["Hello", "world", "how"]
```

Dans cet exemple, split(", ", 3) divise la chaîne str en utilisant la virgule suivie d'un espace comme séparateur et limite le nombre de divisions à 3. Le tableau résultant contient les trois premières sous-chaînes obtenues.


## `.substr()`

### Définition
La méthode `substr()` extrait une sous-chaîne à partir d'une chaîne de caractères en utilisant un index de départ et une longueur spécifiée. Elle renvoie la sous-chaîne extraite sans modifier la chaîne d'origine.

### Syntaxe 
`str.substr(indexDépart, longueur)` 

- `str` : La chaîne à partir de laquelle extraire la sous-chaîne..
- `indexDépart` : L'index de départ à partir duquel extraire la sous-chaîne. Si indexDépart est négatif, il est traité comme (longueur de la chaîne + indexDépart). Par exemple, -1 correspond à l'index du dernier caractère.
- `longueur` : (Optionnel) La longueur de la sous-chaîne à extraire. Si longueur est omis ou dépasse la longueur de la chaîne, la méthode extraira la sous-chaîne jusqu'à la fin de la chaîne.


### Complexité temporelle
La complexité temporelle de la méthode `substr()` est linéaire par rapport à la longueur de la sous-chaîne extraite. Dans le pire des cas, la complexité peut être proportionnelle à la longueur de la chaîne d'origine.

### Cas d'usage

**Extraire une sous-chaîne à partir d'un index de départ**

```javascript
const str = "Hello, world!";
const result = str.substr(7);
console.log(result); // Output: "world!"
```

Dans cet exemple, substr(7) extrait une sous-chaîne de str à partir de l'index 7 (correspondant au caractère "w") jusqu'à la fin de la chaîne. Le résultat est la sous-chaîne "world!".

**Extraire une sous-chaîne avec une longueur spécifiée**

```javascript
const str = "Hello, world!";
const result = str.substr(0, 5);
console.log(result); // Output: "Hello"
```

Ici, substr(0, 5) extrait une sous-chaîne de str à partir de l'index 0 jusqu'à une longueur de 5 caractères. Le résultat est la sous-chaîne "Hello".

** Utiliser un index de départ négatif **

```javascript
const str = "Hello, world!";
const result = str.substr(-6);
console.log(result); // Output: "world!"
```

Dans cet exemple, substr(-6) extrait une sous-chaîne de str à partir de l'index calculé en traitant -6 comme (longueur de la chaîne + indexDépart), ce qui correspond à l'index du caractère "w". Le résultat est la sous-chaîne "world!".



## `.toLowerCase()`

### Définition
La méthode `toLowerCase()` convertit tous les caractères d'une chaîne de caractères en minuscules. Elle ne modifie pas la chaîne d'origine mais renvoie une nouvelle chaîne avec les caractères en minuscules.

### Syntaxe 
`str.toLowerCase()` 

- `str` :  La chaîne de caractères à convertir en minuscules.


### Complexité temporelle
La complexité temporelle de la méthode `toLowerCase()` dépend de la longueur de la chaîne d'origine. En général, elle est linéaire, ce qui signifie que la complexité est proportionnelle à la longueur de la chaîne.


### Cas d'usage


**Convertir une chaîne en minuscules**

```javascript
const str = "Hello, World!";
const result = str.toLowerCase();
console.log(result); // Output: "hello, world!"
```

Dans cet exemple, toLowerCase() convertit tous les caractères de la chaîne str en minuscules, produisant la nouvelle chaîne "hello, world!".

**Comparaison de chaînes insensible à la casse**

```javascript
const str1 = "Hello";
const str2 = "hello";
const areEqual = str1.toLowerCase() === str2.toLowerCase();
console.log(areEqual); // Output: true
```

Ici, toLowerCase() est utilisé pour convertir les deux chaînes (str1 et str2) en minuscules avant de les comparer. Cela permet de comparer les chaînes de manière insensible à la casse, et dans cet exemple, les deux chaînes sont considérées comme égales.

**Validation d'une entrée utilisateur**

```javascript
const userInput = "Mercredi";
const lowerCaseInput = userInput.toLowerCase();

if (lowerCaseInput === "mercredi") {
  console.log("L'utilisateur a entré Mercredi.");
} else {
  console.log("L'utilisateur n'a pas entré Mercredi.");
}
```

Dans ce cas, toLowerCase() est utilisé pour convertir l'entrée utilisateur en minuscules, permettant de faire une comparaison insensible à la casse. Si l'utilisateur entre "mErCreDi" ou "Mercredi", la condition sera vraie et le message approprié sera affiché.


## `.toUpperCase()`

### Définition
La méthode `toUpperCase()` convertit tous les caractères d'une chaîne de caractères en majuscules. Elle ne modifie pas la chaîne d'origine mais renvoie une nouvelle chaîne avec les caractères en majuscules.

### Syntaxe 
`str.toUpperCase()` 

- `str` :  La chaîne de caractères à convertir en majuscules.

### Complexité temporelle
La complexité temporelle de la méthode toUpperCase() dépend de la longueur de la chaîne d'origine. En général, elle est linéaire, ce qui signifie que la complexité est proportionnelle à la longueur de la chaîne.

### Cas d'usage

**Convertir une chaîne en majuscules**

```javascript
const str = "Hello, World!";
const result = str.toUpperCase();
console.log(result); // Output: "HELLO, WORLD!"
Dans cet exemple, toUpperCase() convertit tous les caractères de la chaîne str en majuscules, produisant la nouvelle chaîne "HELLO, WORLD!".
```

**Comparaison de chaînes insensible à la casse**

```javascript
const str1 = "HELLO";
const str2 = "hello";
const areEqual = str1.toUpperCase() === str2.toUpperCase();
console.log(areEqual); // Output: true
```

Ici, toUpperCase() est utilisé pour convertir les deux chaînes (str1 et str2) en majuscules avant de les comparer. Cela permet de comparer les chaînes de manière insensible à la casse, et dans cet exemple, les deux chaînes sont considérées comme égales.

**Validation d'une entrée utilisateur**

```javascript
const userInput = "motdepasse";
const upperCaseInput = userInput.toUpperCase();

if (upperCaseInput === "MOTDEPASSE") {
  console.log("L'utilisateur a entré motdepasse en majuscules.");
} else {
  console.log("L'utilisateur n'a pas entré motdepasse en majuscules.");
}
```


Dans ce cas, toUpperCase() est utilisé pour convertir l'entrée utilisateur en majuscules, permettant de faire une comparaison insensible à la casse. Si l'utilisateur entre "MotDePasse" ou "MOTDEPASSE", la condition sera vraie et le message approprié sera affiché.


## `.trim()`

### Définition
La méthode `trim()` supprime les espaces en début et en fin d'une chaîne de caractères. Les espaces à l'intérieur de la chaîne ne sont pas affectés. La méthode trim() est souvent utilisée pour nettoyer les entrées utilisateur en éliminant les espaces inutiles.

### Syntaxe 
`str.trim()` 

- `str` : La chaîne de caractères à nettoyer en supprimant les espaces en début et en fin.

### Complexité temporelle
La complexité temporelle de la méthode `trim()` dépend de la longueur de la chaîne d'origine. En général, elle est linéaire, ce qui signifie que la complexité est proportionnelle à la longueur de la chaîne.

### Cas d'usage

**Supprimer les espaces en début et en fin d'une chaîne**

```javascript
const str = "   Hello, World!   ";
const result = str.trim();
console.log(result); // Output: "Hello, World!"
```

Dans cet exemple, trim() supprime les espaces en début et en fin de la chaîne str, produisant la nouvelle chaîne "Hello, World!".


**Comparaison de chaînes insensible aux espaces**

```javascript
const str1 = " Hello ";
const str2 = "Hello";
const areEqual = str1.trim() === str2.trim();
console.log(areEqual); // Output: true
```

Ici, trim() est utilisé pour supprimer les espaces en début et en fin des deux chaînes (str1 et str2) avant de les comparer. Cela permet de comparer les chaînes de manière insensible aux espaces, et dans cet exemple, les deux chaînes sont considérées comme égales.

**Nettoyage d'une entrée utilisateur**

```javascript
const userInput = "   Salut   ";
const cleanedInput = userInput.trim();

console.log(cleanedInput); // Output: "Salut"
```

Dans ce cas, trim() est utilisé pour supprimer les espaces en début et en fin de l'entrée utilisateur, nettoyant ainsi la chaîne. Cela permet de s'assurer que la chaîne ne contient pas d'espaces inutiles.

Et voilà, nous avons terminé la liste des méthodes utiles pour manipuler les chaînes de caractère en Javascript. Si vous avez apprécié cet article, n'hésitez pas à laisser un commentaire pour me le faire savoir.