Opérations sur les chaînes en Shell

Introduction

Dans cet atelier, vous allez découvrir les opérations fondamentales sur les chaînes de caractères en script shell. La manipulation de chaînes est une compétence indispensable pour extraire et transformer des données textuelles dans divers scénarios d'automatisation. Vous explorerez des concepts tels que la mesure de la longueur d'une chaîne, la localisation de caractères, l'extraction de segments et le remplacement de motifs. Ces outils sont les piliers d'un traitement de texte efficace sous Linux.

Guide de référence rapide

Voici un aperçu des opérations que nous allons aborder :

Opération	Syntaxe	Description	Exemple
Longueur de chaîne	`${#string}`	Calcule le nombre de caractères	`${#"hello"}` renvoie `5`
Position d'un caractère	`$(expr index "$string" "$char")`	Trouve la position (index commence à 1)	`$(expr index "abcdef" "c")` renvoie `3`
Extraire une sous-chaîne	`${string:start:length}`	Extrait une portion (index commence à 0)	`${"hello":1:3}` renvoie `ell`
Remplacer la 1ère occurrence	`${string/pattern/replacement}`	Remplace la première occurrence trouvée	`${"hello"/l/L}` renvoie `heLlo`
Remplacer toutes les occurrences	`${string//pattern/replacement}`	Remplace toutes les occurrences trouvée	`${"hello"//l/L}` renvoie `heLLo`
Remplacer au début	`${string/#pattern/replacement}`	Remplace uniquement si au début	`${"hello"/#he/HE}` renvoie `HEllo`
Remplacer à la fin	`${string/%pattern/replacement}`	Remplace uniquement si à la fin	`${"hello"/%lo/LO}` renvoie `helLO`

Création du fichier de script

Commençons par créer le fichier dans lequel nous allons écrire nos commandes de manipulation de chaînes.

Ouvrez votre terminal dans l'interface WebIDE. C'est ici que vous saisirez les commandes pour interagir avec le système Linux.
Déplacez-vous dans le répertoire du projet :
```
cd ~/project
```
Cette commande change votre dossier courant vers ~/project. Le symbole ~ représente votre répertoire personnel (home).
Créez un nouveau fichier nommé string_operations.sh :
```
touch string_operations.sh
```
La commande touch crée un fichier vide. S'il existe déjà, elle met simplement à jour sa date de modification.
Ouvrez ce fichier dans l'éditeur de la WebIDE en cliquant sur son nom dans l'explorateur de fichiers à gauche.
Ajoutez la ligne "shebang" suivante tout en haut du fichier pour spécifier l'interpréteur à utiliser :
```
#!/bin/bash
```
Cette ligne indique au système que ce script doit être exécuté avec le shell Bash. C'est une convention indispensable pour tout script shell.

Longueur d'une chaîne

Apprenons maintenant à mesurer la taille d'une chaîne de caractères.

Ajoutez le code suivant à votre fichier string_operations.sh :
```
echo "Step 2: String Length"

STRING="Hello, World!"
LENGTH=${#STRING}

echo "The string is: $STRING"
echo "Its length is: $LENGTH"
```
Analysons ce bloc :
- Nous utilisons echo pour afficher un titre de section.
```
echo "Step 2: String Length"
```
- Nous définissons une variable STRING contenant "Hello, World!".
```
STRING="Hello, World!"
```
  En Bash, il n'y a pas de mot-clé spécifique pour déclarer une variable. On écrit le nom, le signe égal, puis la valeur (sans espaces autour du =).
- Nous calculons la longueur avec la syntaxe ${#variable} et stockons le résultat dans LENGTH.
```
LENGTH=${#STRING}
```
  Cette syntaxe est une extension de paramètre du shell qui renvoie le nombre de caractères.
- Enfin, nous affichons la chaîne et sa longueur.
```
echo "The string is: $STRING"
echo "Its length is: $LENGTH"
```
  Le symbole $ devant un nom de variable indique au shell qu'il doit le remplacer par sa valeur.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Rendez le script exécutable :
```
chmod +x string_operations.sh
```
- chmod signifie "change mode" (modifier les permissions).
- +x ajoute le droit d'exécution.
- Sans cela, le système refuserait de lancer le fichier comme un programme.
Exécutez le script :
```
./string_operations.sh
```
Le préfixe ./ indique au shell de chercher le script dans le répertoire courant.

Vous devriez obtenir :

Step 2: String Length
The string is: Hello, World!
Its length is: 13

Trouver la position d'un caractère

Nous allons maintenant localiser la position d'un caractère spécifique.

Ajoutez ce code à la suite dans votre fichier string_operations.sh :
```
echo -e "\nStep 3: Finding Character Position"

STRING="abcdefghijklmnopqrstuvwxyz"
CHAR="j"

POSITION=$(expr index "$STRING" "$CHAR")

echo "The string is: $STRING"
echo "We're looking for the character: $CHAR"
echo "It is at position: $POSITION"
```
Détails du code :
- L'option -e de echo permet d'interpréter les séquences d'échappement comme \n (saut de ligne), ce qui aère l'affichage.
- Nous utilisons la commande expr index :
```
POSITION=$(expr index "$STRING" "$CHAR")
```
  - expr est un utilitaire pour évaluer des expressions.
  - L'opération index cherche la position d'un caractère.
  - La syntaxe $() capture le résultat de la commande pour le mettre dans la variable POSITION.
  - Attention : Cette commande commence à compter à partir de 1.
Enregistrez et lancez le script :
```
./string_operations.sh
```

Résultat attendu :

Step 3: Finding Character Position
The string is: abcdefghijklmnopqrstuvwxyz
We're looking for the character: j
It is at position: 10

Notez bien que l'indexation commence à 1 ici, contrairement à beaucoup de langages de programmation qui commencent à 0.

Extraction de sous-chaînes

Apprenons à extraire une partie précise d'une phrase.

Ajoutez ce code à votre fichier :
```
echo -e "\nStep 4: Substring Extraction"

STRING="The quick brown fox jumps over the lazy dog"
START=10
LENGTH=5

SUBSTRING=${STRING:$START:$LENGTH}

echo "The original string is: $STRING"
echo "Extracting 5 characters starting from position 10:"
echo "The substring is: $SUBSTRING"
```
Analyse :
- Nous définissons START=10 (position de départ) et LENGTH=5 (nombre de caractères à prendre).
- La syntaxe d'extraction est ${variable:position:longueur}.
```
SUBSTRING=${STRING:$START:$LENGTH}
```
- Important : Contrairement à expr index, cette méthode utilise une indexation commençant à 0. Le premier caractère est donc à la position 0.
Enregistrez et exécutez :
```
./string_operations.sh
```

Résultat :

Step 4: Substring Extraction
The original string is: The quick brown fox jumps over the lazy dog
Extracting 5 characters starting from position 10:
The substring is: brown

Dans la phrase, la position 10 (en partant de 0) correspond au 'b' de "brown". Les 5 caractères suivants forment bien le mot "brown".

C'est un point de vigilance majeur en Shell :

expr index (Étape 3) commence à 1.
L'extraction ${STRING:pos:len} (Étape 4) commence à 0.

Remplacement de chaînes

Enfin, voyons comment modifier dynamiquement le contenu d'une chaîne.

Ajoutez ce code final à votre fichier :

echo -e "\nStep 5: String Replacement"

STRING="The quick brown fox jumps over the lazy dog"
echo "Original string: $STRING"

## Remplacer la première occurrence de 'o' par 'O'
NEW_STRING=${STRING/o/O}
echo "Replacing first 'o' with 'O': $NEW_STRING"

## Remplacer toutes les occurrences de 'o' par 'O'
NEW_STRING=${STRING//o/O}
echo "Replacing all 'o' with 'O': $NEW_STRING"

## Remplacer au début de la chaîne
NEW_STRING=${STRING/#The quick/The slow}
echo "Replacing 'The quick' with 'The slow' at the beginning: $NEW_STRING"

## Remplacer à la fin de la chaîne
NEW_STRING=${STRING/%dog/cat}
echo "Replacing 'dog' with 'cat' at the end: $NEW_STRING"

Détails des opérations de remplacement :

Première occurrence : ${variable/motif/remplacement}. Seul le premier 'o' trouvé (dans "brown") est modifié.
Toutes les occurrences : ${variable//motif/remplacement}. Notez le double slash //. Tous les 'o' de la phrase deviennent des 'O'.
Début de chaîne : ${variable/#motif/remplacement}. Le symbole # force la correspondance au tout début.
Fin de chaîne : ${variable/%motif/remplacement}. Le symbole % force la correspondance à la toute fin.

Enregistrez et exécutez une dernière fois :
```
./string_operations.sh
```

Résultat :

Step 5: String Replacement
Original string: The quick brown fox jumps over the lazy dog
Replacing first 'o' with 'O': The quick brOwn fox jumps over the lazy dog
Replacing all 'o' with 'O': The quick brOwn fOx jumps Over the lazy dOg
Replacing 'The quick' with 'The slow' at the beginning: The slow brown fox jumps over the lazy dog
Replacing 'dog' with 'cat' at the end: The quick brown fox jumps over the lazy cat

Ces outils sont extrêmement puissants pour nettoyer des données, formater des logs ou manipuler des chemins de fichiers dans vos scripts.

Résumé

Dans cet atelier, vous avez appris et pratiqué les opérations essentielles sur les chaînes de caractères en Bash :

Création et exécution d'un script shell.
Calcul de la longueur d'une chaîne avec ${#string}.
Recherche de la position d'un caractère avec $(expr index "$string" "$char").
Extraction de segments avec ${string:start:length}.
Utilisation des différentes variantes de remplacement :
- ${string/pattern/replacement} : Première occurrence.
- ${string//pattern/replacement} : Toutes les occurrences.
- ${string/#pattern/replacement} : Uniquement au début.
- ${string/%pattern/replacement} : Uniquement à la fin.

Ces compétences constituent la base du traitement de texte en shell. En continuant votre apprentissage, vous verrez que ces manipulations sont indispensables pour analyser des données et automatiser des tâches complexes. N'hésitez pas à expérimenter avec vos propres phrases pour bien mémoriser ces syntaxes !

Opérations de base sur les chaînes de caractères