Alphorm.com Formation Scripting Bash avancé pour GNU/Linux

Scripting Bash tous droits réservés noelmace.com autorisation d'exploitation exceptionnellement délivrée pour le site alphorm.com
Noël Macé
Formateur et Consultant indépendant
Expert Unix et FOSS
Contact : alphorm@noelmace.com
Présentation de la
formation
Introduction
Site : http://www.alphorm.com
Blog : http://www.alphorm.com/blog
Forum : http://www.alphorm.com/forum

Plan
●
Présentation du formateur
●
Qu’est ce que Linux ?
●
Qu'est ce que Bash ?
●
Pré-requis
●
Le plan de formation
●
Outils nécessaires
●
Comment travailler

Présentation du formateur
●
Noël Macé
●
alphorm@noelmace.com
●
Formateur consultant expert Unix et FOSS
●
Mes références :
 Mon profil Viadeo : http://fr.viadeo.com/fr/profile/noel.mace
 Mon parcours : http://vizualize.me/noelmace
 Mon site : http://noelmace.com
• Contacts
• Blogs
• Base de connaissance
• CV
• Etc …

Qu’est ce que Linux ?
●
Un kernel
 Développé par Linux Torvalds à partir de Minix
 En 1991
●
Un système d’exploitation
 Libre et open source
 Issu du projet GNU (1983)
 Leader sur :
• les serveurs web (65%)
• Les systèmes embarqués
• Les super-calculateurs

Qu'est ce que Bash ?
● Un shell Unix
– interpréteur de commande
● interaction (terminal)
● ou séquentiel (scripting)
– permet d’exécuter les différentes commandes de GNU/Linux
● mais aussi d'autre systèmes Unix (Solaris, BSD, Mac OS X, etc …)
– permet de créer des programmes simples
● grâce à des commandes internes de scripting (if, while, etc …)
● automatisation
● Cf cours LPIC1

Pré-requis
● bases du scripting Bash
– cf cours LPIC1
● bonne connaissance de GNU/Linux
– cf cours LPIC1 et 2
● algorithmique

Le plan de formation
Bases
●
premiers pas
●
variables
●
état de sortie
●
tests
●
opérations
●
boucles
●
substitution de commandes
Scripting avancé
●
bonnes pratiques
●
commandes
●
redirection
●
documents intégrés
●
sous-shells et shells restreints
●
fonctions
●
alias
●
listes et tableaux
●
débogage
●
options de bash

Outils nécessaires
● il vous suffit
– d'un interpréteur Bash
● sous GNU/Linux : shell par défaut
● sous Windows : cygwin
● sous Mac OS X : tcsh est le shell par défaut
– pour utiliser Bash ; voir ici
– d'un éditeur de texte
● en mode console : vim, nano ou emacs
– cf LPIC1
● en mode graphique : gedit, leafpad, ou autre

Comment travailler
●
Chercher un maximum d'exemples
– init scripts, scripts de configuration des paquets, outils, etc …
●
faire "l'ingénieur fainéant"
– utiliser le scripting pour toute opération répétitive ou redondante
●
Se documenter
 comme toujours, le man est votre amis
 ce cours peut être complété par l'excellent guide de tldp.org, porté par Mendel Cooper :
Advanced Bash Scripting Guide
• traduction en français par traduc.org, disponible ici

Ce qu’on a couvert
●
Introduction de ce cours
– formateur
– les outils à utiliser
– ce que nous verrons

Noël Macé
Expert Unix et FOSS
Premiers pas
Bases du scripting Bash

Plan
• Executer un script
• Demo

Executer un script
●
directement : nécessite un shebang
– première ligne du script
●
#! : nombre magique (cf man magic)
– indique l'interpréteur (/bin/bash dans notre cas)
– utiliser /bin/sh permettra de rendre le script portable aux
machines non-linux
●
perte des fonctionnalité spécifiques à Bash
– nécessite le droit d’exécution sur le script
#!/bin/bash#!/bin/bash

Executer un script
●
via la commande bash
– ne nécessite pas les droits d’exécution sur le fichier
– ni de shebang
●
Nous verrons plus loin les différentes options de bash
$ bash /chemin/vers/monscript.sh$ bash /chemin/vers/monscript.sh

Demo
GO !GO !

●
Comment exécuter un script bash
●
Écrire votre premier script bash.

Noël Macé
Expert Unix et FOSS
Variables

Plan
●
Introduction
●
Déclarer une variable
●
Substitution de variable
●
"Supprimer" une variable
●
Portée d'une variable
– Variables d'environnement
●
Paramètres positionnels
– Paramètres positionnels :
exemple
●
Autres paramètres spéciaux
●
Echappements
– Séquences d’échappement
– Guillemets et apostrophes
●
Extraction et soustraction
de chaîne

Introduction
● Aucun typage
– Toutes les variables sont considérées comme des chaînes de
caractères
– Mais peuvent également être évaluées comme des entiers
suivant le contexte
● Ne nécessite que la présence des chiffres dans sa valeur
– Permet une plus grande flexibilité
● Mais aussi certaines erreurs
● Attention à leur usage
– Toujours garder trace de leur usage / type
– Ne pas bâcler votre code

Déclarer une variable
● Sans typage, aucun besoin de déclaration spécifique
● une simple affectation suffit
 signe égal
 sans espace
● Exemple
● Attention ! le nom d'une variable est sensible à la casse
 ie. "mavariable" n'est pas la même variable que "MaVariable"
$ mavariable="Bonjour"

Substitution de variable
●
nécessite le caractère $ devant le nom
 Référence à la valeur de la variable
●
Exemple :
●
Syntaxe simplifiée de la suivante :
$ echo $mavariable
Bonjour !
$ echo ${mavariable}
Bonjour !

"Supprimer" une variable
●
Exemple
●
La valeur de la variable est alors nulle
– à ne pas confondre avec une variable contenant une chaîne
vide comme nous le verrons avec les tests
$ unset MaVariable

Portée d'une variable
●
Par défaut : locales
– n'est définie et disponible qu'à l'intérieur d'un bloc de code ou
d'une fonction
●
Variables d'environnement
– Accessible pour l'ensemble du processus et de ses fils
●
Un script ne peu donc exporter une variable vers l'environnement du shell
dont il est issu

Variables d'environnement
●
utiliser la commande export
●
Par convention, la référence est en majuscules
●
Pour "dé-exporter" une variable d'environnement
– ie : la repasser en local
●
Attention ! l'argument de la commande export est bien la référence (le nom)
de la variable
 pas sa valeur
 ne pas utiliser le caractère $
$ MESSAGE="Bonjour !"
$ export MESSAGE
$ export -n MESSAGE

Paramètres positionnels
●
variables locales
●
$1, $2, $3 … enregistrent les arguments passés à une
commande
– Doivent être indiquées avec les accolades au delà de 9
●
$0 enregistre la commande ayant permis de lancer le
programme
●
$* et $@ représentent tous les paramètres positionnels
●
$# enregistre le nombre d'arguments
●
etc …

Variables de paramètres: exemple
●
$0 est égale à "/bin/echo"
●
$1 à "-e"
●
$2 à "Bonjour !"
●
$* à "-e 'Bonjour !'"
●
$# à 2
$ /bin/echo –e "Bonjour !"

Autres paramètres spéciaux
● $- : options passées au script via la commande set
● $! : PID du dernier job executé en tâche de fond
● $? : code de sortie de la dernière commande executée
● $_ : dernier argument de la dernière commande effectuée
● $$ : PID du script lui même

Echappements
● Dire au shell d'interpréter le caractère suivant littéralement
– Grâce au caractère
– Ex : cd mon chemin renvoi une erreur
alors que cd mon chemin affichera “mon chemin”
● Peut permettre également l'effet inverse
– Donner un seul particulier à un caractère littéral
– Par exemple pour echo (option -e) ou sed

Séquences d’échappement
a alerte (avertisseur sonore)
b retour arrière (backspace)
c suppression du retour-chariot final
f saut de page
n nouvelle ligne
r retour-chariot
t tabulation horizontale
v tabulation verticale
backslash
nnn le caractère dont le code ASCII octal vaut nnn (un à trois chiffres)
xnnn le caractère dont le code ASCII hexadécimal vaut nnn (un à trois chiffres)

Guillemets et apostrophes
● Protéger (échapper) les caractères spéciaux
– Empêche leur interprétation pour le shell
– Permet de les “passer” à une fonction ou au autre programme
● Conseil : placer les substitutions de variables entre guillemets
– Pour éviter l'interprétation des caractères spéciaux
● Exemples : espaces, *, =, etc …
● La simple quote est plus stricte
– Tout caractère y est interprété littéralement
● Même $ et

Extraction et soustraction de chaîne
● Il est possible de directement manipuler les chaines de caractère
que contiennent les variables
– A noter : le premier caractère d'une chaine à pour indice 0
● ${#var} : longueur de la variable (en caractères)
● Extraction
– ${var:1} : sous-chaine à partir du second caractère
– ${var:2:4} : sous-chaine de 4 caractère à partir du 3ème
● Soustraction
– ${var#expr} : supprime la plus petite sous-chaine correspondant à
expr à partir du début de cette chaine
– ${var##expr} : supprime la plus grande sous-chaine correspondant à
expr à partir du début de cette chaine

●
Comment gérer les variables dans un script bash
– Déclaration
– Portée
– Substitution
●
Gestion des chaînes de caractère contenues dans les
variables
– Échappement
– Extraction et soustraction de chaînes

Noël Macé
Expert Unix et FOSS
États de sortie

Plan
●
Etats de sortie
●
Tester l'état de sortie d'un
programme
●
Sortie d'un script

États de sortie
● chaque programme ou fonction renvoi une valeur numérique
– entre 0 et 255
● 0 si il s'est bien déroulé (sauf cas particuliers)
– un chiffre différent de 0 indique donc un code d'erreur

Tester l'état de sortie d'un programme
● Nous pouvons évaluer l'état de sortie grâce à plusieurs
méthodes de test
– if/else
– enchaînements conditionnels
– case
– cf cours suivant
● $? permet également de récupérer la valeur de sortie du
dernier programme exécuté

Sortie d'un script
● Commande exit nnn
– où nnn est l'état de sortie à renvoyer
● Sans cette commande, c'est la valeur de sortie de la
dernière opération exécutée qui est renvoyée
– équivalent à exit ou encore exit $?

● Valeur de retour des scripts, programmes et fonctions
● Comment sortir d'un script en renvoyant une valeur.

Noël Macé
Expert Unix et FOSS
Tests

Plan
●
Test
●
Composition
●
Alternatives : si - sinon
●
Alternatives : Selon

Test
●
ou
●
Exemples
test expressiontest expression
[ expression ][ expression ]
[ 2 -lt 3 ][ 2 -lt 3 ]
[ "$var1" != "$var2" ][ "$var1" != "$var2" ]
[ -x /bin/bash ][ -x /bin/bash ]

Composition
●
séquentielle : cmd1 ; cmd2
●
parallèle : cmd1 & cmd2
●
sur erreur (ou) : cmd1 || cmd2
●
sur succès (et) : cmd1 && cmd2

Alternatives : si - sinon
if test
then
instructions
elif test
then
instructions
…
else
instructions
fi
if test
then
instructions
elif test
then
instructions
…
else
instructions
fi

Alternatives : Selon
case variable in
expr)
instructions
;;
…
esac
case variable in
expr)
instructions
;;
…
esac
●
Attention : case n'utilise pas d'expression régulière, mais du
pattern matching

●
Comment réaliser des tests en scripting Bash
– la commande test
– composition
– if ; then ; else
– case

Noël Macé
Expert Unix et FOSS
Opérations

Plan
●
Opérateurs arithmétiques
●
Affectation arithmétique
●
Opérateurs binaires
●
Opérateurs logiques
●
Changement de base
●
Evaluation arithmétique

Opérateurs arithmétiques
Opérateur Description
+ addition
- soustraction
/ division
* multiplication
** puissance (Bash 2.02 et supérieurs)
% modulo (reste de division entière)
Remarque : Bash ne comprend pas l'arithmétique à virgule
flottante, et interprète donc les nombres décimaux comme des
chaînes de caractère. Toute opération sera donc toujours entière.
Pour des calcules complexes, utilisez le language bc.

Affectation arithmétique
+= incrémentation
-= décrémentation
/= affectation par division
*= affectation par multiplication
%= affectation du reste de la division entière
Associe affectation et opérateur arithmétique pour modifier la valeur
d'une variable par le résultat d'une opération entre sa valeur précédente
et une constante.

Opérateurs binaires
<< décalage d'un bit à gauche (multiplication par 2)
>> décalage d'un bit à droite (division par 2)
& ET binaire
| OU (inclusif) binaire
~ NON binaire
^ XOR (ou exclusif) binaire
Tout ces opérateurs peuvent également être associés à l'affectation comme p
opérateurs arithmétiques.
Exemple : <<=

Opérateurs logiques
● la composition sur erreur (||) et la composition du réussite
(&&) peuvent également être utilisés comme des OU et ET
logiques.
● la commande ! permet d'inverser le retour d'une commande
– et donc d'agir comme un NON logique
– exemple :
! which /bin/bash

Changement de base
● base 10 par défaut
● si un nombre est précédé de 0 : base 8 (octal)
● si un nombre est précédé de 0x : base 16 (hexadécimal)
● Pour utiliser d'autres bases, précéder le nombre de
BASE#
– maximum : 64
– notation : 10 chiffres + 26 caractères minuscules + 26
caractères majuscules + @ + _

Evaluation arithmétique
●
commande let
●
double parenthèse
– apporte les mêmes fonctionnalités que let
– permet la manipulation de variables à la manière du C
●
Exemple
– permet une “substitution” d'évaluation arithmétique
(( var++ ))
let 'var = 2 + 3'
echo $(( 2 ** 3 ))

●
Comment effectuer des opérations en Bash
– opérateurs arithmétiques, binaires et logiques
– changement de base
– évaluation

Noël Macé
Expert Unix et FOSS
Boucles

Plan
●
Pour
●
Tant que
●
Contrôle de boucles

Pour
● la variable var prendra successivement la valeur de chacun des
éléments de la liste (séparés par des espaces)
● Exemple :
for var in liste
do
…
done
for var in liste
do
…
done
for couleur in rouge orange vert
do
echo $couleur
done
for couleur in rouge orange vert
do
echo $couleur
done

Pour
● Astuce : il est possible d'écrire un for à la manière du C grâce
à (( … ))
● Exemple :
● Remarque : (( … )) n'est pas ici considéré comme une évaluation
arithmétique mais comme un argument particulier de for
for (( i=1 ; i<=5 ; i++ ))
do
echo $i
done
for (( i=1 ; i<=5 ; i++ ))
do
echo $i
done

Tant que
while cmd
do
…
done
while cmd
do
…
done
●
tant que la commande cmd renverra 0
●
tant que la commande cmd ne renverra pas 0
●
cmd est généralement un test
while cmd
do
…
done
while cmd
do
…
done

Contrôle de boucles
● break : termine (sort de) la boucle
– break N : sortir de N niveaux de boucles (1 par défaut)
● continue : provoque un saut jusqu'à la prochaine itération de
la boucle
– continue N : provoque un saut jusqu'à la prochaine itération de
la boucle de N niveaux au dessus
● sans effectuer les itérations suivantes des boucles de niveau 1 à N-1

●
Comment effectuer des boucles en Bash
– Pour (for)
– Tant que (while et until)
●
Comment contrôler les itérations de ces boucles
– grâce à break et continue

Noël Macé
Expert Unix et FOSS
Substitution de
commande

Plan
●
Qu'est ce que c'est ?
●
Syntaxe
●
Exemples d'utilisation

Qu'est ce que c'est ?
● Ia substitution de commande permet de “brancher” la sortie
d'une commande dans un autre contexte
● Elle permet :
– l'affectation de cette sortie à une variable
– l'utilisation de cette sortie comme argument d'une autre
commande
– etc ...

Syntaxe
● On encadre pour cela la commande d'anti-quotes
– altgr + 7 sur les claviers Azerty
● Nouvelle syntaxe : $( … )
– à ne pas confondre avec l'évaluation arithmétique
– permet l'imbrication
– meilleure lisibilité
`ma commande``ma commande`

Exemples d'utilisation
● Comme argument
– d'un test
– de for
● Pour affectation
– du contenu d'un fichier
● la deuxième solution étant moins performante, puisque nécessitant un
nouveau processus
[ -x `which bash` ][ -x `which bash` ]
for i in `seq 1 100` ; dofor i in `seq 1 100` ; do
variable=`<fichier`variable=`<fichier` variable=`cat fichier`variable=`cat fichier`

●
Ce qu'est la subsitution de commande.
●
Comment la réaliser.
●
Quelques exemples d'utilisation courante.

Noël Macé
Expert Unix et FOSS
Documents
intégrés
Scripting avancé

Plan
●
Qu'est ce que c'est
●
Syntaxe
●
Exemples : édition de texte
●
Exemples : multi-lignes
●
Pour aller plus loin
●
Chaînes intégrées

Qu'est ce que c'est
● une solution simple et rapide pour envoyer une suite de
commandes à un programme interactif.
● permet donc de réaliser des “scripts” pour beaucoup de
programmes
– dont certains non prévus à cet usage
– cat, ex, echo, wall, etc …
● permet également une meilleure lisibilitée des entrées multi-
lignes

Syntaxe
● le délimiteur indique la fin des entrées
– il peut être n'importe quelle suite de caractères
– par convention, on utilisera généralement EOF
commande <<délimiteur
entrées …
délimiteur
commande <<délimiteur
entrées …
délimiteur

Exemples : édition de texte
● avec vim
● avec ex
vim monfichier <<xxxLIMITExxx
i
ligne 1
ligne 2
^[
:wq !
xxxLIMITExxx
vim monfichier <<xxxLIMITExxx
i
ligne 1
ligne 2
^[
:wq !
xxxLIMITExxx
ex $mot <<EOF
:%s/$ORIGINAL/$REMPLACEMENT/g
:wq
EOF
ex $mot <<EOF
:%s/$ORIGINAL/$REMPLACEMENT/g
:wq
EOF

Exemples : multi-lignes
cat <<-EOF
-------------------------------------
Ceci est la ligne 1 du message.
Ceci est la dernière ligne du message.
-------------------------------------
EOF
cat <<-EOF
-------------------------------------
Ceci est la dernière ligne du message.
-------------------------------------
EOF
●
Astuce : vous pouvez supprimer les tabulations en début de
ligne d'un document intégré en précédent le délimiteur du
signe '-'

Pour aller plus loin
● Les documents intégrés supportent la substitution de
variable
● Il est possible de rediriger la sortie de la commande appelée
● On peu réaliser un bloc de commentaire Bash en effectuant
un document intégré sur la commande ':'
commande > fichier <<délimiteurcommande > fichier <<délimiteur

Chaînes intégrées
● forme minimale de document intégré
– permet de n'envoyer qu'un chaîne simple
● syntaxe
● trés utile pour tester votre script
commande <<< chainecommande <<< chaine
read -p "entrez un nombre" nbr <<< "22"read -p "entrez un nombre" nbr <<< "22"

● Comment "scripter" n'importe quel programme grâce aux
documents intégrés.
– syntaxe
– usages
– fonctions avancées
● Comment envoyer une valeur à n'importe quel programme
grâce aux chaînes intégrées.

Noël Macé
Expert Unix et FOSS
Sous-shells et
shells restreints
Scripting avancé

Plan
●
Sous-shell
– Syntaxe
– A savoir
●
Shell restreint
– Actions essentielles
désactivées

Sous-shell
● permet de lancer un processus fils de notre script
– qui exécutera son propre "flot" de commandes
– dont les variables ne sont pas visibles du shell père
● chaque commande externe appelé dans notre shell lance
son propre processus
– ce n'est pas le cas des commandes internes (qui demandent
donc moins de ressources)

Syntaxe
● encadrer une série de commandes par des parenthèses
(
cmd1
cmd2
cmd3
)
(
cmd1
cmd2
cmd3
)

A savoir
● La commande exit ne termine que le processus courant
– si elle est réalisée dans un sous-shell, elle ne mettra donc fin
qu'à celui-ci, et non au script bash lui même
● Une commande cd effectuée au sain d'un sous-shell n'a
d'impacte que sur celui-ci
● Il est possible d'executer deux sous shells en parallèle en les
séparant par un '&' (sans retour à la ligne)

Shell restreint
● mode spécial
● désactive certaines commandes
– minimise les risques
– en limitant les droits
● Pour passer en mode restreint :
ouset -rset -r set --restrictedset --restricted

Actions essentielles désactivées
● changement de répertoire de travail (cd)
● changement de valeur des variables d'environnement
suivantes : $PATH, $SHELL, $BASH_ENV, $ENV.
● lecture et remplacement d'options d'environnement de shell
$SHELLOPTS.
● redirection de sortie.
● appel à des commandes contenant un ou plusieurs /.
● substituer un processus différent de celui du shell (exec)
● sortir du mode restreint au sain du script

●
Comment lancer une série d'opération au sain d'un nouveau
processus (sous shell).
– les principales utilitées de cette démarche
●
Comment limiter les fonctionnalités d'un script grâce au
shell restreint.

Noël Macé
Expert Unix et FOSS
Fonctions
Scripting avancé

Plan
●
Fonctions
– Syntaxe
– A savoir
●
Aliases

Fonctions
● sembables aux fonctions des autres langages
– bien que très limitées
– sous-routine implémentant un certain nombre d'opérations
dans un but précis
● A utiliser pour remplacer toute suite d'opération répétées
plusieurs fois au cours d'un script

Syntaxe
● classique bash
● "C-like"
function nom_fonction {
…
}
function nom_fonction {
…
}
nom_fonction()
{
…
}
nom_fonction()
{
…
}

A savoir
● Une fonction ne peu être vide
● Elles peuvent prendre des arguments de la même manière
qu'un script
– pas entre les parenthèses !
– accessibles via $1 $2 etc … au sain de la fonction
● Comme tout programme, elle renvoie également un code de
sortie

Aliases
● simple raccourci pour une longue séquence de commandes
– déclaré grâce à la commande alias
– exemple
– pour supprimer un alias : commande unalias
● particulièrement utile en mode interactif
– cd bashrc
● très peu en scripting, car très limité
alias la="ls -la"
la
alias la="ls -la"
la

●
Comment écrire des fonctions en Bash.
●
Comment mettre en place un alias.

Noël Macé
Expert Unix et FOSS
Listes et tableaux
Scripting avancé

Plan
●
Affectation et substitution
●
A savoir

Affectation et substitution
● Affectation
– de l'ensemble d'un tableau
– d'un élément d'un tableau
● Substitution d'un élément d'un tableau
– toutes les opérations de chaîne déjà connues sur les variables sont
également réalisables
– exemple
tableau[xx]="valeur"tableau[xx]="valeur"
tableau=(val1 val2 val3)tableau=(val1 val2 val3)
${#tableau[@]} # "longueur" (nombre d'éléments) d'un tableau${#tableau[@]} # "longueur" (nombre d'éléments) d'un tableau
tableau[xx]="valeur"tableau[xx]="valeur"

A savoir
● le premier indice d'un tableau est 0
● ${tableau} référence le premier élément d'un tableau, non
le tableau en entier
● un tableau bash n'a pas de taille fixe. Il s'apperente donc
plus à une liste

●
Comment déclarer est manipuler des tableaux (ou listes) en
scripting bash.

Noël Macé
Expert Unix et FOSS
Débogage
Scripting avancé

Plan
●
Introduction
●
Suivre l’exécution de votre script
●
Quelques recommandations

Introduction
● Pas de débogueur intégré
● Des messages d'erreurs souvent obscures
● Nous allons donc voir ici quelques astuces pour déboguer
votre script.

Suivre l'execution de votre script
● Effectuer des affichages (echo) aux points clés
– Encore mieux : ne le faire qu'en mode débug
● Filter les sorties des commandes clés grâce à tee
● Utiliser la variable LINENO
– prend automatiquement la valeur de la ligne du script où elle est appelée
### debecho (debug-echo) par Stefano Falsetto ###
### Affichera les paramètres seulement si DEBUG est configuré. ###
debecho () {
if [ ! -z "$DEBUG" ]; then
echo "$1" >&2
# ^^^ vers stderr
fi
}
### debecho (debug-echo) par Stefano Falsetto ###
### Affichera les paramètres seulement si DEBUG est configuré. ###
debecho () {
if [ ! -z "$DEBUG" ]; then
echo "$1" >&2
# ^^^ vers stderr
fi
}

Quelques recommandations
● Tester chaque variables et conditions aux points critiques
– On peu pour cela créer une fonction assert, inspirée du C
● Qui sortira du script avec un message d'erreur spécifique en cas de non respect d'un
condition donnée
● Exemple : tester si une variable est un nombre
– ici, le premier argument de la fonction assert sera bien entendu testé via la
commande test pour un if, qui exécutera un exit en cas de non respect de cette
condition
● Intercepter le signal EXIT avec trap afin d'afficher un message
personnalisé en cas d'arrêt du script
– comme par exemple pour afficher les valeurs de différentes variable
assert "$var1"' =~ '^[0-9]+$''assert "$var1"' =~ '^[0-9]+$''
trap 'echo variables : var1 = $var1 / var2 = $var2' EXITtrap 'echo variables : var1 = $var1 / var2 = $var2' EXIT

●
Comment déboguer un script bash.

Noël Macé
Expert Unix et FOSS
Options de Bash
Scripting avancé

Plan
●
Introduction
●
Options utiles au débogage
●
Autres options utiles
●
Pour aller plus loins

Introduction
● Permettent de modifier le comportement du shell
● Activées soit
– au lancement du script, via l'appel de l'interpréteur
● shebang ou ligne de commande
– en cours d'execution, via la commande set
● activer une option : set -o nom ou set -abrévation
● désactiver une option : set +o option ou set +raccourci
set -o verboseset -o verbose set -vset -v

Options utiles au débogage
Abréviation Nom Description
-n noexec Teste les erreurs de syntaxe du script sans
l'exécuter.
-v verbose Affiche chaque commande avant de
l'exécuter.
-x xtrace Développe et affiche chaque commande
avant de l'exécuter.

Autres options utiles
Abréviation Nom Description
-C noclobber Empêche tout écrassement de fichier pré-
existant avec les opérateurs >, >& et <>.
Surpassable par l'usage de >|
-a allexport Exporter toutes les variables et fonctions
modifiées ou créés.
-f noglob Désactive le globbing (développement des
chemins).
-r restricted Mode restreint.
-u nounset Empêche l'usage de variable non définie
(erreur et sortie du script).

Pour aller plus loins
● Bien d'autres comportements facultatifs sont (dés)activables
dans vos scripts
– grâce à la commande shopt
– Options
● -s var : activer
● -d var : désactiver
● Exemple : rendre case insensible à la casse
shopt -s nocasematchshopt -s nocasematch
shopt [-pqsu] [-o] [nom_opt ...]shopt [-pqsu] [-o] [nom_opt ...]

●
Comment modifier le comportement de notre script
– en activant / désactivant certaines fonctionnalitées du shell
– grâce aux options de la commande bash, à set et à shopt

Noël Macé
Expert Unix et FOSS
Conclusion
Conclusion

●
Merci à tous et à bientôt.

Alphorm.com Formation Scripting Bash avancé pour GNU/Linux

Contenu connexe

Tendances (20)

En vedette (20)

Similaire à Alphorm.com Formation Scripting Bash avancé pour GNU/Linux (18)

Plus de Alphorm (20)

Alphorm.com Formation Scripting Bash avancé pour GNU/Linux