Présentation

Exécuter un script
Les différents types de shells
Les variables
Les tableaux
Les arguments en ligne de commande
Les structures de contrôle
La commande test
La structure : `if`
La structure `while`
La structure `case`
La structure for
Les fonctions
Exemples et exercices
L'art d'écrire un script
Liens

programmation, script, shell, console

Introduction aux scripts shell

Présentation
Un script shell permet d'automatiser une série d'opérations. Il se présente sous la forme d'un fichier
contenant une ou plusieurs commandes qui seront exécutées de manière séquentielle.

Écrire un script

Si vous voulez écrire un programme sh, vous avez deux possibilités :

soit vous tapez dans un shell toutes les commandes

ou alors vous rassemblez toutes les instructions copiées par ci par là dans un fichier sh.

À titre d'exemple, saisissez ces quelques lignes dans votre éditeur préféré :

#!/bin/bash
# indique au système que l'argument qui suit est le programme utilisé pour exécuter ce
fichier.
# En cas général les "#" servent à faire des commentaires comme ici

1 sur 15 14/03/2011 00:58

tutoriel:script_shell - Documentation Ubuntu Francophone [Link]

echo Mon premier script

echo Liste des fichiers :
ls -la

exit 0

Le résultat de ce script est d'écrire à l'écran « Mon premier script », puis en dessous « Liste des
fichiers : », et enfin la liste des fichiers avec la commande `ls -la`.

Comme vous l'avez compris, la commande `echo` sert à écrire quelque chose à l'écran.

Cependant il vous faudra faire extrêmement attention à tous ces morceaux de code. Leur utilisation
sans connaissance de votre part pourrait vous faire perdre de précieuses données.
« Mais comment on exécute ce script ? »

Et bien il suffit de se placer dans le dossier où est le script, et de lancer

bash nom_du_script

Si vous voulez l'exécuter avec « . », il faut le rendre exécutable avec `chmod`. Pour ceci tapez dans le
shell la commande qui suit :

chmod +x nom_du_script

Puis vous pouvez exécuter le script en faisant :

./nom_du_script

Le fait de rendre le script exécutable permet aussi de l'exécuter en double cliquant sur son icône
depuis le gestionnaire de fichier.

Exécuter un script - Modifier le PATH

Il peut être intéressant d'ajouter un répertoire au "PATH" pour pouvoir exécuter ses scripts sans avoir
à se placer dans le bon dossier. Je m'explique, quand vous tapez une commande ("ls" par exemple), le
shell regarde dans le PATH qui lui indique où chercher le code de la commande.

Pour voir à quoi ressemble votre PATH, tapez dans votre console:

echo $PATH

Cette commande chez moi donnait initialement :

/usr/local/bin:/usr/bin:/bin:/usr/bin/X11:/usr/games

C'est à dire que le shell va aller voir si la définition de la commande tapée ("ls" pour continuer sur le
même exemple) se trouve dans /usr/local/bin puis dans /usr/bin… jusqu'à ce qu'il la trouve.

Ajouter un répertoire au PATH peut donc être très pratique. En effet, chez moi, j'ai créé un dossier
contenant mes scripts bash utilisés en console : /home/user/scripts_console. Pour pouvoir utiliser
mes scripts en tapant directement leur nom (sans le "./") depuis n'importe quel répertoire de mon

2 sur 15 14/03/2011 00:58

tutoriel:script_shell - Documentation Ubuntu Francophone [Link]

ordinateur, il me suffit d'indiquer au shell de chercher aussi dans /home/user/scripts_console en

l'ajoutant au PATH. Pour ceci, il suffit de faire :

export PATH=$PATH:/home/user/scripts_console

La commande

echo $PATH

retourne maintenant

/usr/local/bin:/usr/bin:/bin:/usr/bin/X11:/usr/games:/home/user/scripts_console

et je peux lancer le script appelé "monScript" situé dans "/home/user/scripts_console" en tapant

directement

monScript

Cette procédure est pour une modification temporaire du $PATH, qui sera effacée à la fin de la session.

Pour rendre la modification permanente, ajouter la commande dans le fichier caché .bashrc se

trouvant dans votre dossier personnel.

Comme vous avez sûrement dû l'entendre, il existe différents types de shells ou en bon français,

interpréteurs de commandes :

dash : shell par défaut utilisé pour exécuter les scripts sur Ubuntu ;
bash (Bourne Again SHell) : conçu par le projet GNU, shell linux ; le shell par défaut sur Ubuntu
;
rbash : un shell restreint basé sur bash. Il existe de nombreuses variantes de bash ;
csh, tcsh : shells C, créés par Bill Joy de Berkeley ;
zsh, shell C écrit par Paul Falstad ;
ksh (⇔ ksh88 sur Solaris et equivaut a ksh93 sur les autres UNIX/Linux [Link] shell History):
shells korn écrits par David Korn, pdksh (Public Domain Korn Shell ⇔ ksh88) ;
rc : shell C, lui aussi conçu par le projet GNU ;
tclsh : shell utilisant Tcl ;
wish : shell utilisant Tk ;

Il existe bien entendu beaucoup d'autres types de shells.

La commande sh est en fait un lien symbolique vers l'interpréteur de commandes par défaut :
/bin/dash.

Les variables
Pour appeller une variable, par exemple HOME, il suffit de mettre un $ devant, par exemple :

echo $HOME

Ce petit code va afficher la variable HOME à l'écran.

Pour affecter une valeur à une variable c'est très simple.

MSG=salut

3 sur 15 14/03/2011 00:58

tutoriel:script_shell - Documentation Ubuntu Francophone [Link]

echo $MSG

Il existe des variables un peu spéciales

Nom fonction

$* contient tous les arguments passés à la fonction

$# contient le nombre d'argument

$? contient le code de retour de la dernière opération

$0 contient le nom du script

$n contient l'argument n, n étant un nombre

Exemple : créer le fichier [Link] avec le contenu qui suit

#!/bin/bash

echo "Nombre d'argument "$#

echo "Les arguments sont "$*

echo "Le second argument est "$2

echo "Et le code de retour du dernier echo est "$?

Lancez ce script avec un ou plusieurs arguments et vous aurez

./[Link] 1 2 3
Nombre d'argument 3
Les arguments sont 1 2 3
Le second argument est 2
Et le code de retour du dernier echo est 0

Pour déclarer un tableau, plusieurs méthodes :

Premiere méthode (compatible bash, zsh, et ksh93 mais pas ksh88)

tab=("John Smith" "Jane Doe")

ou bien

tab[0]=John Smith
tab[1]=Jane Doe

Pour compter le nombre d'éléments du tableau :

len=${#tab[*]}

Pour afficher un élément :

echo ${tab[1]}

Pour afficher tous les éléments :

4 sur 15 14/03/2011 00:58

tutoriel:script_shell - Documentation Ubuntu Francophone [Link]

echo ${tab[@]}

ou bien (en bash ou en ksh93 mais pas en ksh88):

for i in ${!tab[@]}; do echo ${tab[i]}; done

ou encore ( C style )

for (( i=0; i < ${#tab[@]}; i++ )); do echo ${tab[i]}; done

Les arguments en ligne de commande

Pour passer des arguments en ligne de commande c'est encore une fois très simple. Chaque argument
est numéroté et ensuite on l'appelle par son numéro :

./[Link] powa noplay

Voici notre [Link]

#!/bin/sh
echo $2 echo $1

Notez que $0 est le nom du fichier.

Les structures de contrôle

La commande test existe sous tous les unix, elle permet de faire un test et de renvoyer 0 si tout s'est
bien passé ou 1 en cas d'erreur.

En mode console, faites man test pour connaître tous les opérateurs, en voici quelques uns :

Opérateurs de test

Syntaxe Fonction réalisée

-e fichier renvoie 0 si fichier existe.

-d fichier renvoie 0 si fichier existe et est un répertoire.

-f fichier renvoie 0 si fichier existe et est un fichier 'normal'.

-w fichier renvoie 0 si fichier existe et est en écriture.

-x fichier renvoie 0 si fichier existe et est exécutable.

f1 -nt f2 renvoie 0 si f1 est plus récent que f2.

f1 -ot f2 renvoie 0 si f1 est plus vieux que f2.

Opérateurs de comparaison numériques

Syntaxe Fonction réalisée

$A -lt 5 renvoie 0 si $A est inférieur à 5

5 sur 15 14/03/2011 00:58

tutoriel:script_shell - Documentation Ubuntu Francophone [Link]

$A -gt 5 renvoie 0 si $A est supérieur à 5

$A -eq 5 renvoie 0 si $A est égal à 5

Les crochets

On peut raccourcir la commande test par des crochets. Exemple :

test -f /etc/passwd

echo $?

[ -f /etc/passwd ]

echo $?

Affichera la valeur 0 : ce fichier existe, 1 dans le cas où le fichier /etc/passwd n'existe pas. Sous unix,
le code de retour est par convention et en général 0 s'il n'y a aucune erreur et différent de 0 dans les
autres cas

La syntaxe la plus appropriée dans de la programmation shell moderne est le double crochet :

[[ -f /etc/passwd ]]

Cela gère bien mieux les problèmes d'espace dans les noms de fichiers, les erreurs etc… C'est une
structure propre à bash (ksh, ?) qui est le shell par défaut dans la plupart des distributions Linux, et de
Ubuntu en particulier. On garde en général des simples crochets pour les scripts shell qui doivent être
à tout prix POSIX. ( Utilisation sur des Unix sans installation préalables de bash, comme BSD, Solaris…
)

Les opérateurs logiques

Il y a en 3 :

le et logique : -a
le ou logique : -o
le non logique : !

Exemple :

echo "renverra 0 si les deux expressions sont vraies"

test expr 1 -a expr2

[ expr1 -a expr2 ]

Table de vérité de « -o »

Comparaison Résultat Calcul

0 ou 0 0 0+0=0

0 ou 1 1 0+1=1

1 ou 0 1 1+0=1

6 sur 15 14/03/2011 00:58

tutoriel:script_shell - Documentation Ubuntu Francophone [Link]

1 ou 1 1 1+1=1

Dès que l'une des deux assertions est vérifiée, la condition globale l'est aussi.

Table de vérité de « -a »

Comparaison Résultat Calcul

0 et 0 0 0×0=0

0 et 1 0 0×1=0

1 et 0 0 1×0=0

1 et 1 1 1×1=1

Les deux assertions doivent être vérifiées pour que la condition le soit aussi.

Exemple plus complet :

#!/bin/sh

echo -n "Entrez un nom de fichier: "

read file
if [ -e "$file" ]; then
{
echo "Le fichier existe!"
}
else
{
echo "Le fichier n'existe pas, du moins n'est pas dans le répertoire d'exécution du
script"
}
fi
exit 0

La seule chose qui prête à confusion est que l'on vérifie seulement si le fichier « file » est dans le
répertoire où le script à été exécuté.

Avant de commencer à faire des scripts de 1000 lignes, il serait intéressant de voir comment se servir
des variables, et des instructions if, then, elif, else, fi. Cela permet par exemple de faire réagir le
script de manière différente, selon la réponse de l'utilisateur à une question.

En bash, les variables ne se déclarent généralement pas avant leur utilisation, on les utilise
directement et elles sont créées lors de sa première mise en œuvre.

Pour pouvoir voir la valeur d'une variable il faut faire précéder son nom du caractère « $ ».

Exemple

#!/bin/sh
echo -n "Voulez-vous voir la liste des fichiers Y/N : "
read ouinon
if [ "$ouinon" = "y" ] || [ "$ouinon" = "Y" ]; then
{

7 sur 15 14/03/2011 00:58

tutoriel:script_shell - Documentation Ubuntu Francophone [Link]

echo "Liste des fichiers :"

ls -la
}
elif [ "$ouinon" = "n" ] || [ "$ouinon" = "N" ]; then
{
echo "Ok, bye! "
}
else
{
echo "Il faut taper Y ou N!! Pas $ouinon"
}
fi

Explication

Ce script peut paraître simple à première vue mais certaines choses prêtent à confusion et ont besoin
d'être expliquées en détail.

Tout abord, le `echo -n` permet de laisser le curseur sur la même ligne, ce qui permet à l'utilisateur
de taper la réponse après la question (question d'esthétique).

L'instruction `read` permet d'affecter une valeur ou un caractère à une variable quelconque, en la
demandant à l'utilisateur.

En bash, la variable est considérée comme une chaîne même si celle-ci contient une valeur
numérique, et les majuscules sont considérées différentes des minuscules, $M ≠ $m.
Ensuite vient l'instruction conditionnelle `if`. Elle est suivie d'un « [ » pour délimiter la condition. La
condition doit bien être séparée des crochets par un espace ! Attention, la variable est mise entre
guillemets car dans le cas où la variable est vide, le shell ne retourne pas d'erreur, mais en cas
contraire, l'erreur produite ressemble à :

[: =: unaryoperator expected

L'opérateur `||` signifie exécute la commande suivante si la commande précédente n'a pas renvoyé 0.
Il existe aussi l'opérateur && qui exécute la commande suivante si commande précédente a renvoyé 0,
et enfin ; qui exécute l'opération suivante dans tous les cas.

Exemple si le répertoire toto n' existe pas , le créer

[ ! -d /tmp/toto ] && mkdir /tmp/toto

[ -d /tmp/toto ] || mkdir /tmp/toto
test ! -d /tmp/toto && mkdir /tmp/toto
rm -rf /tmp/toto;mkdir /tmp/toto

Les « { » servent à bien délimiter le bloc d'instructions suivant le `then`, est une commande et donc
si elle est sur la même ligne que le `if` les deux commandes doivent être séparées par un `;`

Ensuite, `elif` sert à exécuter une autre série d'instructions, si la condition décrite par `if` n'est pas
respectée, et si celle fournie après ce `elif` l'est.

Enfin, `else` sert à exécuter un bloc si les deux conditions précédentes ne sont pas respectées (ah les
jeunes, ils respectent plus rien de nos jours ).

8 sur 15 14/03/2011 00:58

tutoriel:script_shell - Documentation Ubuntu Francophone [Link]

`fi` indique la fin de notre bloc d'instructions `if`, ce qui permet de voir où se termine toute notre
portion de code soumise à une condition.

Quelques petites commandes pratiques :

sh -n nom_du_fichier

ou

bash -x chemin_du_fichier

Cette commande vérifie la syntaxe de toutes les commandes du script, pratique quand on débute et
pour les codes volumineux.

sh -u nom_du_fichier

Celle-ci sert à montrer les variables qui n'ont pas été utilisées pendant l'exécution du programme.

Voici le tableau des opérateurs de comparaison, ceux-ci peuvent s'avérer utiles pour

diverses raisons, nous verrons un peu plus loin un exemple.

La commande while exécute ce qu'il y a dans son bloc tant que la condition est respectée :

#!/bin/sh

cmpt=1
cm=3
echo -n "Mot de passe : "
read mdp

while [ "$mdp" != "ubuntu" ] && [ "$cmpt" != 4 ]

do
echo -n "Mauvais mot de passe, plus que "$cm" chance(s): "
read mdp
cmpt=$(($cmpt+1))
cm=$(($cm-1))
done
echo "Non mais, le brute-force est interdit en France !!"
exit 0

On retrouve des choses déjà abordées avec `if`. Le `&&` sert à symboliser un "et", cela implique que

deux conditions sont à respecter. Le `do` sert à exécuter ce qui suit si la condition est respectée. Si

elle ne l'est pas, cela saute tout le bloc (jusqu'à `done`). Vous allez dire :

Mais qu'est-ce que c'est ce truc avec cette syntaxe bizarre au milieu ?

Cette partie du code sert tout simplement à réaliser une opération arithmétique. A chaque passage,

'cmpt = cmpt+1' et 'cm = cm-1'.

`while` permet de faire exécuter la portion de code un nombre déterminé de fois. La commande

`until` fait la même chose que la commande `while` mais en inversant. C'est-à-dire qu'elle exécute le

bloc jusqu'à ce que la condition soit vraie, donc elle s'emploie exactement comme la commande

`while`.

Regardons la syntaxe de cette commande, qui n'est pas une des plus simples :

9 sur 15 14/03/2011 00:58

tutoriel:script_shell - Documentation Ubuntu Francophone [Link]

case variable in
modèle [ | modèle] ...) instructions;;
modèle [ | modèle] ...) instructions;;
...
esac

Cela peut paraître complexe mais on s'y habitue quand on l'utilise.

Mais à quoi sert cette commande ?

Elle sert à comparer le contenu d'une variable à des modèles différents. Les ;; sont indipensables car il
est possible de placer plusieurs instructions entre un modèle et le suivant. Les ;; servent donc à
identifier clairement la fin d'une instruction et le début du modèle suivant.

Exemple :

#!/bin/sh

echo -n "Etes-vous fatigué ? "

read on

case "$on" in
oui | o | O | Oui | OUI ) echo "Allez faire du café !";;
non | n | N | Non | NON ) echo "Programmez !";;
* ) echo "Ah bon ?";;
esac
exit 0

La seule chose qui mérite vraiment d'être expliquée est sans doute `* )`. Cela indique tout
simplement l'action à exécuter si la réponse donnée n'est aucune de celles données précédemment.

Il existe aussi plusieurs structures pour les modèles, telles que :

case "$truc....." in
[nN] *) echo "Blablabla...";;
n* | N* ) echo "Bla....";;

Pour vous donner une idée précise de ce que peuvent réaliser toutes ces instructions, voici un petit
script censé refaire un prompt avec quelques commandes basiques :

#!/bin/bash

clear

echo

echo "#################### Script ############################"

echo

echo "#############################"

echo -n "LOGIN: "

10 sur 15 14/03/2011 00:58

tutoriel:script_shell - Documentation Ubuntu Francophone [Link]

read login
echo -n "Hôte: "
read hote
echo "#############################"
echo
echo "### Pour l'aide tapez help ###"
echo
while [ 1 ]; do # permet une boucle infinie
echo -n ""$login"@"$hote"$ " # qui s'arrête avec break
read reps

case $reps in
help | hlp )
echo "A propos de TS --> about"
echo "ls --> liste les fichiers"
echo "rm --> détruit un fichier (guidé)"
echo "rmd --> efface un dossier (guidé)"
echo "noyau --> version du noyau Linux"
echo "connect --> savoir qui s'est connecté dernièrement";;
ls )
ls -la;;
rm )
echo -n "Quel fichier voulez-vous effacer : "
read eff
rm -f $eff;;
rmd | rmdir )
echo -n "Quel répertoire voulez-vous effacer : "
read eff
rm -r $eff;;
noyau | "uname -r" )
uname -r;;
connect )
last;;
about | --v | vers )
echo "Script simple pour l'initiation aux scripts shell";;
quit | "exit" )
echo Au revoir!!
break;;
* )
echo "Commande inconnue";;
esac
done
exit 0

Remarque

Comme vous l'avez remarqué, l'indentation a une place importante dans ce programme. En effet,
celui-ci est plus lisible et cela évite aussi de faire des erreurs. C'est pourquoi il est préférable de bien
structurer le code que vous écrivez.

L'instruction `for` exécute ce qui est dans son bloc un nombre de fois prédéfini. Sa syntaxe est la
suivante :

for variable in valeurs; do

11 sur 15 14/03/2011 00:58

tutoriel:script_shell - Documentation Ubuntu Francophone [Link]

instructions

done

Comme vous l'aurez sans doute remarqué, on assigne une valeur différente à variable à chaque
itération. On peut aussi très facilement utiliser des fichiers comme "valeur". Rien ne vaut un exemple
:

#!/bin/sh
for var in *.txt; do
echo "$var"
done
exit 0

On peut voir une syntaxe un peu particulière :

$(sort *.txt)

. Ceci sert à indiquer que ce qui est entre les parenthèses est une commande à exécuter.

On peut aussi utiliser cette instruction simplement avec des nombres, cela permet de connaître le
nombre d'itérations :

#!/bin/sh
for var in 1 2 3 4 5 6 7 8 9; do
echo $var
done
exit 0

On peut très bien aussi utiliser d'autres types de variables, comme par exemple des chaînes de
caractères :

#!/bin/sh
for var in Ubuntu Breezy 5.10; do
echo $var
done
exit 0

Il faut quand même faire attention au fait que Ubuntu Breezy 5.10 est différent de "Ubuntu Breezy
5.10" dans ce cas. En effet, tous les mots placés entre "" sont considérés comme faisant partie de la
même chaîne de caractères. Sans les "", sh considèrera qu'il y a une liste de trois chaînes de
caractères.

Les fonctions
Les fonctions sont indispensables pour bien structurer un programme mais aussi pouvoir le simplifier,
créer une tâche, la rappeler… Voici la syntaxe générale de 'déclaration' d'une fonction :

nom_fonction(){
instructions
}

Cette partie ne fait rien en elle même, elle dit juste que quand on appellera nom_fonction, elle fera
instruction. Pour appeler une fonction (qui ne possède pas d'argument, voir plus loin) rien de plus

12 sur 15 14/03/2011 00:58

tutoriel:script_shell - Documentation Ubuntu Francophone [Link]

simple :

nom_fonction

Rien ne vaut un petit exemple :

#!/bin/sh

#Definition de ma fonction
mafonction(){
echo 'La liste des fichiers de ce répertoire'
ls -l
}
#fin de la définition de ma fonction

echo 'Vous allez voir la liste des fichiers de ce répertoire:'

mafonction #appel de ma fonction
exit 0

Comme vous l'avez sans doute remarqué, quand on appelle la fonction, on exécute simplement ce
qu'on lui a défini au début, dans notre exemple, echo… et ls -l, on peut donc faire exécuter n'importe
quoi à une fonction.

Exemples et exercices

L'art d'écrire un script

Des vérifications approfondies doivent être effectuées sur TOUTES les commandes utilisées.
Des commentaires détaillés doivent apparaître lors de chaque étape. De même, chaque étape
doit être suivie d'un "echo <voici ce que je fais>" (particulièrement utile notamment lors du
débogage).
Lors d'une mise à jour, un fil de discussion doit être précisé pour tracer les bugs éventuels.
Avertir les utilisateurs des dégâts que peuvent causer les commandes utilisées. (Ces deux
dernières remarques ne concernent bien sûr que les scripts que l'on souhaite diffuser.)
Commencer par :

#!/bin/bash
# Version du script

13 sur 15 14/03/2011 00:58

tutoriel:script_shell - Documentation Ubuntu Francophone [Link]

Écrire les variables en majuscule et NE PAS choisir des noms de commandes (ping , ls, …) de
même pour les noms de fonctions
À la fin de vos scripts, ajouter impérativement :

exit 0;

Ce qui indique que votre script s'est exécuté correctement.

Créer des fonctions pour des actions précises :

nom_de_la_fonction()

...

Utiliser des chemins absolu pour les dossiers et des chemins relatif pour les nom de fichiers

$CHEMIN_DU_DOSSIER/$NOM_DU_FICHIER

Utiliser les entrées de commandes pour les fonctions :

nom_de_la_fonction $1 $2 $3 ....

Si votre script doit s'arrêter à cause d'une erreur, d'une variable qui ne correspond pas a vos
attentes utiliser des numéros exit différents :

exit 100;
exit 101;
exit 102;
....

Ça permettra d'identifier d'où vient l'erreur.

Utiliser le tableau ${PIPESTATUS[@]} pour récupérer les états des autres commandes.
On peut écrire une fonction d'erreur du type :

erreur()
{
tab=( ${PIPESTATUS[@]} )

for (( i=0; i < ${#tab[@]}; i++ )); do ((i+=i)); done

if ((i > 0)); then

zenity --error --title="Une erreur est survenue" --text="Une erreur est
survenue "
exit 100
fi
}

ainsi après chaque commande vous pouvez donner des codes d'exécutions différents.

Évidemment ces conseils sont utiles au débutant…

Astuce : Le plus important dans tout programme est l'algorithme utilisé

Exemple : Supposons que vous ayez une base de données, avec 3 catégories d'enregistrements

14 sur 15 14/03/2011 00:58

tutoriel:script_shell - Documentation Ubuntu Francophone [Link]

possibles : éléphant bleu, éléphant blanc, éléphant rose ayant chacun 30 individus. Votre script doit
compter le nombre d'éléphants bleus et blancs. Deux possibilités s'offrent à vous :

calculer le nombre d'éléphants bleus + éléphants blancs

ou

calculer le nombre total d'éléphants - nombre d'éléphants roses

Quel algorithme choisissez-vous ?

Résultat : Le premier car dans le deuxième il faut d'abord calculer le nombre total d'éléphants, donc
un calcul en plus.

Liens
(fr) [Link] : Pour ceux qui souhaitent aller plus loin dans la
conception de script shell.

(fr) [Link] : Un très bon tutoriel concernant la réalisation

du script shell. C'est l'un des plus complets et les mieux détaillés disponibles en français. Il
contient également des exemples de script complets, une carte de référence (variables, tests…).
Ce site est un site qui vaut réellement le détour pour tous ceux qui cherchent à créer des scripts
complets en utilisant au mieux les performances du shell.
(fr) [Link] : Un
tutoriel trés complet pour linux qui comporte quelques parties sur la réalisation de scripts bash.
(en) Bash parameters and parameter expansions. En anglais mais contient de nombreux
exemples concernant la gestion et l'analyse des paramètres.
(fr ) Bash pour les nuls. Contient les man pages et d'autres informations intéressantes
(fr ) Introduction à Bash
(fr ) Siteduzero

15 sur 15 14/03/2011 00:58