[[lien:bash:perso |Retour]]
Ce document est largement inspiré de
Initiation à Bash 21 Apr. 2007
Auteur : lenounoursmignon Responsable : TrustRobot
Source du document : http://www.trustonme.net/didactels/148.html
====== Le premier script ======
Un script Bash est un fichier texte, qui commence toujours par \#!/bin/bash ou \#!/bin/sh, et qui doit être rendu exécutable pour pouvoir s'éxécuter. Dans ce fichier on definit les commandes selon l'ordre dans lequel on souhaite qu'elles s'exécutent.
Exemple : Ouvrez votre éditeur de texte préfèré et copiez-y les lignes ci-dessous. que vous enregistrerez dans le fichier mon_script.sh :
#!/bin/bash echo "Bonjour"
Rendons-le exécutable par : chmod u+x mon_script.sh
Et pour l'exécuter ce sera : /le_chemin_vers/mon_script.sh
Remarque : pour inclure des commentaires dans votre script - ce qui est indispensable dans tout programme/script qui se respecte - vous devez faire précéder la ligne du symbole #.
====== Variables et paramètres ======
On peut définir des variables locales dans le script par MA_VARIABLE='moi', et pour les manipuler il faut les préfixer du symbole $, exemple :script1.sh
#!/bin/bash
# script1.sh
# affiche le nombre d'arguments transmis
echo "le nombre d'arguments est $#"
echo 'le nombre d'\''arguments est $#'
Les scripts Bash sont dotés de certains paramètres spéciaux. On peut récupérer leurs valeurs dans le script par :
- $0 correspond au nom du script lancé, \$1 correspond au premier argument, \$2 au deuxième argument
- $# a pour valeur le nombre total d'arguments passés au script
- $? a pour valeur le code de retour de la dernière commande exécutée dans le shell
- $@ pour récupérer la concaténation de tous les paramètres, en les séparant par un espace
2 fonctions utiles dans les scripts bash
===== Let =====
Incrémentation (ajouter 1 à i)
let i=i+1
let "i = i + 1" # Ici mettez des espaces
===== Read =====
Lecture d'une valeur au clavier
echo -n "Entrez votre nom :"
read nom
echo \$nom
====== Les chaînes de caractères : ======
* ' ' délimitent une chaîne de caractères. A l'intérieur, tous les métacaractères perdent leur signification.
* " " délimitent une chaîne de caractères. A l'intérieur, tous les métacaractères perdent leur signification, à l'exception des métacaractères `, $ et \
* \ protège le caractère qui suit, que ce soit un caractère normal ou un métacaractère du shell (sauf à l'intérieur d'une chaîne délimitée par des ').
**Exemple :**
dupont.sh
#!/bin/bash
nom='Dupont'
echo 'Mr Dupont' affichera .........
echo "Mr $nom" affichera .........
echo 'Mr $nom' affichera .........
echo "Mr \"$nom\"" affichera .........
echo "Mr \$nom" affichera .........
Pour connaître la taille(longueur) d'une chaîne de caractères, utilisez la syntaxe suivante :
${#ma_variable}
**Exemple :**
nom='Dupont'
echo ${#nom} #affiche ....
===== Opérateurs de chaîne =====
${nomvar:-mot} Si nomvar existe retourne sa valeur, sinon renvoie mot
Exemple : ${compteur:-0} donne 0 si compteur est indéfini, compteur reste indéfini.
${nomvar:=mot} Si nomvar existe retourne sa valeur, sinon la fixe à mot
Exemple : ${compteur:-0} fixe compteur à 0 s'il était indéfini.
${nomvar:?message} Si nomvar existe et n'est pas nulle,retourne sa valeur, sinon affiche nomvar : message et annule la commande ou le script en cours
Exemple : Vous avez fait un script programme.sh qui demande un argument
programme.sh
#!/bin/bash
premier=${1:?"argument absent"}
echo "premier argument : $premier"
chmod u+x programme.sh
./programme.sh #affiche ./programme.sh: line 2: 1: argument absent
./programme.sh 2 #affiche premier argument : 2
${nomvar:+mot} Si nomvar existe et n'est pas nulle, retourne mot, sinon renvoie nul
**Objectif** tester l'existence d'une variable
${nomvar:décalage:longueur} réalise un développement de sous-chaîne.Si longeur est omis va jusqu'à la fin de nomvar
**Exemple** : si nom = //promotion//, ${nom:3} retourne //motion// et ${nom:3:3} retourne //mot//
====== Les Conditions ======
Cela peut paraître surprenant, mais il n'existe pas de type Booléen ( True/False ou encore 0/1 ) en Bash, ni d'autres types d'ailleurs, car Bash est un langage non-typé.
Ceci étant, les conditions, sous leur forme booléenne, n'existent donc pas à proprement parler. Dans ce document, nous avons tout de même utilisé le mot 'condition' pour ne pas perturber le lecteur, mais sachez que ce sont en fait des 'commandes' qui jouent ce rôle.
Je m'explique, Bash considère qu'une commande s'est bien deroulée lorsqu'elle reçoit comme valeur de sortie '0' (zéro), toute autre valeur correspondant à une exécution non réussie (entièrement ou partiellement).
Donc, si, dans la structure de commande, la commande qui joue le rôle de condition renvoie '0', alors cela correspond à un True dans le type Booléen, et vice-versa. Toute condition est analysée par la commande test(interne à Bash), sans pour autant qu'elle soit obligatoirement écrite.
** Voici trois exemples** pour expliciter ce qui vient d'être dit :
test.sh
if test -f mon_script ; then
echo "le fichier existe"
fi
if [ -f mon_script.sh ]; then
echo "le fichier existe"
fi
if [ ./ma_commande ]; then
echo "la commande s'est terminée avec succès"
fi
Quelques comparaisons utiles :
* -a ou -e fichier existe
* -f teste l'existence d'un fichier et est un fichier normal.
* -d teste l'existence d'un répertoire
* -x teste si le fichier ou répertoire existe et est exécutable ou traversable pour un répertoire
* -r teste si le fichier existe et est ouvert en lecture
* -w teste si le fichier existe et ouvert en écriture
* -s teste si le fichier existe et a une taille supérieur à 0 octet
Pour les comparaisons arithmétiques (voir la deuxième partie de ce tutoriel pour plus d'informations), il peut être plus agréable d'utiliser une autre syntaxe :
if (( $nombre_1 == $nombre_2 )); then
echo "il y a egalité"
fi
**Remarque** : il faut **TOUJOURS** laisser un espace entre les crochets "[ ]" et entre chaque argument; sinon vous obtiendrez des messages d'erreurs tels que "syntax error in expression" ou "syntax error near unexpected token".
====== Les structures de contrôles ======
Comme dans tout langage de programmation, avec Bash il est possible de casser la séquence d'exécution des commandes, en utilisant les structures de contrôles habituelles. Voici la syntaxe à utiliser.
===== IF : =====
if condition_1 # si condition_1
then commandes1 # alors commandes1
elif condition_2 # sinon si condition_2
then commandes2 # alors commandes2
else commandes3 # sinon commandes3
fi # fin du si
**Exemple :** si.sh
#!/bin/bash
# Ecrire un script qui dit si le fichier passé
# en paramètre est un fichier, un répertoire ou autre chose
# Si le paramètre est nul on envoie un message
if [ -z $1 ] ; then # voir aussi -n
echo "Vous n'avez pas entré de paramètres"
echo "Le mode d'utilisation du script est $0 NomDuFichier"
exit 0
fi
if [ -f $1 ] ; then # alors c'est un fichier
echo "$1 est un fichier"
elif [ -d $1 ] ; then #c'est un répertoire
echo "$1 est un répertoire"
else
echo "Il semble que $1 ne soit ni un fichier ni un répertoire
ou alors n'existe pas."
fi
===== FOR : =====
Pour variable dans liste_de_cas faire commandes fin_faire
for variable in liste_de_cas do commandes done
for variable in $(seq [premier] [incrément] dernier) do commandes done
for (( expr1 ; expr2 ; expr3 )) do commandes done
**Exemple :** boucle.sh
#!/bin/bash
# boucle.sh
for fruit in pomme orange banane
do
echo $fruit
done
L'exécution du programme affiche :
pomme
orange
banane
===== WHILE : =====
Tant que condition vraie faire commandes fin_faire
while condition do commandes done; on sort du tant que (while) quand la condition est fausse.
Exemple :
i=10 #variable i à 10
while [ $i -gt 0 ] # tant que i > 0
do # faire
echo $i # afficher la valeur de i
let i=i-1 # i=i-1, on décrémente i
done # fin de la boucle tant que
===== UNTIL : =====
Jusqu'à condition fausse faire commandes fin_jusqu'à
until condition do commandes done; on sort du jusqu'à (until) quand la condition est vraie
Exemples on peut simplement remplacer while [ $i -gt 0 ] par until ! [ $i -gt 0 ]
A vous de l'améliorer...
===== CASE : =====
Choix variable dans traitement des cas fin_cas
case variable in
cas1) commande1 ;;
cas2) commande2 ;;
*) commande_par_defaut ;;
esac #( cas1 et cas2 sont des chaînes de caractères. )
**Exemple :** choix.sh
#!/bin/bash
clear
echo
echo "<1> Micro-informatique "
echo "<2> Réseaux "
echo "<3> Installation "
echo "<4> Maintenance "
echo ""
echo "Taper une option du menu 1, 2, 3, 4, ou pour quitter"
read saisie
case $saisie in
1) echo "Vous avez choisi l'option 1 Micro-informatique" ;;
2) echo "Vous avez choisi l'option 2 Réseaux " ;;
3) echo "Vous avez choisi l'option 3 Installation" ;;
4) echo "Vous avez choisi l'option 4 Maintenance" ;;
q|Q) echo "Vous avez choisi de quitter l'application" ;;
*) # Tous les autres cas
echo "Vous avez saisi un peu n'importe quoi" ;;
esac
exit 0
====== Les fonctions : ======
On peut définir des fonctions en Bash, cela peut être très utile pour structurer ses programmes. La syntaxe est la suivante :
ma_fonction() { corps }
Pour appeler la fonction dans le script ce sera :
ma_fonction param1 param2 param3 ...
A l'intérieur du corps de la fonction, les paramètres sont disponibles dans les variables $0, $1, $2 ... Le nombre de paramètres etant toujours $#. Une variable utilisée à l'intérieur d'une fonction est globale!
Pour éviter ce phénomène, il faut rajouter local à la déclaration de la variable :
local MA_VARIABLE
**Exemple :** somme.sh
#!/bin/bash
valeur=0
calcul() {
somme=$(( $1 + $2 ))
local valeur=$somme
}
calcul 5 9
echo $somme #retourne "14"
echo $valeur #retourne "0"
**Remarque** : la déclaration de la fonction dans le script doit ABSOLUMENT se faire avant son appel, autrement, vous obtiendrez un "command not found"
Une fonction se termine soit après l'exécution de la dernière commande située avant l'accolade fermante, auquel cas le code de retour est celui de cette dernière commande, soit après exécution d'une commande return n, avec "n" un nombre compris entre 1 et 255.
Attention le code de retour indique si la fonction s'est bien déroulée, pas la valeur calculée
On utilise souvent echo à la fin d'une fonction pour renvoyer sa valeur, exemple : somme1.sh
#!/bin/bash
calcul() {
echo $(( $1 + $2 ))
}
somme=$(calcul 5 9)
echo le résultat est $somme #retourne "le résultat est 14"
On remarquera que l'echo de la fonction n'est pas affiché à l'écran mais affecté à la variable somme