Aspects avancés de la programmation shell

1. Utilisation de $* et de $@ sans guillemets

Les variables $* et $@ contiennent la liste des arguments d’un script shell. Lorsqu’elles ne sont pas entourées par des guillemets, elles sont équivalentes.

Exemple

Le script test_var1.sh affiche la valeur de chaque argument de la ligne de commande :

$ nl test_var1.sh  
     1  #! /usr/bin/ksh 
     2  # compatibilité du script : posix, ksh, bash 
     3 
     4  compteur=1 ; 
 
     5  # $* : tous les espaces sont vus comme séparateurs de mots 
     6  for arg in $*           # Equivalent a $@ 
     7  do 
     8    echo "Argument $compteur : $arg" 
     9    compteur=$(( compteur + 1 )) 
    10  done 

Voici un exemple d’appel du script :

$ test_var1.sh a b c "d e f" g 

Première étape : le shell courant traite les caractères de protection avant de lancer le script. À ce niveau, les espaces internes à "d e f" sont protégés et ne sont pas vues comme séparateurs de mots, mais comme des caractères quelconques.

Deuxième étape : le shell enfant qui interprète le script substitue $* (ou $@) par a b c d e f g.

 for arg in $@ 
 ou 
 for arg in $*  
  
 for arg in a b c d e f g 

Les espaces qui étaient protégés au niveau du shell de travail ne le sont plus au niveau du shell enfant. Voici le résultat de l’exécution...

1. Longueur de la valeur contenue dans une variable

Syntaxe

${#variable} 

Exemple

$ var="ma chaine" 
$ echo ${#var} 
9 
$ 

2. Retirer le plus petit fragment en début de chaîne

Syntaxe

${variable#modele} 

où modele est une chaîne de caractères pouvant inclure les caractères spéciaux *, ?, [], ?(expression), +(expression), *(expression), @(expression), !(expression) (cf. chapitre Mécanismes essentiels du shell - Substitution de noms de fichiers).

Le caractère # signifie "Chaîne la plus courte possible en début de chaîne".

Exemple

Afficher la variable ligne sans son premier champ :

$ ligne="champ1:champ2:champ3" 
$ echo ${ligne#*:} 
champ2:champ3 

L’expression " *: " signifie : 0 à n caractères suivis du caractère ":".

3. Retirer le plus grand fragment en début de chaîne

Syntaxe

${variable##modèle} 

Les caractères ## signifient "Chaîne la plus longue possible en début de chaîne".

Exemple

Afficher le dernier champ de la variable ligne :

$ ligne="champ1:champ2:champ3" 
$ echo ${ligne##*:} 
champ3 

L’expression " *: " signifie : 0 à n caractères suivis du caractère " : ".

4. Retirer le plus petit fragment en fin de chaîne

Syntaxe

${variable%modèle} 

Le caractère "%" signifie "Chaîne la plus courte possible fin de chaîne".

Exemple

Afficher la variable ligne sans son dernier...

1. Définition et initialisation d’un tableau

Les éléments d’un tableau peuvent être assignés de manière globale ou un par un.

Syntaxe

Définition d’un tableau :

declare -a nomtableau 

Initialisation globale d’un tableau :

nomtableau=( val1 val2 ... valn ) 

Définition et initialisation globale d’un tableau :

declare -a nomtableau=( val1 val2 ... valn ) 

Exemples

$ declare -a tab 
$ tab=( 10 11 12 13 mot1 mot2 ) 

ou

$ declare -a tab=( 10 11 12 13 mot1 mot2 ) 

Syntaxe

Définition d’un tableau :

set -A nomtableau 

Définition et initialisation globale d’un tableau :

set -A nomtableau val1 val2 ... valn 

Exemple

$ set -A tab 10 11 12 mot1 mot2 

Autre syntaxe ksh93

Définition et initialisation globale d’un tableau :

nomtableau=( val1 val2 ... valn ) 

2. Assigner un élément de tableau

Les éléments peuvent être initialisés, modifiés ou ajoutés de cette façon :

Syntaxe

nomtableau[indice]=valeur 

Exemple

$ tab[0]=10 
$ tab[2]=12 

3. Valeur d’un élément

Syntaxe

${nomtableau[indice]} 

Exemple

Affichage de l’élément d’indice 0 :

$ echo...

1. Définition d’une fonction

La définition d’une fonction doit être faite avant son premier appel.

Première syntaxe

Les parenthèses indiquent au shell que mafonction est une fonction.

Définition de la fonction :

mafonction() { 
    commande1 
    commande2 
    ... 
} 

Appel de la fonction :

mafonction 

Deuxième syntaxe

Le mot-clé function remplace les parenthèses utilisées dans la première syntaxe. 

Définition de la fonction :

function mafonction { 
    commande1 
    commande2 
    ... 
} 

Appel de la fonction :

mafonction 

Dans un script contenant des fonctions, les commandes situées en dehors des corps de fonction sont exécutées séquentiellement.

Pour que les commandes localisées dans une fonction soient exécutées, il faut faire un appel de fonction. Une fonction peut être appelée aussi bien à partir du programme principal qu’à partir d’une autre fonction.

Exemples

Utilisation de la première syntaxe :

$ nl fonc1.sh 
1 f1() {    # Déefinition de la fonction 
2    echo "Dans f1" 
3 } 
4 echo "1ère commande" 
5 echo "2ème commande" 
6 f1    # Appel de la fonction 
7 echo "3ème commande" 
 
$ fonc1.sh 
1ère commande 
2ème commande 
Dans f1 
3ème commande ...

1. La commande print

Cette commande apporte des fonctionnalités qui n’existent pas avec echo.

$ print Imprimante en panne 
Imprimante en panne 
$ 

$ print -n Imprimante en panne 
Imprimante en panne$ 

$ print -i : Option invalide 
ksh: print: bad option(s) 
$ print "-i : Option invalide" 
ksh: print: bad option(s) 

$ print - "-i : Option invalide" 
-i : Option invalide 
$ 

print -udesc message 

$ print -u2 "Message d'erreur" 

$ echo "Message d'erreur" 1>&2 

1. Redirection des entrées/sorties standards

La commande interne exec permet de manipuler les descripteurs de fichier du shell courant. Utilisée à l’intérieur d’un script, elle permet de rediriger de manière globale les entrées/sorties de celui-ci.

Rediriger l’entrée standard d’un script

exec 0< fichier1 

Toutes les commandes du script placées derrière cette directive et qui lisent leur entrée standard vont extraire leurs données à partir de fichier1. Il n’y aura donc plus d’interaction avec le clavier.

Rediriger la sortie standard et la sortie d’erreur standard d’un script

exec 1> fichier1 2> fichier2 

Toutes les commandes du script placées derrière cette directive et qui écrivent sur leur sortie standard enverront leurs résultats dans fichier1. Celles qui écrivent sur leur sortie d’erreur standard enverront leurs erreurs dans fichier2. 

Rediriger la sortie standard et la sortie d’erreur standard d’un script dans un même fichier

exec 1> fichier1 2>&1 

Toutes les commandes du script placées derrière cette directive enverront leurs résultats et leurs erreurs dans fichier1 (cf. chapitre Mécanismes essentiels du shell - Redirections).

Premier exemple

Le script batch1.sh envoie sa sortie standard dans /tmp/resu et sa sortie d’erreur standard dans /tmp/log :

$ nl batch1.sh  
     1  #! /bin/bash 
     2  # compatibilité du script : posix, ksh, bash 
 
     3  exec 1> /tmp/resu 2> /tmp/log 
     4  echo "Début du traitement: $(date)" 
     5  ls ...

1. Principaux signaux

2. Ignorer un signal

Syntaxe

trap '' sig1 sig2 

Exemple

Le shell courant a pour PID 18033 :

$ echo $$ 
18033 

L’utilisateur demande au shell d’ignorer l’éventuelle réception des signaux HUP et TERM :

$ trap '' HUP TERM 

Envoi des signaux HUP et TERM (syntaxe tous shells) :

$ kill -HUP 18033 
$ kill -TERM 18033 

Les signaux sont ignorés, le processus shell ne meurt donc pas :

$ echo $$ 
18033 
$ 

1. Récupérer le nom du shell interpréteur du script

Nous allons avoir besoin de tester si le script est en cours d’interprétation par le bash ou le ksh. Voici l’instruction qui permet de faire ce test :

$$ représente le PID du shell courant, tail permet de récupérer la dernière ligne du résultat, et awk permet de récupérer le dernier champ de la ligne (cf. chapitre Le langage de programmation awk).

$ shell=$( ps -p $$ | tail -1 | awk '{ print $NF}' )  
$ echo $shell  
bash  
$ 

Nous listons ci-après deux incompatibilités classiques entre ksh et bash et nous finirons par la manière d’écrire un script unique grâce au nom du shell que nous venons de récupérer ci-dessus.

2. Gestion des séquences d’échappement avec echo

Dans le comportement par défaut du bash, l’option -e est indispensable pour que les séquences d’échappement soient interprétées. En ksh, aucune option n’est nécessaire.

Exemple en ksh

$ echo " a\nb"  
a  
b  
$ 

Exemple en bash

$ echo -e " a\nb"  
a  
b  
$ 

Pour éviter d’avoir à utiliser l’option -e en bash, il faut activer l’option xpg_echo à l’aide de la commande shopt.

Exemple en bash

$ shopt -s xpg_echo  
$ echo "a\nb"  
a  
b  
$ 

3. Gestion des caractères étendus

Comme nous l’avons étudié dans les chapitres précédents, l’option extglob doit être activé...

1. Objectif

Il s’agit d’écrire un script qui sauvegarde de manière incrémentale le contenu d’un répertoire d’une machine de production. Les fichiers de sauvegarde (archives cpio compressées) seront transférés sur un serveur de sauvegarde (serveur venus), dans un répertoire dont le nom dépend du mois et de l’année de sauvegarde.

Répertoires de la machine de production :

Répertoires de la machine de sauvegarde :

Dans l’exemple présenté ici, ces répertoires sont créés par avance. Ce n’est pas le script de sauvegarde qui le fait (mais cela est facilement réalisable).

La figure 2 représente l’arborescence des deux serveurs.

La sauvegarde incrémentale utilisera autant de niveau de sauvegarde qu’il y a de jours dans le mois. Par principe, une sauvegarde de niveau 0 (sauvegarde de tous les fichiers du répertoire /home/document) est faite le premier jour de chaque mois. Les jours suivants, seuls les fichiers modifiés depuis le jour précédent seront archivés.

Des fichiers de niveau sont utilisés (niveau0, niveau1...). Ceux-ci témoignent de la date à laquelle la sauvegarde a été réalisée.

Exemple

Le 01/01/2022 : Sauvegarde de niveau 0 : création du fichier témoin "niveau0" et sauvegarde de tous les fichiers situés sous...

1. Fonctions

- 0 - Fin 
- 1 - Afficher la liste des utilisateurs connectés 
- 2 - Afficher l'espace disque 
Votre choix : 

0 - Fin 
1 - Supprimer les fichiers de taille 0 sous mon répertoire d'accueil 
2 - Contrôler l'espace disque du SF racine 
Votre choix :