Guide de base pour la création de scripts sous SHEL et Python

Introduction au script Shell

Un script shell est un fichier texte, qui contient une suite de commandes shell qui sont exécuté par un interpréteur. Ces scripts permettent d'invoquer directement des commandes systèmes.
Les commandes shell retournent toujours :

• Code de bon fonctionnement : 0/Aucune erreur; 1/ou autre une erreur;

Shell est un langage de commande et d'échange avec le système.
Quelques shell :

• Bash pour Bourne Again Shell
• csh, tcsh
• ksh

Script de base

                                        #!/bin/bash
echo "nous somme le " $(date)
exit 0

                                        

                                        # -*- coding: utf-8 -*-
#!/usr/bin/env python3
# Importe le module datetime pour obtenir la date actuelle
from datetime import datetime
    
# Affiche un message avec la date actuelle
print("Nous sommes le", datetime.now().strftime("%d/%m/%Y"))
    
# Quitte le script avec succès
exit(0)

                                        

Les variables en shell

Les variables en Shell, ne sont ni déclaré ni typé. On référence une variable avec le symbole $.
Les variables d'environnements sont mise à disposition pour nos scripts :

• $USER : L'utilisateur actuellement connecté.
• $PWD : Le répertoire courant.
• $HOME : Le répertoire home de l'utilisateur connecté.

Exemple de script shell qui utilise les variales d'environnements

                                        #!/bin/bash
var_bjr1="bonjour les amis"
var_bjr2=bonjour
formatted_date=$(date +"%Y%m%d%H%M%S")

echo $var_bjr1
echo $var_bjr2
echo $formatted_date

echo L\'utilisateur connecté est : $USER
echo Répertoire d\'exécution est : $PWD
echo Répertoire de l\'utilisateur est : $HOME
exit 0

                                        

                                        # -*- coding: utf-8 -*-
#!/usr/bin/env python3
import os
    
# Déclarations de variables
var_bjr1 = "bonjour les amis"
    
# Affiche les variables et d'autres informations
print(var_bjr1)
print("L'utilisateur connecté est :", os.environ['USER'])
print("Répertoire d'exécution est :", os.getcwd())
print("Répertoire de l'utilisateur est :", os.path.expanduser('~'))

                                        

                                        #!/bin/bash
echo "Ce script se nomme : " $0
echo "Le premier argument passé est :" $1
./script_1.sh
echo "La dernière commande a donné :" $? # 0 si aucune erreur
exit 0

                                        

Concaténation

                            #!/bin/bash
nom="ILLOURMANE"
prenom="Mahmoud"
nom_prenom="${nom}-${prenom}"
echo $nom_prenom

exit 0

                            

Les conditionnelles

Les conditionnelles en shell scripting permettent d'exécuter des commandes ou des blocs de commandes basées sur des conditions spécifiques. Voici quelques exemples pour illustrer comment utiliser les conditionnelles en shell.

                                        #!/bin/bash
nombre1=5
nombre2=10
if [ $nombre1 -lt $nombre2 ]; then
    echo "$nombre1 est inférieur à $nombre2."
else
    echo "$nombre1 n'est pas inférieur à $nombre2."
fi

                                        

                                        #!/bin/bash

age=20
ville="Paris"

if [ $age -ge 18 ] -a [ "$ville" = "Paris" ]; then
    echo "Je suis majeur et je vis à Paris."
elif [ $age -lt 18 ] -o [ "$ville" != "Paris" ]; then
    echo "Je suis mineur ou je ne vis pas à Paris."
else
    echo "Autre situation."
fi

                                        

                                        mahmoud@Mahmoud:script_bash$ ./script_5.sh
    390

                                        

                                        #!/bin/bash
choix="a"

case $choix in
    a) echo "Option A sélectionnée.";;
    b) echo "Option B sélectionnée.";;
    *) echo "Option inconnue.";;
esac

                                        

Les Boucles

                                        #!/bin/bash

for ville in "Paris" "Lyon" "Marseille"; do
    echo "Je visite $ville."
done

                                        

                                        #!/bin/bash

for i in 1 2 3 4 5; do
    echo "Nombre: $i"
done

                                        

                                        #!/bin/bash

compteur=0
while [ ! -e fichier.txt ]; do
    echo "En attente de la création de fichier.txt..."
    sleep 1
    compteur=$((compteur+1))
    if [ $compteur -eq 10 ]; then
        echo "Temps d'attente dépassé."
        break
    fi
done

                                        

                                        #!/bin/bash

compteur=0
until [ -e fichier.txt ]; do
    echo "Tentative $compteur: fichier.txt non trouvé."
    sleep 1
    compteur=$((compteur+1))
    touch fichier_script_untile.txt # Pour cet exemple, je crée le fichier après quelques tentatives.
    if [ $compteur -eq 5 ]; then
        echo "Fichier créé pour terminer la boucle."
        break
    fi
done

                                        

Opérations sur les variables

Opérations mathématiques

                                        #!/bin/bash
var1=0
echo $var1
let var1++
echo $var1

                                        

                                        mahmoud@Mahmoud:script_bash$ ./script_4.sh
    0
    1

                                        

                                        #!/bin/bash
var2=45
var3=$(($var2+345))
echo $var3

                                        

                                        mahmoud@Mahmoud:script_bash$ ./script_5.sh
    390

                                        

                                        #!/bin/bash
var4=45
var5=$[$var2+347]
echo $var5

                                        

                                        mahmoud@Mahmoud:script_bash$ ./script_5.sh
    347

                                        

Opérations sur les tableaux

On Shell, les tableaux sont assez flexibles ils peuvent être considéré comme des listes, des tableaux..
On peut ajouter des élements à la volé.

                                        #!/bin/bash
tab=("Mahmoud" "ILLOURMANE")
exit 0

                                        

                                        #!/bin/bash
tab1[0] = "Mahmoud"
tab1[1] = "ILLOURMANE"
exit 0

                                        

                                        #!/bin/bash

# Déclare un tableau associatif
declare -A tab_vms

# Remplir le tableau associatif
tab_vms["VM1"]="05d4ddb6-090a-8992-a71f-6ea54ee89fef"
tab_vms["VM2"]="55042bd4-9ee0-d1a2-d9ea-55c2eef69683"

# Parcours du tableau associatif
for vm_name in "${!tab_vms[@]}"; do
    # Obtenir l'UUID de la VM en fonction du nom
    vm_uuid=${tab_vms[$vm_name]}

    echo "Traitement de la VM : $vm_name avec l'UUID : $vm_uuid"
done

exit 0

                                        

                                        #!/bin/bash
echo ${tab[0]}

# Affichage de tout le tableau
echo ${tab[@]}
exit 0

                                        

                                        #!/bin/bash
tab=("Mahmoud" "ILLOURMANE" 25)
echo ${#tab[*]}

# Stockage de la taille dans une variable
len=${#tab[*]}
echo $len
exit 0

                                        

                                        #!/bin/bash

# Définition du tableau
tab=("Mahmoud" "ILLOURMANE")
    
for element in "${tab[@]}"; do
    echo "Traitement de l'élément : $element"
done
exit 0

                                        

Tests

Les tests en shell, souvent réalisés avec la commande test ou les crochets [ ], sont utilisés pour évaluer des expressions conditionnelles dans les scripts Shell. Voici un résumé des points clés :

• Test de Conditions : Les tests permettent de vérifier différentes conditions telles que l'existence d'un fichier, la comparaison de chaînes de caractères ou de nombres, etc.
• Commande test : La commande test est utilisée pour effectuer des tests conditionnels. Elle prend en entrée une expression conditionnelle et renvoie 0 (vrai) si la condition est vraie et 1 (faux) sinon.
• Crochets [ ] : Les crochets [ ] sont une alternative à la commande test. Ils fonctionnent de la même manière mais nécessitent un espace avant et après les crochets. Ils sont souvent utilisés pour améliorer la lisibilité du code.

Opérateurs de Comparaison :

Les tests permettent d'utiliser différents opérateurs de comparaison tels que :

• -eq : égal =
• -ne : différent !=
• -lt : inférieur <
• -gt : supérieur >
• -le : inférieur ou égal <=
• -ge : supérieur ou égal >=

Tests sur les fichiers

• -e : Le fichier existe
• -f : C'est un fichier
• -d : C'est un répertoire
• -r | -w | -x : Propriété du fichier
• -s : Non vide
• f1 -nt f2 : Plus récent que
• f1 -ot f2 : Plus vieux que

Exemples

                                        #!/bin/bash

# Affiche l'usage du script si aucun argument n'est fourni
if [ $# -eq 0 ]; then
    echo "Usage: $0 "
    exit 1
fi
    
# Définit le nom du fichier à partir du premier argument
file="$1"
    
# Tente d'obtenir le chemin absolu du répertoire contenant le script
# et vérifie si l'opération réussit
script_dir=$(dirname "$(readlink -f "$0")") || { echo "Erreur lors de la résolution du chemin du script"; exit 1; }
    
# Construit le chemin complet vers le fichier ciblé
file_path="${script_dir}/${file}"
    
# Vérifie l'existence du fichier et affiche un message approprié
if [ -e "$file_path" ]; then
    echo "Le fichier ${file} existe dans le même répertoire que le script."
else
    echo "Le fichier ${file} n'existe pas dans le même répertoire que le script."
fi

                                        

                                        mahmoud@Mahmoud:script_bash$ ./script_6_file_exist.sh
    Usage: ./script_6_file_exist.sh <nom_du_fichier> 
mahmoud@Mahmoud:script_bash$ ./script_6_file_exist.sh script_1.sh
    Le fichier script_1.sh existe dans le même répertoire que le script.
mahmoud@Mahmoud:script_bash$ ./script_6_file_exist.sh script_5.sh
    Le fichier script_5.sh n'existe pas dans le même répertoire que le script.

                                        

                                        #!/bin/bash

# Vérifie si au moins un argument est fourni
if [ $# -eq 0 ]; then
    echo "Je dois utiliser ce script comme suit: $0 <nom_du_fichier>"
    exit 1
fi
    
# Assigne le nom du fichier fourni à une variable
fichier="$1"
    
# Vérifie si le fichier existe et est un fichier
if [ -f "$fichier" ]; then
    echo "Le fichier '$fichier' existe et c'est un fichier."
else
    if [ -e "$fichier" ]; then
        echo "Le fichier '$fichier' existe mais ce n'est pas un fichier."
    else
        echo "Le fichier '$fichier' n'existe pas."
    fi
fi                    

                                        

                                        mahmoud@Mahmoud:script_bash$ ./script_7_est_un\ _fic.sh script_
    Le fichier 'script_' n'existe pas.
mahmoud@Mahmoud:script_bash$ ./script_7_est_un\ _fic.sh script_1.sh
    Le fichier 'script_1.sh' existe et c'est un fichier régulier.
mahmoud@Mahmoud:script_bash$ mkdir test/
mahmoud@Mahmoud:script_bash$ ./script_7_est_un\ _fic.sh test/
    Le fichier 'test/' existe mais ce n'est pas un fichier régulier.
mahmoud@Mahmoud:script_bash$

                                        

                                        #!/bin/bash

# Vérifie si un argument est fourni
if [ $# -eq 0 ]; then
    echo "Je dois utiliser ce script comme suit: $0 <nom_du_répertoire>"
    exit 1
fi

# Assigne le nom du répertoire fourni à une variable
repertoire="$1"
    
# Vérifie si le chemin existe et est un répertoire
if [ -d "$repertoire" ]; then
    echo "Le répertoire '$repertoire' existe."
else
    echo "Le répertoire '$repertoire' n'existe pas ou ce n'est pas un répertoire."
fi                  

                                        

                                        mahmoud@Mahmoud:script_bash$ ./script_8_est_un_repertoire.sh
    Je dois utiliser ce script comme suit: ./script_8_est_un_repertoire.sh <nom_du_répertoire>
mahmoud@Mahmoud:script_bash$ ./script_8_est_un_repertoire.sh test
    Le répertoire 'test' existe.
mahmoud@Mahmoud:script_bash$ ./script_8_est_un_repertoire.sh testd
    Le répertoire 'testd' n'existe pas ou ce n'est pas un répertoire.

                                        

                                        #!/bin/bash

# Vérifie si un argument est fourni
if [ $# -eq 0 ]; then
    echo "Je dois utiliser ce script comme suit: $0 <nom_du_fichier>"
    exit 1
fi
    
# Assigne le nom du fichier fourni à une variable
fichier="$1"
    
# Vérifie si le fichier est lisible
if [ -r "$fichier" ]; then
    echo "Je peux lire le fichier '$fichier'."
else
    echo "Je ne peux pas lire le fichier '$fichier'."
fi
    
# Vérifie si le fichier est modifiable
if [ -w "$fichier" ]; then
    echo "Je peux modifier le fichier '$fichier'."
else
    echo "Je ne peux pas modifier le fichier '$fichier'."
fi

# Vérifie si le fichier est exécutable
if [ -x "$fichier" ]; then
    echo "Je peux exécuter le fichier '$fichier'."
else
    echo "Je ne peux pas exécuter le fichier '$fichier'."
fi                                         

                                        

                                        mahmoud@Mahmoud:script_bash$ ls -l script_1.sh
    -rwxrwxrwx 1 mahmoud mahmoud 48 Feb 13 10:11 script_1.sh
mahmoud@Mahmoud:script_bash$ ./script_9_perm_fic.sh script_1.sh
    Je peux lire le fichier 'script_1.sh'.
    Je peux modifier le fichier 'script_1.sh'.
    Je peux exécuter le fichier 'script_1.sh'.

                                        

                                        #!/bin/bash

# Vérifie si un argument est fourni
if [ $# -eq 0 ]; then
    echo "Je dois utiliser ce script comme suit: $0 <nom_du_fichier>"
    exit 1
fi
    
# Assigne le nom du fichier fourni à une variable
fichier="$1"
    
# Vérifie si le fichier existe et a une taille supérieure à zéro
if [ -s "$fichier" ]; then
    echo "Le fichier '$fichier' existe et n'est pas vide."
else
    # Vérifie si le fichier existe, même s'il est vide
    if [ -e "$fichier" ]; then
        echo "Le fichier '$fichier' existe mais est vide."
    else
        echo "Le fichier '$fichier' n'existe pas."
    fi
fi                                                

                                        

                                        mahmoud@Mahmoud:script_bash$ touch test2.txt
mahmoud@Mahmoud:script_bash$ ./script_10_fic_non_vide.sh test2.txt
    Le fichier 'test2.txt' existe mais est vide.
mahmoud@Mahmoud:script_bash$ ./script_10_fic_non_vide.sh script_1.sh
    Le fichier 'script_1.sh' existe et n'est pas vide.

                                        

                                        #!/bin/bash

# Vérifie si deux arguments sont fournis
if [ $# -ne 2 ]; then
    echo "Je dois utiliser ce script comme suit: $0 <fichier1> <fichier2>"
    exit 1
fi
    
# Assigne les noms des fichiers fournis à des variables
fichier1="$1"
fichier2="$2"
    
# Vérifie si fichier1 est plus récent que fichier2
if [ "$fichier1" -nt "$fichier2" ]; then
    echo "Le fichier '$fichier1' est plus récent que le fichier '$fichier2'."
elif [ "$fichier2" -nt "$fichier1" ]; then
    echo "Le fichier '$fichier2' est plus récent que le fichier '$fichier1'."
else
    echo "Les fichiers '$fichier1' et '$fichier2' ont la même date de modification ou l'un d'eux n'existe pas."
fi                                                           

                                        

                                        mahmoud@Mahmoud:script_bash$ ./script_11_nt.sh script_1.sh script_2.sh
    Le fichier 'script_2.sh' est plus récent que le fichier 'script_1.sh'.

                                        

                                        #!/bin/bash

# Vérifie si deux arguments sont fournis
if [ $# -ne 2 ]; then
    echo "Je dois utiliser ce script comme suit: $0 <fichier1> <fichier2>"
    exit 1
fi
    
# Assigne les noms de fichiers fournis aux variables
fichier1="$1"
fichier2="$2"
    
# Vérifie si fichier1 est plus ancien que fichier2
if [ "$fichier1" -ot "$fichier2" ]; then
    echo "Le fichier '$fichier1' est plus ancien que '$fichier2'."
elif [ "$fichier2" -ot "$fichier1" ]; then
    echo "Le fichier '$fichier2' est plus ancien que '$fichier1'."
else
    echo "Les fichiers '$fichier1' et '$fichier2' ont la même date de modification ou l'un d'eux n'existe pas."
fi                                                          

                                        

                                        mahmoud@Mahmoud:script_bash$ ./script_12_ot.sh script_1.sh script_2.sh
    Le fichier 'script_1.sh' est plus ancien que 'script_2.sh'.

                                        

Expressions Logiques

• exp1 -a exp2 : ET
• exp1 -o exp2 : OU
• !exp : Négation

Exemples

                                        #!/bin/bash

# Vérifie si les deux chaînes sont non vides
if [ -n "$1" -a -n "$2" ]; then
    echo "Les deux chaînes sont non vides."
else
    echo "Au moins une des deux chaînes est vide."
fi

                                        

                                        #!/bin/bash

# Vérifie si au moins une des deux chaînes est non vide
if [ -n "$1" -o -n "$2" ]; then
    echo "Au moins une des deux chaînes est non vide."
else
    echo "Les deux chaînes sont vides."
fi 

                                        

                                        #!/bin/bash

# Vérifie si la chaîne est vide en utilisant la négation
if [ ! -n "$1" ]; then
    echo "La chaîne est vide."
else
    echo "La chaîne n'est pas vide."
fi                    

                                        

Tests sur les chaînes de caractères

• -z Chaîne vide
• -n Chaîne non vide
• != Différentes
• = Identiques

Exemples

                                        #!/bin/bash

# Vérifie si la chaîne de caractères est vide
if [ -z "$1" ]; then
    echo "La chaîne est vide."
else
    echo "La chaîne n'est pas vide."
fi

                                        

                                        #!/bin/bash

# Vérifie si la chaîne de caractères est non vide
if [ -n "$1" ]; then
    echo "La chaîne n'est pas vide."
else
    echo "La chaîne est vide."
fi    

                                        

                                        #!/bin/bash

# Vérifie si les chaînes de caractères sont différentes
if [ "$1" != "$2" ]; then
    echo "Les chaînes sont différentes."
else
    echo "Les chaînes sont identiques."
fi                    

                                        

                                        #!/bin/bash

# Vérifie si les chaînes de caractères sont identiques
if [ "$1" = "$2" ]; then
    echo "Les chaînes sont identiques."
else
    echo "Les chaînes sont différentes."
fi

                                        

La Gestion des Flux

Redirection d'entrée standard depuis un fichier

Lire le contenu d'un fichier et l'utiliser comme entrée pour une commande.
Dans cet exemple, je redirige le contenu du fichier noms.txt vers la commande sort, qui va trier les lignes du fichier.

                            #!/bin/bash
file="$1"
sort < "$file"

                            

Redirection du flux standard

Écrire la sortie d'une commande dans un fichier.

                            #!/bin/bash
echo "Bonjour le monde" > sortie.txt

                            

Redirection du flux d'erreur

Dans cet exemple, je cherche le mot "recherche" dans un fichier qui n'existe pas, et je redirige les erreurs générées dans le fichier erreurs.txt.

                            #!/bin/bash
grep "recherche" fichier_inexistant.txt 2> erreurs.txt

                            

Redirection de la sortie d'erreur vers la sortie standard

Rediriger à la fois la sortie standard et la sortie d'erreur vers le même fichier.

                            #!/bin/bash
commande 2>&1 > sortie_et_erreurs.txt

                            

Redirection dans un fichier (écriture et création du fichier)

Créer un fichier ou écraser le contenu s'il existe déjà, avec la sortie d'une commande.

                            #!/bin/bash
echo "Je crée ou j'écrase un fichier" > nouveau_fichier.txt

                            

Ajout à un fichier

Ajouter la sortie d'une commande à la fin d'un fichier existant.

                            #!/bin/bash
echo "J'ajoute cette ligne à la fin du fichier" >> fichier_existant.txt

                            

Ecriture dans un fichier

Dans cet exemple, je commence par récupérer la date et l'heure actuelles avec la commande date que je stocke dans la variable date_now. Ensuite, je crée un fichier date_info.txt où je vais écrire la date et l'heure. Avec l'opérateur > je crée le fichier ou j'écrase son contenu s'il existe déjà. Avec l'opérateur >>, je vais ajouter la liste des fichiers et dossiers du répertoire courant à la suite dans le fichier sans écraser le contenu précédent.

                            #!/bin/bash

# Je stocke la commande `date` dans la variable date_now
date_now=$(date)
    
# Je crée un fichier nommé 'date_info.txt'
# Je vais écrire la date et l'heure actuelles dedans
echo "La date et l'heure actuelles sont : $date_now" > date_info.txt
    
# Ensuite, je vais lister le contenu du répertoire courant et ajouter cette liste au même fichier
echo "Liste des fichiers et dossiers:" >> date_info.txt
ls >> date_info.txt        

                            

                            #!/bin/bash

list=$(ls)
for element in $list
do
    echo $element >> ./toto.txt
done   

                            

                            #!/bin/bash

list=$(cat toto.txt)
for element in $list
do
    echo $element >> ./nouveau_toto.txt
done

                            

Lecture d'un fichier

Dans cette exemple, je vais lire le contenu d'un fichier ligne par ligne et afficher chaque ligne avec un numéro précédant le texte.

                            #!/bin/bash

filename='date_info.txt'
i=1
while read line; do
    # Affichage du numéro de ligne et du contenu de la ligne
    echo "Ligne $i: $line"
    i=$((i + 1))
done < $filename    

                            

                            #!/bin/bash

cpt=1
while read LINE
do
    echo $cpt ": " $LINE
    let cpt++
done < toto.txt

                            

Lecture de l'entrée clavier

                            #!/bin/bash

echo "Entrez votre nom, prénom et âge :"
read nom prenom age
echo "Je m'appelle $prenom $nom et j'ai $age ans."

                            

Exécution

                            mahmoud@Mahmoud:script_bash$ ./script_19_read.sh
    Entrez votre nom, prénom et âge :
    illourmane mahmoud 25
    Je m'appelle mahmoud illourmane et j'ai 25 ans.

                            

Configuration d'un conteneur Docker

                            #!/bin/bash

echo "Entrez le nom de l'image, le tag et le nom du conteneur :"
read image tag nom_conteneur
echo "Je lance un conteneur Docker avec l'image $image:$tag appelé $nom_conteneur."
docker run --name $nom_conteneur $image:$tag

                            

Exécution

                            mahmoud@Mahmoud:script_bash$ ./script_20_docker.sh
    Entrez le nom de l'image, le tag et le nom du conteneur :
    nginx lastest mon-nginx
    Je lance un conteneur Docker avec l'image nginx:lastest appelé mon-nginx.

                            

Les fonctions

En shell script, il n'est pas requis de spécifier explicitement les paramètres lors de la déclaration d'une fonction. Les fonctions ont la capacité d'accéder aux variables globales ou d'utiliser les arguments passés directement via des paramètres positionnels.
De plus, l'appel d'une fonction se fait sans parenthèses, se distinguant ainsi des syntaxes des langages de programmation tels que Python ou Java. On appelle simplement la fonction par son nom suivi de ses arguments.

Fonction sans paramètre

                            #!/bin/bash

# Déclaration de la fonction
fun_1() {
    echo L\'utilisateur qui lance la fonction est : $USER
}

# Appel de la fonction
fun_1

                            

Fonction avec paramètres

Dans cet exemple, la fonction attend deux paramètres envoyés en argument pour additionner deux chiffres.

                            #!/bin/bash

fun_2() {
    let result=$1+$2
    result2=$(($1 + $2))
    echo 1-Le résultat de l\'addition est : $result
    echo 2-Le résultat de l\'addition est : $result2
}

fun_2 $1 $2

                            

Fonction avec paramètre entré au clavier

                            #!/bin/bash

fun_3() {
    echo "En Fahrenheit, cela fait : $((($1 * 9/5) + 32))°F"
}
    
echo "Entrez la température en Celsius :"
read celsius
    
fun_3 $celsius

                            

Une fonction qui vérifie si un fichier existe

                            #!/bin/bash

fun_4() {
    if [[ -e $1 ]]; then
        echo "Le fichier $1 existe."
    else
        echo "Le fichier $1 n'existe pas."
    fi
}
    
echo "Entrez le nom du fichier à vérifier :"
read nomFichier
    
fun_4 $nomFichier

                            

Manipuler des chaînes de caractères

En shell il est possible de manipuler les chaînes de caractères pour extraires des informations, modifier un symbol délimiteur etc.
Cela simplifier les programmes, et évite l'utilisation d'expression régulière.
Attention dans le cas des séparateurs, les modifications sont persistantes.

                                #!/bin/bash

chaine="Bonjour à tous"
chaine2=${chaine:7:3}
chaine3=${chaine:10:4}
echo $chaine
echo $chaine2
echo $chaine3

                                

                                mahmoud@Mahmoud:script_bash$ ./script_1_chaine_extrac.sh
    Bonjour à tous
    à
    tous

                                

                                #!/bin/bash

chaine="Bonjour à tous"
chaine2=${chaine:10}
echo $chaine
echo $chaine2

                                

                                mahmoud@Mahmoud:script_bash$  ./script_2_trancature.sh
    Bonjour à tous
    tous

                                

Séparateur IFS

En programmation shell, la variable IFS, pour 'Internal Field Separator', est fondamentale pour lire et interpréter correctement les données. Elle définit le séparateur de champ à utiliser lors de la division d'une ligne de texte en mots.
Par défaut, elle inclut le retour à la ligne (newline), l'espace (space) et la tabulation (tab), mais je peux la redéfinir pour changer le comportement de split implicite selon mes besoins spécifiques.

                                #!/bin/bash

oldIFS=$IFS
chaine="Bonjour;Hello;Hola"
echo $chaine
# Redéfinition de l'IFS
IFS=';'
echo $chaine
# Remise à la normale
IFS=$oldIFS
echo $chaine

                                

                                mahmoud@Mahmoud:script_bash$  ./script_1_ifs.sh
    Bonjour;Hello;Hola
    Bonjour Hello Hola
    Bonjour;Hello;Hola

                                

                                #!/bin/bash

# Définition de la fonction d'affichage
afficher_infos() {
    local IFS_SAVE=$IFS  # Sauvegarde de l'IFS actuel
    IFS=';'              # Définition de la virgule comme nouveau IFS
    for var in $1 
    do
        echo $var
    done
    IFS=$IFS_SAVE
    echo "======="
}
    
# Lecture du fichier ligne par ligne
while read LINE 
do
    afficher_infos $LINE
done < "fic.txt"

                                

                                # Fichier fic.txt
Hello;Bonjour;Hola
Azerty;Qwerty
Python;Shell

mahmoud@Mahmoud:script_bash$   ./script_2_ifs.sh
    Hello
    Bonjour
    Hola
    =======
    Azerty
    Qwerty
    =======
    Python
    Schell
    =======

                                

Appel système

Exécution d'un appel système pour installer un package :

                            #!/bin/bash

# Exécute la commande apt install
apt install <package_name>
    
# Vérifie le code de retour de la commande
if [ $? -ne 0 ]; then
    # En cas d'erreur, affiche un message d'erreur et quitte avec un code de sortie non nul
    echo "Erreur lors de l'installation du paquet."
    exit 1
else
    # Si la commande s'est exécutée avec succès, affiche un message de réussite
    echo "Installation du paquet terminée avec succès."
fi

                            

Pour gérer les erreurs on peux utiliser un mélange de redirections de sortie et de structures de contrôle pour afficher les messages d'erreur :

                            #!/bin/bash

# Fonction pour afficher les messages d'erreur
print_error() {
    echo "Erreur: $1" >&2
}
    
# Exécute la commande apt install
if ! output=$(apt install  2>&1); then
    print_error "Impossible d'installer le paquet."
    print_error "$output"
    exit 1
fi
    
# Si la commande s'est exécutée avec succès, affiche un message de réussite
echo "Installation du paquet terminée avec succès."        

                            

Extraire une information

Dans cet exemple, nous allons voir comment extraire une information contenu dans une sortie d'appel système :

                            xe snapshot-list params=uuid
    uuid ( RO)    : b4568bdb-0aad-f63f-5a15-610421a65614
    uuid ( RO)    : e729e7a2-391f-6312-7d28-5ea5006615a7

                            

Le but ici est d'extraire uniquement la valeur de l'uuid. Pour cela nous allons utiliser awk, cette commande permet d'extraire des champs spécifiques à partir de la sortie de commande en spécifiant le délimiteur (par défaut, c'est l'espace ou la tabulation) et le numéro de champ.
En partant de la sortie précédente, on voit que chaque ligne contient un préfixe uuid ( RO) : suivi de l'UUID.
Dans ce cas, le préfixe uuid ( RO) : compte comme quatre champs lorsqu'on considère l'espace comme délimiteur :
- Champ 1 : uuid
- Champ 2 : (
- Champ 3 : RO)
- Champ 4 : ":"
L'UUID lui-même commence après ces quatre champs et est donc considéré comme le cinquième champ.
En utilisant awk, on utilisant on peut spécifier quel champ on souhaite extraire :

                            xe snapshot-list params=uuid | awk '/uuid \( RO\)/ {print $5}'

                            

Commandes avec interactions

Lorsqu'une commande attend une réponse yes ou autre chose de notre part, nous pouvons l'automatiser en utilisant un pipe | avec les commandes echo ou yes. Cela nous permet de gérer les confirmations requises dans un script. Voici comment scripter ce genre d'appel :

Méthode 1 : Utiliser echo avec un pipe (|)

On utilise echo pour envoyer une réponse (yes ou no) à une commande qui attend une confirmation.
Exemple : Pour une commande qui attend yes pour continuer, on peut utiliser echo avec un pipe (|) :

                            #!/bin/bash

echo "yes" | xe template-uninstall template-uuid=$tmp_uuid_template 

exit 0

                            

Méthode 2 : Utiliser yes

La commande yes répète en continu une réponse (yes ou no) et la pipe à la commande.
Exemple : Pour envoyer en continu yes à une commande :

                            #!/bin/bash

yes | xe template-uninstall template-uuid=$tmp_uuid_template 

exit 0

                            

Nous pouvons personnaliser la réponse répétée par yes en ajoutant l'argument souhaité :

                            #!/bin/bash

yes "yes" | xe template-uninstall template-uuid=$tmp_uuid_template 

exit 0