Лист за преговор: Maîtrise des structures et commandes Bash

📋 Plan du Cours

1. Signature Bash
2. Autorisation fichier
3. Assignation variables
4. Lancement script
5. Affichage message
6. Lecture entrée utilisateur
7. Gestion options script
8. Structures décisionnelles
9. Opérateurs comparaison
10. Boucles for/while
11. Commandes de contrôle

📖 1. Signature Bash

🔑 Notions clés & Définitions

• Shebang (#!/bin/bash)
  Indicateur placé en début de script pour spécifier que le fichier doit être exécuté avec Bash.
  Exemple : #!/bin/bash

• Autorisation (chmod +x)
  Commande permettant de rendre un script exécutable.
  Exemple : chmod +x script.sh

• Assignation (NOM=Valeur)
  Stockage d'une information dans une variable.
  Exemple : NOM="Alice"

• Commande d'exécution (./script.sh)
  Lancer un script dans le répertoire courant.
  Exemple : ./mon_script.sh

• Affichage (echo)
  Affiche un message dans le terminal.
  Exemple : echo "Bonjour"

• Lecture utilisateur (read)
  Attend une entrée de l'utilisateur.
  Exemple : read NOM

📝 Points essentiels

• Le shebang (#!/bin/bash) doit être la première ligne pour assurer l'exécution correcte du script.
• La commande chmod +x est indispensable pour rendre le script exécutable.
• Les variables sont assignées sans espace (NOM="Alice") et peuvent être récupérées par $NOM.
• La commande echo sert à afficher des messages ou des variables dans le terminal.
• La commande read permet d'interagir avec l'utilisateur, avec ou sans question (read -p "Question" NOM).
• L'exécution d'un script se fait en précisant le chemin (./script.sh) après avoir donné les droits.

💡 À retenir

La signature Bash repose sur le shebang pour définir l'interpréteur, l'autorisation d'exécution, et l'utilisation de variables, commandes d'affichage et de lecture pour créer des scripts interactifs et automatisés.

📖 2. Autorisation fichier

🔑 Notions clés & Définitions

Notion	Définition	Exemple / Utilisation
chmod	Commande permettant de modifier les droits d'accès d’un fichier ou dossier.	chmod +x script.sh pour rendre un script exécutable.
+x / -x / r / w / x	Modificateurs d'autorisations : + (ajoute), - (supprime), r (lecture), w (écriture), x (exécution).	chmod u+x fichier pour ajouter le droit d'exécution à l'utilisateur.
Propriétaire / Groupe / Autres	Différents niveaux d'autorisations pour l'utilisateur propriétaire, le groupe, et tous les autres.	chmod 754 fichier : propriétaire (7), groupe (5), autres (4).
Permissions numériques	Représentation numérique des droits (0 à 7) pour chaque catégorie.	7 = lecture + écriture + exécution, 4 = lecture seule.
Vérification fichier/dossier	Commande -f (fichier) ou -d (dossier) pour tester leur existence.	[ -f monfichier.txt ] && echo "Fichier existant".

📝 Points essentiels

• La commande chmod est essentielle pour gérer la sécurité et l'accès aux fichiers scripts ou données.
• Les permissions peuvent être modifiées en mode symbolique (+x, -w) ou numérique (chmod 755).
• La vérification de l'existence d’un fichier ou d’un dossier se fait avec [ -f fichier ] ou [ -d dossier ].
• La gestion des droits doit respecter les principes de moindre privilège pour la sécurité.
• La syntaxe numérique : 4 (lecture), 2 (écriture), 1 (exécution). La somme donne le niveau de permission (ex : 7 = 4+2+1).

💡 À retenir

Les droits d’accès aux fichiers, modifiables via chmod, sont fondamentaux pour la sécurité et le bon fonctionnement des scripts. La vérification de l’existence d’un fichier ou d’un dossier permet de conditionner l’exécution de commandes.

📖 3. Assignation variables

🔑 Notions clés & Définitions

• Variable : Espace mémoire permettant de stocker une valeur (texte, nombre, etc.) pour une utilisation ultérieure dans le script. Exemple : NOM=Valeur.
• Assignation : Opération qui consiste à donner une valeur à une variable, généralement avec le symbole = sans espaces. Exemple : NOM="Jean".
• Paramètres positionnels ($1, $2, ... ) : Variables automatiques qui récupèrent les arguments passés lors de l'exécution du script. $1 correspond au premier argument, $2 au second, etc.
• Nombre d'arguments ($#) : Variable qui indique le nombre total d'arguments passés au script.
• Variable spéciale $? : Récupère le code de sortie de la dernière commande exécutée (0 si succès, autre si erreur).

📝 Points essentiels

• La syntaxe d'assignation est NOM=Valeur sans espaces autour du =.
• Les variables sont utilisées pour stocker et manipuler des données dans le script.
• Les paramètres positionnels ($1, $2, ...) permettent de rendre un script dynamique selon les arguments fournis.
• $# est utile pour vérifier le nombre d'arguments et gérer les erreurs ou conditions.
• La variable $? est essentielle pour contrôler le flux en fonction du succès ou de l’échec des commandes précédentes.
• La déclaration de variables locales ou globales dépend du contexte, mais en Bash, toutes sont globales par défaut sauf dans une fonction.

💡 À retenir

L'assignation de variables permet de stocker et de manipuler des données dans un script Bash, facilitant la création de scripts dynamiques et interactifs. La maîtrise des paramètres positionnels et des variables spéciales est essentielle pour un scripting efficace.

📖 4. Lancement script

🔑 Notions clés & Définitions

• Signature (#!/bin/bash)
  Indication en première ligne d’un script Bash pour spécifier l’interpréteur utilisé. Elle permet au système de reconnaître le fichier comme un script Bash exécutable.

• Autorisation (chmod +x)
  Commande permettant de rendre un fichier exécutable. Elle est essentielle pour pouvoir lancer un script en ligne de commande.

• Variable (NOM=Valeur)
  Stockage d’une information dans une variable, utilisée pour transmettre ou manipuler des données dans le script.

• Commande d’exécution (./script.sh)
  Lance le script dans le répertoire courant. Nécessite que le fichier ait l’autorisation d’exécution.

• Affichage (echo)
  Commande qui affiche un message ou une valeur dans le terminal, utile pour la communication avec l’utilisateur ou le débogage.

📝 Points essentiels

• La ligne #!/bin/bash doit être la toute première ligne pour que le script soit reconnu comme un script Bash.
• Avant d’exécuter un script, il faut souvent rendre le fichier exécutable avec chmod +x.
• Les variables sont assignées sans espaces (NOM=Valeur) et peuvent être utilisées dans le script pour stocker des informations dynamiques.
• La commande ./ est nécessaire pour lancer un script local, sauf si le script est dans un répertoire inclus dans la variable $PATH.
• echo est la méthode principale pour afficher des messages ou des résultats dans le terminal.
• La gestion de l’interaction utilisateur se fait avec read (attente de saisie) et read -p (question + attente).

💡 À retenir

Le lancement d’un script Bash repose sur la signature #!/bin/bash, la configuration des droits d’exécution, et l’utilisation de commandes simples comme echo et read pour interagir avec l’utilisateur.

📖 5. Affichage message

🔑 Notions clés & Définitions

• echo : Commande permettant d'afficher un message ou une variable dans le terminal.
  Exemple : echo "Bonjour" affiche "Bonjour".

• read : Commande qui attend que l'utilisateur tape une réponse, stockée dans une variable.
  Exemple : read nom attend une saisie et la stocke dans nom.

• read -p : Variante de read qui affiche une question ou un message avant d'attendre la réponse.
  Exemple : read -p "Quel est votre âge ? " age.

• **#** : Variable spéciale qui compte le nombre d'arguments passés à un script ou une fonction. *Exemple :* Si le script reçoit 3 arguments, `#` vaut 3.

• $1,$2, ... : Variables positionnelles correspondant aux arguments passés au script.
  Exemple : Si on lance ./script.sh hello world, $1 vaut "hello" et $2 "world".

📝 Points essentiels

• La commande echo est fondamentale pour afficher des messages, des variables ou des résultats dans le terminal.
• La commande read permet d'interagir avec l'utilisateur en récupérant ses réponses.
• La syntaxe read -p facilite la communication en affichant une question ou un message avant la saisie.
• Les variables $# et $1, $2, ... sont essentielles pour gérer les arguments passés à un script Bash.
• La gestion des arguments permet de rendre les scripts dynamiques et interactifs.

💡 À retenir

L'affichage et la récupération d'informations dans un script Bash reposent principalement sur echo et read, avec une gestion efficace des arguments pour rendre les scripts interactifs et modulables.

📖 6. Lecture entrée utilisateur

🔑 Notions clés & Définitions

• read : Commande permettant d'attendre que l'utilisateur tape une information dans le terminal.
• read -p : Variante de read qui affiche une question ou un message avant d'attendre la réponse de l'utilisateur.
• $1,$2, ... : Variables positionnelles qui récupèrent les arguments passés lors de l'exécution du script (premier, deuxième argument, etc.).
• $# : Variable spéciale qui indique le nombre d'arguments fournis au script.
• echo : Commande d'affichage qui affiche un message ou une variable dans le terminal.

📝 Points essentiels

• La commande read est essentielle pour rendre un script interactif, permettant de collecter des données utilisateur.
• La syntaxe read -p "Question ?" variable facilite la collecte d'une réponse après une question affichée à l'écran.
• Les arguments $1, $2, ... permettent de passer des paramètres au script, utiles pour automatiser ou personnaliser son comportement.
• La variable $# aide à vérifier le nombre d'arguments pour gérer des cas d'erreur ou des comportements conditionnels.
• La commande echo est souvent utilisée pour afficher des instructions, des résultats ou des messages d'erreur à l'utilisateur.

💡 À retenir

La lecture d'entrée utilisateur dans un script Bash repose principalement sur la commande read, qui, combinée aux arguments et variables, permet de créer des scripts interactifs et adaptatifs.

📖 7. Gestion options script

🔑 Notions clés & Définitions

• Signature (#!/bin/bash) : Indique que le fichier est un script Bash, permettant au système d'utiliser l'interpréteur Bash pour l'exécuter.
• Autorisation (chmod +x) : Commande qui donne le droit d'exécution à un fichier, rendant le script exécutable.
• Variables (NOM=Valeur) : Stockent des informations ou des paramètres pour une utilisation ultérieure dans le script.
• Options ($1, $2, ...) : Représentent les arguments passés lors de l'exécution du script, permettant de personnaliser son comportement.
• Structures de décision (if / fi) : Permettent d'exécuter des blocs de code conditionnels selon des critères spécifiques.

📝 Points essentiels

• La signature en début de script est obligatoire pour indiquer le langage utilisé.
• La commande chmod +x doit être exécutée pour rendre un script exécutable.
• Les variables sont assignées sans espace et peuvent contenir des valeurs dynamiques ou statiques.
• Les options $1, $2, etc., permettent de récupérer les paramètres passés lors de l'exécution pour adapter le comportement du script.
• Les structures conditionnelles (if / then / else) sont fondamentales pour la logique décisionnelle dans un script.
• La gestion des fichiers/dossiers avec -f et -d permet de vérifier leur existence avant d'agir.
• Les boucles (for, while) facilitent la répétition d'actions, avec des commandes comme break et continue pour contrôler leur flux.
• La fonction (func() { }) permet de regrouper des commandes réutilisables, améliorant la modularité.
• La commande $? donne le code de sortie de la dernière commande exécutée, utile pour la gestion des erreurs.
• La commande exit permet de terminer le script proprement avec un code spécifique.

💡 À retenir

Le script Bash repose sur une structure claire : déclaration de la signature, gestion des permissions, utilisation de variables, contrôle de flux avec conditions et boucles, et organisation en fonctions pour une automatisation efficace.

📖 8. Structures décisionnelles

🔑 Notions clés & Définitions

• Structure conditionnelle (if / fi) : Permet d'exécuter des blocs de code en fonction de la véracité d'une condition. Syntaxe : if [ condition ]; then ... fi.
• Opérateurs de comparaison : Utilisés pour comparer des valeurs ou du texte dans une condition. Exemples : ==, !=, -f, -d, -eq, -ne.
• Commandes de contrôle de flux : Incluent then, else, elif pour définir différentes branches selon le résultat de la condition.
• Boucles (for / while) : Permettent de répéter des actions. for parcourt une liste, while répète tant qu'une condition est vraie.
• Commandes de rupture et de continuation : break pour sortir d'une boucle, continue pour passer à l'itération suivante.

📝 Points essentiels

• La structure if est la base pour la prise de décision dans un script Bash. Elle s'accompagne souvent d'opérateurs de comparaison pour évaluer des conditions.
• Les opérateurs -f et -d vérifient l'existence de fichiers ou dossiers, respectivement, ce qui est crucial pour éviter des erreurs.
• La commande then marque le début du bloc d'instructions si la condition est vraie, tandis que else gère le cas contraire.
• Les boucles for et while permettent d'automatiser la répétition d'actions, avec do et done pour délimiter le bloc.
• La commande exit permet de terminer un script en renvoyant un code de sortie, utile pour indiquer le succès ou l'échec.

💡 À retenir

Les structures décisionnelles en Bash permettent de contrôler le flux d'exécution en fonction de conditions, rendant les scripts dynamiques et adaptatifs. La maîtrise de if, des opérateurs de comparaison, et des boucles est essentielle pour écrire des scripts efficaces et robustes.

📖 9. Opérateurs comparaison

🔑 Notions clés & Définitions

• Opérateur d'égalité (==)
  Compare si deux chaînes de caractères ou deux nombres sont identiques.
  Exemple : [ "$a" == "$b" ] retourne vrai si $a est égal à $b.

• Opérateur de différence (!=)
  Vérifie si deux valeurs ne sont pas identiques.
  Exemple : [ "$a" != "$b" ] retourne vrai si $a est différent de $b.

• Opérateur de comparaison numérique (-eq, -ne, -lt, -le, -gt, -ge)
  Utilisés pour comparer des nombres.

  • -eq : égal à
  • -ne : différent de
  • -lt : inférieur à
  • -le : inférieur ou égal à
  • -gt : supérieur à
  • -ge : supérieur ou égal à

• Opérateurs de test de fichiers (-f, -d)
  Vérifient l'existence et le type d'un fichier ou d'un dossier.

  • -f : fichier régulier existant
  • -d : dossier existant

• Opérateur de comparaison dans les scripts ($?, $#)

  • $? : code de sortie de la dernière commande (0 = succès)
  • $# : nombre d'arguments passés au script ou à la fonction

📝 Points essentiels

• Les opérateurs == et != sont utilisés pour comparer des chaînes de caractères dans des tests [ ] ou [[ ]].
• La comparaison numérique doit se faire avec -eq, -ne, etc., dans des tests [ ].
• La syntaxe correcte est cruciale : par exemple, pour comparer deux variables $a et $b en numérique : [ "$a" -eq "$b" ].
• Les tests de fichiers permettent de vérifier l'existence ou le type d’un fichier ou d’un dossier avant d’agir.
• La variable $? est utile pour contrôler le succès ou l’échec d’une commande précédente dans une condition.

💡 À retenir

Les opérateurs de comparaison en Bash permettent de réaliser des décisions conditionnelles précises, essentielles pour le contrôle du flux dans les scripts. Leur maîtrise garantit la robustesse et la fiabilité des automatisations.

📖 10. Boucles for/while

🔑 Notions clés & Définitions

• Boucle for : Structure de répétition qui exécute un bloc de code pour chaque élément d'une liste ou d'une séquence.
  Syntaxe : for variable in liste; do ...; done
  Utilité : Parcourir des éléments de façon simple et efficace.

• Boucle while : Structure de répétition qui exécute un bloc de code tant qu'une condition est vraie.
  Syntaxe : while condition; do ...; done
  Utilité : Répéter une action jusqu'à ce qu'une condition change.

• Commandes break et continue :

  • break : Interrompt immédiatement la boucle en cours.
  • continue : Saute l'itération en cours et passe à la suivante.

• Variables de contrôle : Variables utilisées pour gérer ou compter les itérations, souvent initialisées avant la boucle.

• Condition : Expression évaluée à vrai ou faux, déterminant la déroulement de la boucle (dans while) ou la sélection d'éléments (dans for).

📝 Points essentiels

• La boucle for est idéale pour parcourir une liste ou une séquence fixe, tandis que while est adaptée pour des conditions dynamiques ou dépendantes d'événements.
• La syntaxe correcte inclut toujours la délimitation par do et done.
• Les commandes break et continue permettent de contrôler le flux d'exécution à l'intérieur des boucles.
• La variable de contrôle dans une boucle for peut être implicite ou explicite, selon la syntaxe utilisée.
• La condition dans while doit évoluer pour éviter une boucle infinie.

💡 À retenir

Les boucles for et while sont essentielles pour automatiser la répétition de tâches en script Bash, permettant une gestion efficace des processus itératifs. La maîtrise de leur syntaxe et de leur contrôle de flux est fondamentale pour écrire des scripts robustes et efficaces.

📖 11. Commandes de contrôle

🔑 Notions clés & Définitions

• Signature (#!/bin/bash) : Indique que le fichier est un script Bash, permettant au système d'interpréter le contenu avec Bash.
• Structure de décision (if / fi) : Permet d'exécuter des blocs de code en fonction de conditions booléennes.
• Boucles (for, while) : Permettent de répéter des actions plusieurs fois selon des critères définis.
• Commandes de contrôle (break, continue) : break interrompt une boucle, continue passe à l'itération suivante.
• Fonctions (func() { }) : Regroupent un ensemble de commandes réutilisables dans le script.

📝 Points essentiels

• La signature #!/bin/bash doit être la première ligne pour que le script soit reconnu comme script Bash.
• Les structures conditionnelles (if / else) utilisent then et fi pour délimiter le bloc conditionnel.
• Les boucles for et while s'accompagnent de do et done pour délimiter leur contenu.
• La commande read peut attendre une entrée utilisateur, avec ou sans question (-p).
• La gestion des erreurs et des résultats se fait via $?, qui retourne le code de sortie de la dernière commande exécutée.
• Les commandes && et || permettent d'enchaîner des commandes selon leur succès ou échec.

💡 À retenir

Les commandes de contrôle en Bash permettent de gérer la logique, la répétition et la modularité des scripts, essentielles pour automatiser efficacement. La maîtrise des structures conditionnelles, boucles et fonctions est fondamentale pour écrire des scripts robustes et dynamiques.

📊 Tableaux de Synthèse

Fonction	Description	Exemple
Shebang (#!/bin/bash)	Indique l’interpréteur pour exécuter le script	#!/bin/bash
Autorisation (chmod)	Rendre un script exécutable ou modifier droits	chmod +x script.sh
Assignation variable	Stocker une valeur dans une variable	NOM="Alice"
Lancement script	Exécuter un script dans le terminal	./script.sh
Affichage (echo)	Afficher un message ou une variable	echo "Bonjour"
Lecture utilisateur (read)	Attendre une saisie utilisateur	read NOM

⚠️ Pièges & Confusions Fréquentes

1. Oublier de rendre le script exécutable avec chmod +x.
2. Mettre un espace autour du = lors de l’assignation (NOM = "Alice"), ce qui provoque une erreur.
3. Oublier le shebang (#!/bin/bash) en début de script, empêchant son exécution correcte.
4. Confondre echo et read : echo affiche, read attend une saisie.
5. Utiliser ./ pour lancer un script sans avoir donné les droits d’exécution.
6. Ne pas vérifier l’existence d’un fichier avec [ -f fichier ] ou [ -d dossier ].
7. Confusion entre permissions symboliques (+x, -w) et numériques (755, 644).

✅ Checklist Examen

• Vérifier que le script commence par le shebang #!/bin/bash.
• S’assurer que le fichier a les droits d’exécution (chmod +x).
• Connaître la syntaxe d’assignation (NOM="Valeur").
• Savoir lancer un script avec ./nom_script.sh.
• Pouvoir utiliser echo pour afficher un message ou une variable.
• Maîtriser la commande read pour récupérer une entrée utilisateur.
• Connaître la différence entre +x, -w, -r et leur représentation numérique.
• Vérifier l’existence d’un fichier ou d’un dossier avant de l’utiliser.
• Comprendre le rôle des paramètres positionnels ($1, $2, etc.).
• Savoir utiliser chmod pour modifier les droits d’un fichier.
• Savoir utiliser read -p pour poser une question avant la saisie.
• Vérifier que le script ne comporte pas d’erreurs de syntaxe.
• S’assurer que toutes les variables utilisées sont déclarées et initialisées.
• Vérifier que le script est testé dans un environnement contrôlé.
• S’assurer que le script ne comporte pas de commandes dangereuses ou mal sécurisées.
• Vérifier la maîtrise des structures conditionnelles et des boucles.
• Savoir interpréter le code de sortie $? pour gérer les erreurs.
• Vérifier la compréhension des options de echo et read.
• S’assurer de la maîtrise des permissions pour la sécurité.
• Vérifier la cohérence entre la logique du script et ses objectifs.
• S’assurer que le script est commenté pour la compréhension.
• Vérifier la compatibilité du script avec différentes versions de Bash.