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 FOSSContact : [email protected]

Présentation de la formation

Introduction

Site : http://www.alphorm.comBlog : http://www.alphorm.com/blogForum : http://www.alphorm.com/forum

http://www.alphorm.com/

http://www.alphorm.com/blog


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é

● [email protected]

● 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 …

http://fr.viadeo.com/fr/profile/noel.mace

http://fr.viadeo.com/fr/profile/noel.mace

http://vizualize.me/noelmace

http://vizualize.me/noelmace

http://noelmace.com/


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 formationBases

● 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

http://www.cygwin.com/

http://support.apple.com/kb/ta27005


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

http://www.tldp.org/guides.html

http://abs.traduc.org/


Ce qu’on a couvert● Introduction de ce cours

– formateur

– les outils à utiliser

– ce que nous verrons



Premiers pasBases 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 !


Ce qu’on a couvert● Comment exécuter un script bash

● Écrire votre premier script bash.



VariablesBases du scripting Bash








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 $mavariableBonjour !

$ 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 erreuralors 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


Ce qu’on a couvert● 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



États de sortieBases du scripting Bash








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 $?


Ce qu’on a couvert● Valeur de retour des scripts, programmes et fonctions

● Comment sortir d'un script en renvoyant une valeur.



TestsBases du scripting Bash








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 testthen

instructionselif testthen

instructions…

else

instructions

fi

if testthen

instructionselif testthen

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


Ce qu’on a couvert● Comment réaliser des tests en scripting Bash

– la commande test

– composition

– if ; then ; else

– case



OpérationsBases du scripting Bash








Plan● Opérateurs arithmétiques

● Affectation arithmétique

● Opérateurs binaires

● Opérateurs logiques

● Changement de base

● Evaluation arithmétique


Opérateurs arithmétiquesOpé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.

http://www.delafond.org/traducmanfr/man/man1/bc.1.html


Affectation arithmétique

Opérateur Description

+= 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 valeurd'une variable par le résultat d'une opération entre sa valeur précédenteet une constante.


Opérateurs binairesOpérateur Description

<< 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 pour les 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 ))


Ce qu’on a couvert● Comment effectuer des opérations en Bash

– opérateurs arithmétiques, binaires et logiques

– changement de base

– évaluation



BouclesBases du scripting Bash








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 listedo

…done

for var in listedo

…done

for couleur in rouge orange vertdo

echo $couleurdone

for couleur in rouge orange vertdo

echo $couleurdone


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 $idone

for (( i=1 ; i<=5 ; i++ ))do

echo $idone


Tant que

while cmddo

…done

while cmddo

…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 cmddo

…done

while cmddo

…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


Ce qu’on a couvert● 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



Substitution de commande

Bases du scripting Bash








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’on a couvert● Ce qu'est la subsitution de commande.

● Comment la réaliser.

● Quelques exemples d'utilisation courante.



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élimiteurentrées …délimiteur

commande <<délimiteurentrées …délimiteur


Exemples : édition de texte● avec vim

● avec ex

vim monfichier <<xxxLIMITExxxiligne 1ligne 2^[:wq !xxxLIMITExxx

vim monfichier <<xxxLIMITExxxiligne 1ligne 2^[:wq !xxxLIMITExxx

ex $mot <<EOF :%s/$ORIGINAL/$REMPLACEMENT/g :wqEOF

ex $mot <<EOF :%s/$ORIGINAL/$REMPLACEMENT/g :wqEOF


Exemples : multi-lignes

cat <<-EOF-------------------------------------Ceci est la ligne 1 du message.Ceci est la ligne 2 du message.Ceci est la ligne 3 du message.Ceci est la ligne 4 du message.Ceci est la dernière ligne du message.-------------------------------------

EOF

cat <<-EOF-------------------------------------Ceci est la ligne 1 du message.Ceci est la ligne 2 du message.Ceci est la ligne 3 du message.Ceci est la ligne 4 du message.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"


Ce qu’on a couvert● 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.



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

(cmd1cmd2cmd3)

(cmd1cmd2cmd3)


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


Ce qu’on a couvert● 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.



FonctionsScripting 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"laalias la="ls -la"la


Ce qu’on a couvert● Comment écrire des fonctions en Bash.

● Comment mettre en place un alias.



Listes et tableauxScripting 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


Ce qu’on a couvert● Comment déclarer est manipuler des tableaux (ou listes) en

scripting bash.



DébogageScripting avancé









● 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" ]; thenecho "$1" >&2# ^^^ vers stderrfi}

### debecho (debug-echo) par Stefano Falsetto ###### Affichera les paramètres seulement si DEBUG est configuré. ###debecho () {if [ ! -z "$DEBUG" ]; thenecho "$1" >&2# ^^^ vers stderrfi}


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


Ce qu’on a couvert● Comment déboguer un script bash.



Options de BashScripting avancé









● 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ébogageAbré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 utilesAbré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 ...]


Ce qu’on a couvert● 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



ConclusionConclusion








Ce qu’on a couvert● Merci à tous et à bientôt.

alphorm.com formation scripting bash avancé pour gnu/linux

Technology