Vous n'êtes pas identifié(e).
L'icône rouge permet de télécharger chaque page du wiki visitée au format PDF et la grise au format ODT →
Ceci est une ancienne révision du document !
- Pour choisir, voir les autres Tags possibles dans l'Atelier.
Nota :
Contributeurs, les sont là pour vous aider, supprimez-les une fois le problème corrigé ou le champ rempli !
Ré-requis indispensables :
Vous savez donc ce qu'est le shell, un alias et un script.
Mais quel rapport entre la diversité des shell (ou interpréteur de commandes) qui existent (sh ; bsh ; bash ; ksh, etc.) et les scripts ?
C'est que dans l'en-tête du script l'un de ces shell doit être appelé avec le sha-bang:
#!/bin/sh #!/bin/bash #!/bin/perl #!/bin/tcl
Chacune de ces lignes appelle un interpréteur de commandes différent.
POSIX est un standard2).
Appeler bash avec l'option –posix ou insérer set -o posix au début du script fait que bash se conforme au standard posix.
À savoir :
Pour utiliser tcsh, ksh, ash, sh, csh, etc :
http://formation-debian.via.ecp.fr/shell.html
méthode d'installation de ksh
Apprendre le BASH sans devenir un ultra-bashiste“ : si si c'est possible !
En général, tous les shell acceptent la même syntaxe de base telle que définie par POSIX, mais chacun accepte une syntaxe étendue qui lui est propre (et donc incompatible avec les autres shells).
Voici quelques aspects auxquels se référer à chaque fois que vous apprendrez une nouvelle notion relative au shell BASH.
POSIX | À éviter : bashisme |
---|---|
if [ “$toto” = “$titi” ] ; then … | if [ “$toto” == “$titi” ] ; then … |
diff -u fichier.c.orig fichier.c d | diff -u fichier.c{.orig,} |
mkdir /tototiti /tototutu | mkdir /toto{titi,tutu} |
funcname() { … } | function funcname() { … } |
format octal : « \377 » | format hexadécimal : « \xff » |
Pour plus de détails sur chacun de ces points voir : Guide avancé d'écriture des scripts Bash :36.9. Problèmes de portabilité
Il s'agit là plutôt d'un aboutissement, essayons d'acquérir par des exemples très simples, les connaissances de bases qui permettront de comprendre chacun de ces points, ainsi que ce que l'on trouve ici : scripts
Il y a différentes méthodes pour lancer ses scripts, cela dépend, vous l'aurez compris, du répertoire dans lequel sont placés ses scripts.
touch mon-script
Si l'on a exécuté cette commande à l'ouverture de son terminal, le fichier “mon-script” est alors placé dans son répertoire courant.
Et oui une script est un simple fichier texte dont le contenu (une suite de commandes et d'instruction) est exécutable.
À savoir :
chmod u+x mon-script
Voyons maintenant trois méthodes pour exécuter un script
nano mon-script
dans lequel on inscrit :
echo -n "Bonjour les copains"
ATTENTION il faut penser à se déplacer dans le répertoire parent de ce script avant de lancer l'exécution.
bash mon-script
Bonjour les copainsutiliateur@debian:~$
/bin/echo -n "Bonjour les copains"
La commande echo est une commande interne du shell ; la commande /bin/echo est une commande à part.
merci captnfab
Essayez maintenant :
bash --posix mon-script
Bonjour les copainsutilisateur@debian:~$
#!/bin/bash ls /home/utilisateur
./mon-script
À voir : modifier-durablement-la-valeur-de-la-variable-d-environnement-path
Il faut pour cela placer le chemin absolu de son script dans le PATH, c'est-à-dire dans l'un des répertoires /bin, /usr/bin ou /usr/local/bin
Les scripts que l'on crée sont ceux de l'utilisateur, on peut donc ajouter le chemin du répertoire dans lequel on range ses scripts
-en éditant le fichier ~/.bashrc qui est un fichier caché du répertoire courant de l'utilisateur (son HOME);
-et en y ajoutant à la fin la ligne PATH=$PATH”:$HOME/MesScripts“
mkdir MesScripts
nano ~/.bashrc
PATH=$PATH":$HOME/MesScripts"
nano mon-script
##!/bin/bash echo "Coucou tout le monde !"
chmod u+x ~/mon-script
mv ~/mon-script ~/MesScripts/
(Voir exemple ci-dessous : “Un petit script pour lancer un script depuis n'importe où !”)
mon-script
Coucou tout le monde !
echo $PATH #retour: /usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/home/utilisateur/MesScripts
Pas si difficile que ça
Voyons pour finir la méthode qui vérifie la compatibilité de son script avec la norme POSIX :
nano ~/MesScripts/mon-script
#!/bin/bash set -o posix echo -n "Bonjour $USER"
Le prompt vous dira “bonjour” avec l'option -n !
Pas d'inquiétude si vous ne comprenez pas tout ; vous en en serez capable après avoir suivi ce wiki et consulté ses liens. Il faut :
#!/bin/bash set -o posix printf "Un nouveau script $USER ? Son nom : " { read nom ; echo "#!/bin/bash" >> $nom ; chmod u+x $nom ; mv ~/$nom ~/MesScripts ; /usr/bin/gedit ~/MesScripts/$nom ;}
scriptx
Retour :
Un nouveau script toto ? Son nom :
Lors de l'exécution de ce script, la chaîne que vous entrerez pour répondre à la question, sera le nom d'un nouveau script que vous voulez créer.
En liens nécessaires :
Le shell pour tous : "Variables et environnement"
variables
Le nom d'une variable est un simple pointeur vers l'emplacement mémoire où sont conservées les données qu'elle contient.
Les variables qu'on crée dans un script (ou dans le terminal) sont localisées dans ce script (ou à l'ouverture d'un terminal) c'est-à-dire qu'elles ne sont utilisables que lorsqu'on exécute son script, (ou que l'on appelle la valeur d'une variable qu'on vient de déclarer dans un terminal). Et il s'agit du script d'un utilisateur, il faut les distinguer des variables de substitution prédéfinies et des variables d'environnement prédéfinies.
Mais comment enregistrer une valeur en mémoire ?
Comme vous allez le comprendre, une valeur est mémorisée au moyen de l'un des mécanismes internes du shell et il y en a plusieurs.
C'est par exemple, l'affectation d'une valeur au nom d'une variable qui va permettre d'enregistrer en mémoire cette variable avec sa valeur
Voyons d'abord comment créer une variable de cette manière et comment utiliser sa valeur.
Avant tout prenez bien conscience que la déclaration d'une variable n'est pas confinée au script, mais qu'il est possible de déclarer une variable dans le shell courant (dans le terminal). Voir absolument : détail sur le caractère $.
#!/bin/bash NomDelaVariable=ValeurDeLaVariable
⇒ La valeur “ValeurDeLaVariable” a été mémorisée.
#!/bin/bash nx_fichier=les-fonctions touch ~/$nx_fichier ls -la ~/$nx_fichier
⇒ Les programmes (ou commandes) “touch” et “ls” ont utilisé la valeur de la fonction nommée “nx_fichier”, d'une valeur qui correspond à la chaîne de caractères “les_fonctions”.
#!/bin/bash var1=a var2=texte var3="texte avec espaces" var4=55 var5=$var1 #ici on affecte à la variable var5, la valeur de la variable var1 var6=$0 #ici on affecte à la variable var6, la valeur de la variable pré-définie $0 (1) echo -e "valeur de var1: $var1\nvaleur de var2: $var2\nvaleur de var3: $var3\nvaleur de var3: $var4\nvaleur de var5: $var5\nvar6: $var6"
(1) $0 a pour valeur pré-définie le nom du programme
Retour :
valeur de var1: a valeur de var2: texte valeur de var3: texte avec espaces valeur de var3: 55 valeur de var5: a var6: /home/hypathie/MesScripts/mon-script
#!/bin/bash set -o posix var1=a var2=texte var3="texte avec espaces" var4=55 var5=$var1 var6=$0 /bin/echo -e "valeur de var1: $var1\nvaleur de var2: $var2\nvaleur de var3: $var3\nvaleur de var3: $var4\nvaleur de var5: $var5\nvar6: $var6" # même retour que précédemment
On peut créer des variables au moyen de commandes, comme par exemple la commande read qui est une commande interne (ou primitive) au shell.
read nom-de-la-variable
Par exemple dans un script :
#!/bin/bash echo "Bonjour : qui êtes-vous ?" read nom echo "Enchanté $nom !"
De même dans le terminal on peut tout à fait entrer tour à tour chacune des lignes de ce script, essayez !
#!/bin/bash read -p "entrez votre prénom: " prenom echo "bonjour $prenom !"
Ici “prenom” est le nom de la variable, et sa valeur est entrée par l'utilisateur depuis le terminal. Là aussi ces deux commandes peuvent être entrées dans le terminal.
read -p "entrez votre nom et prénom: " nom prenom
retour:
entrez votre nom et prénom:
On entre par exemple debian facile, puis on peut récupérer la valeur de chacune des variables “nom” et “prenom”
echo $prenom $nom
retour :
facile debian
Mais dans un script c'est plus rapide !
Ci-dessous, on ne met pas le “nom” de la variable, parce qu'on ne cherche pas à appeler la valeur de cette variable mais à permettre au programme de se poursuivre.
Quand on entre dans le terminal la réponse attendu par “read”, le retour de la commande et zéro, donc elle est considérée comme exécutée, et le shell passe à l'exécution de la commande suivante.
#!/bin/bash read -p "entrez votre nom d'utilisateur: " echo "bonjour $USER !"
par exemple:
read -p "entrez votre de naissance (deux derniers chiffres): " -n 2 annee
À savoir :
La valeur (contenu) de la variable1 (var1) et de la variable2 (var2) peuvent être les arguments passés à un script. Un script peut opérer un test sur les chaînes de caractères passées au script depuis le terminal. (Lancez “mon-script” successivement sans argument, puis un, deux trois, etc. arguments.)
#!/bin/bash var1=$1 var2=$2 echo $1 echo $2 if [ $# == 1 ] ; then echo "ERREUR: vous avez entré $@, mais il faut deux arguments !" elif [ $# == 2 ] ; then echo "Les deux arguments que vous avez entré sont $1 et $2" elif [ $# == 0 ] ; then echo "ERREUR: vous n'avez pas entré d'arguments, il en faut deux !" fi
Les chaînes testées par un script peuvent être aussi le contenu d'un fichier.
Dans ces deux cas les valeurs des variables que l'on testent, sont choisies depuis l'extérieur du script (le script est un processus fils du shell).
Mais pour modifier la valeur d'une variable par un script (que le script appelle une valeur extérieure; chaîne de caractère donnée par le terminale, récupération du résultat d'une commande, contenu d'un fichier, etc. ou que cette variable soit affectée dans le script lui-même) on utilise les boucles.
Voir :
#!/bin/bash for i in "$@" do echo "Vous avez donné à la variable 'i' la valeur : $i." if [ "$1" != "coucou" ] ; then echo "Le premier argument doit être 'coucou'." else echo "OK" if [ "$2" != "toi" ] ; then echo "Le deuxième paramètre doit être 'toi'." else echo "MERCI" fi fi done echo " " #pour sauter une ligne echo $@
Ci-dessus, la variable i de la boucle prend tour à tour la valeur des paramètres passé au script depuis le terminal et la structure if teste si la chaîne du paramètre passé au script (valeur de la variable) correspond au motif voulu.
#!/bin/bash set a b c echo "Avec 'shift', on se décale d'un paramètre à chaque boucle." for i in "$@" do i=$1 shift 1 echo "les paramètres sont : $1 :$2 :$3 ." done
Retour:
Avec 'shift', on se décale d'un paramètre à chaque boucle. les paramètres sont : b :c : . les paramètres sont : c : : . les paramètres sont : : : .
Attention à la commande set: avec set - - le script est en quelque sorte, fermé sur lui-même et après l'avoir utiliser, on ne peut plus récupérer une valeur extérieur au script pour modifier une variable du script. Par exemple : soit le script ci-dessous boucle-set.sh (passer un argument à ce script depuis le terminal)
#!/bin/bash var=$1 echo $1 set a b c #set -- echo $@ for i in "$@" do i=$1 shift 1 echo "les paramètres sont : $1 :$2 :$3 ." echo $var done
./boucle-set.sh argument1
Retour :
argument1 a b c les paramètres sont : b :c : . argument1 les paramètres sont : c : : . argument1 les paramètres sont : : : . argument1
MAIS :
#!/bin/bash var=$1 echo $1 set a b c set -- echo $@ for i in "$@" do i=$1 shift 1 echo "les paramètres sont : $1 :$2 :$3 ." echo $var done
Retour :
argument1
declare let exit
Les variables de chaque case d'un tableau, ont elles aussi une position définie par l'utilisateur, ou automatiquement lors de la création du tableau.
Pour plus de précision sur la création et l'utilisation de tableau dans les scripts voir ici : page-man-bash-v-les-tableaux
Le shell bash permet plusieurs syntaxes pour définir une fonction.
Il faut utiliser le mot réservé function :
function nom-de-la-fonction { suite-de-commande } nom-de-la-fonction
#!/bin/bash function f # on peut ajouter des parenthèse après le nom ; function f() { echo "Bonjour tout le monde" } f # retour : Bonjour tout le monde
#!/bin/bash function f { echo "coucou" ;} f # retour : coucou
#!/bin/bash function f { echo hello } f # retour : Hello
#!/bin/bash function f { echo $0 echo $USER echo $1 $2 $3 echo $# echo $@ echo $* } f chez debian facile #chez : premier argument #debian : deuxième argument #facile : troisième argument
Retour
/home/hypathie/MesScripts/script.fct hypathie chez debian facile 3 chez debian facile chez debian facile
Cette commande permet de décaler la numérotation des paramètres de position de la fonction
#!/bin/bash function minipoesie { echo "nom complet : $0" echo " " echo "$*" # avant 'shift 1' shift 1 (l'argument 1 est "chez") echo "$*" # après 'shift 1' echo "$*" # avant 'shift 2' shift 2 (l'argument 1 est "debian") echo -e "\t$*" # après 'shift 2' echo -e "\t $*" # avant 'shift 3' shift 3 echo -e "\t $*" # après 'shift 3' } minipoesie hypathie chez debian facile
retour
nom complet : /home/hypathie/MesScripts/minipoesie hypathie chez debian facile chez debian facile chez debian facile facile facile facile
Et voilà, vous devriez maintenant être capable de tout comprendre de l'exemple de ces liens: