Les scripts shell - Niveau 1

Objectifs pédagogiques

Dans ce chapitre, vous allez apprendre à rédiger votre premier script, à utiliser des variables et également à interagir avec les utilisateurs.

Rédiger son premier script en bash ;
Utiliser des variables ;
Interagir avec un utilisateur ;
Transformer le contenu d’un fichier ou d’une variable ;
Gérer les arguments d’un script.

script, shell, bash

Connaissances :
Niveau technique :
Temps de lecture : 20 minutes

Le shell est l’interpréteur de commandes de Linux. C’est un binaire qui ne fait pas partie du noyau, mais forme une couche supplémentaire, d’où son nom de "coquille".

Il analyse les commandes saisies par l’utilisateur puis les fait exécuter par le système.

Il existe plusieurs shells, tous partageant des points communs. L’utilisateur est libre d’utiliser celui qui lui convient le mieux parmi (entre autres) :

  • le Bourne-Again shell (bash),

  • le Korn shell (ksh),

  • le C shell (csh),

  • etc.

Le bash est présent par défaut sur les principales distributions Linux. Il se caractérise par ses fonctionnalités pratiques et conviviales.

Le shell est aussi un langage de programmation basique qui, grâce à quelques commandes dédiées, permet :

  • l’utilisation de variables,

  • l’exécution conditionnelle de commandes,

  • la répétition de commandes.

Les scripts en shell ont l’avantage d’être réalisables rapidement et de manière fiable, sans compilation ni installation de commandes supplémentaires. Un script shell n’est qu’un fichier texte sans enluminures (gras, italique, etc.).

Si le shell est un langage de programmation « basique », il n’en reste pas moins très puissant et parfois plus rapide qu’un mauvais code compilé. Si vous n’en êtes pas convaincu, vous pouvez lire, même s’il commence à dater, l’article suivant : Entretien avec un débutant en bash de Étienne Dublé. Cela vous permettra de réfléchir à votre façon de coder.

Pour écrire un script shell, il suffit de réunir dans un même fichier texte toutes les commandes nécessaires. En rendant ce fichier exécutable, le shell le lira séquentiellement et exécutera une à une les commandes le comportant. Il est aussi possible de l’exécuter en passant le nom du script comme un argument au binaire bash.

Lorsque le shell rencontre une erreur, il affiche un message permettant d’identifier le problème mais continue l’exécution du script. Mais il existe des mécaniques pour stopper l’exécution d’un script en cas de survenance d’une erreur. Les erreurs propres aux commandes sont également affichées à l’écran ou à l’intérieur de fichiers.

Qu’est ce qu’un bon script ? C’est un script :

  • fiable : son fonctionnement est irréprochable même en cas de mauvaise utilisation ;

  • commenté : son code est annoté pour en faciliter la relecture et les futures évolutions ;

  • lisible : le code est indenté à bon escient, les commandes sont aérées, …

  • portable : le code fonctionne sur tout système Linux, gestion des dépendances, gestion des droits, etc.

Premier script

Pour commencer l’écriture d’un script shell, il est pratique d’utiliser un éditeur de texte gérant la coloration syntaxique.

vim, par exemple, est un outil adapté à cela.

Le nom du script devra respecter quelques règles :

  • pas de nom de commandes existantes ;

  • ne contenant que des caractères alphanumériques, c’est-à-dire pas de caractère accentué ni d’espace ;

  • extension en .sh pour indiquer qu’il s’agit d’un script shell.

hello-world.sh
#!/usr/bin/env bash
#
# Auteur : Antoine Le Morvan
# Date : Janvier 2019
# Version 1.0.0 : Affiche le texte "Hello world !"
#

# Affiche un texte à l'écran :
echo "Hello world !"

Pour pouvoir exécuter ce script, en argument du bash :

$ bash hello-world.sh
Hello world !

Ou, plus simplement, après lui avoir donné le droit d’exécution :

$ chmod u+x ./hello-world.sh
$ ./hello-world.sh
Hello world !

Notez que pour exécuter le script, celui-ci a été appelé avec « ./ » avant son nom. L’interpréteur pourra refuser d’exécuter un script présent dans le répertoire courant sans indiquer un chemin (ici avec le « ./ » devant). La commande chmod n’est à passer qu’une seule fois sur un script nouvellement créé.

La première ligne à écrire dans tout script permet d’indiquer le nom du binaire du shell à utiliser pour l’exécuter. Si vous désirez utiliser le shell ksh ou le langage interprété python, vous remplaceriez la ligne :

#!/usr/bin/env bash

par :

#!/usr/bin/env ksh

ou par :

#!/usr/bin/env python

Tout au long de l’écriture, il faudra penser à la relecture du script en utilisant notamment des commentaires :

  • une présentation générale, en début, pour indiquer le but du script, son auteur, sa version, son utilisation, etc.

  • au cours du texte pour aider à la compréhension des actions.

Les commentaires peuvent être placés sur une ligne à part ou bien à la fin d’une ligne contenant une commande.

Exemple :

# Ce programme affiche la date
date    # Cette ligne est la ligne qui affiche la date !

Variables

Comme dans tout langage de programmation, le script shell utilise des variables. Elles servent à stocker des informations en mémoire pour les réutiliser à volonté au cours du script.

Une variable est créée au moment où elle reçoit son contenu. Elle reste valide jusqu’à la fin de l’exécution du script ou à la demande explicite de l’auteur du script. Puisque le script est exécuté séquentiellement du début à la fin, il est impossible de faire appel à une variable avant qu’elle ne soit créée.

Le contenu d’une variable peut être modifié au cours du script, la variable continue d’exister. Si le contenu est supprimé, la variable reste active mais ne contient rien.

La notion de type de variable en script shell est possible mais est très peu utilisée. Le contenu d’une variable est toujours un caractère ou une chaîne de caractères.

01-backup.sh
#!/usr/bin/env bash

#
# Auteur : Antoine Le Morvan
# Date : Janvier 2019
# Version 1.0.0 : Sauvegarde dans /root les fichiers passwd, shadow, group et gshadow
#

# Variables globales
FICHIER1=/etc/passwd
FICHIER2=/etc/shadow
FICHIER3=/etc/group
FICHIER4=/etc/gshadow

# Dossier destination
DESTINATION=/root

# Nettoie l'écran :
clear

# Lancer la sauvegarde
echo "La sauvegarde de $FICHIER1, $FICHIER2, $FICHIER3, $FICHIER4 vers $DESTINATION va commencer :"

cp $FICHIER1 $FICHIER2 $FICHIER3 $FICHIER4 $DESTINATION

echo "La sauvegarde est terminée !"

Ce script fait usage de variables. Le nom d’une variable doit commencer par une lettre mais peut ensuite contenir n’importe quelle suite de lettres ou de chiffres. Hormis le tiret bas « _ », les caractères spéciaux ne sont pas utilisables.

Par convention, les variables créées par un utilisateur ont un nom en minuscules. Ce nom doit être choisi avec précaution pour n’être ni trop évasif ni trop compliqué. Une variable peut toutefois être nommée avec des majuscules, comme c’est le cas ici, s’il s’agit d’une variable globale qui ne doit pas être modifiée par le programme.

Le caractère « = » affecte du contenu à une variable :

variable=valeur
nom_rep="/home"

Il n’y a pas d’espace ni avant ni après le signe =.

Pour afficher du texte en même temps que le contenu d’une variable, il est obligatoire d’utiliser les guillemets et non les apostrophes.

L’usage des apostrophes inhibe l’interprétation des caractères spéciaux.

$ message="Bonjour"
$ echo "Voici le contenu de la variable message : $message"
Voici le contenu de la variable message : Bonjour
$ echo 'Voici le contenu de la variable message : $message'
Voici le contenu de la variable message : $message

Pour isoler le nom de la variable, il faut utiliser les apostrophes ou les accolades :

$ fichier=nom_fichier
$ touch "$fichier"1
$ touch ${fichier}1

L’utilisation systématique des accolades est conseillée.

Supprimer et verrouiller les variables

La commande unset permet de supprimer une variable.

Exemple :

$ nom="NOM"
$ prenom="Prenom"
$ echo "$nom $prenom"
NOM Prenom
$ unset prenom
$ echo "$nom $prenom"
NOM

La commande readonly ou typeset -r verrouille une variable.

Exemple :

$ nom="NOM"
$ readonly nom
$ nom="AUTRE NOM"
bash: nom: variable en lecture seule
$ unset nom
bash: nom: variable en lecture seule

Un set -u en début de script va arrêter l’exécution du script en cas d’utilisation des variables non déclarées.

Variables d’environnements

Les variables d’environnements et les variables systèmes sont des variables utilisées par le système pour son fonctionnement. Par convention elles portent un nom en majuscules.

Comme toutes variables, elles peuvent être affichées à l’exécution d’un script. Même si cela est fortement déconseillé, elles peuvent aussi y être modifiées.

  • La commande env permet d’afficher toutes les variables d’environnement utilisées.

  • La commande set permet d’afficher toutes les variables système utilisées.

Parmi les dizaines de variables d’environnement, plusieurs ont un intérêt à être utilisées dans un script shell :

Table 1. Variables d’environnement
Variable Observation

HOSTNAME

Nom d’hôte de la machine.

USER, USERNAME et LOGNAME

Nom de l’utilisateur connecté sur la session.

PATH

Chemin où trouver les commandes.

PWD

Répertoire courant, mis à jour à chaque exécution de la commande cd.

HOME

Répertoire de connexion.

$$

Numéro du processus de l’exécution du script.

$?

Code retour de la dernière commande exécutée.

Exporter une variable

La commande export permet d’exporter une variable.

Une variable n’est valable que dans l’environnement du processus du script shell. Pour que les processus fils du script puissent connaître les variables et leurs contenus, il faut les exporter.

La modification d’une variable exportée dans un processus fils ne peut pas remonter au processus père.

Sans option, la commande export affiche le nom et les valeurs des variables exportées dans l’environnement.

La substitution de commande

Il est possible de stocker le résultat d’une commande dans une variable.

Cette opération n’est valable que pour les commandes qui renvoient un message à la fin de leur exécution.

La syntaxe pour sous-exécuter une commande est la suivante :

Syntaxes pour la substitution de commandes
variable=`commande`
variable=$(commande) # Syntaxe à privilégier

Exemple :

$ jour=`date +%j`
$ homedir=$(pwd)

Améliorations du script de sauvegarde

Quelques pistes d’améliorations
#!/usr/bin/env bash

#
# Auteur : Antoine Le Morvan
# Date : Janvier 2019
# Version 1.0.0 : Sauvegarde dans /root les fichiers passwd, shadow, group et gshadow
# Version 1.0.1 : Création d'un répertoire avec le quantième du jour.
#		          Améliorations diverses

# Variables globales

## Fichiers a sauvegarder
FICHIER1=/etc/passwd
FICHIER2=/etc/shadow
FICHIER3=/etc/group
FICHIER4=/etc/gshadow

## Dossier destination
DESTINATION=/root

## Variables en readonly
readonly FICHIER1
readonly FICHIER2
readonly FICHIER3
readonly FICHIER4
readonly DESTINATION

# Un nom de dossier avec le quantième du jour
rep="backup-$(date +%j)"

# Nettoie l'écran :
clear

# Lancer la sauvegarde
echo "****************************************************************"
echo "     Script de sauvegarde - Sauvegarde sur la machine $HOSTNAME "
echo "****************************************************************"
echo "La sauvegarde sera faîte dans le dossier ${rep}."
echo "Création du répertoire..."
mkdir -p $DESTINATION/$rep
echo "                                                      [ OK ]"
echo "La sauvegarde de ${FICHIER1}, ${FICHIER2}, ${FICHIER3}, ${FICHIER4} vers ${DESTINATION}/$rep va commencer :"

cp $FICHIER1 $FICHIER2 $FICHIER3 $FICHIER4 $DESTINATION/$rep

echo "La sauvegarde est terminée !"

# La sauvegarde est notée dans le journal d'évènements du système :
echo "La sauvegarde est renseignée dans syslog :"
logger "Sauvegarde des fichiers systèmes par ${USER} sur la machine ${HOSTNAME} dans le dossier ${DESTINATION}/$rep."
echo "                                                      [ OK ]"
Exécution de notre script de sauvegarde
root # ./02-backup-enhanced.sh
*****************************************************************
     Script de sauvegarde - Sauvegarde sur la machine formateur1
*****************************************************************
La sauvegarde sera faîte dans le dossier backup-262.
Création du répertoire...
                                                       [ OK ]
La sauvegarde de /etc/passwd, /etc/shadow, /etc/group, /etc/gshadow vers /root/backup-262 va commencer :
La sauvegarde est terminée !
La sauvegarde est renseignée dans syslog :
                                                       [ OK ]

Grace à la commande logger, les affichages de l’exécution du script sont écrites dans le journal syslog :

Événement dans syslog
root # tail -f /var/log/messages
janvier. 02 19:35:35 formateur1 antoine[9712]: Sauvegarde des fichiers systèmes par antoine sur la machine formateur1 dans le dossier /root/b...

Saisie et manipulations

Selon l’objet du script, il peut être nécessaire de lui envoyer des informations lors de son lancement ou durant son exécution.

Ces informations, non connues lors de l’écriture du script, peuvent être extraites à partir de fichiers ou saisies par l’utilisateur.

Il est aussi possible d’envoyer ces informations sous forme d’arguments lors de la saisie de la commande du script. C’est le mode de fonctionnement de nombreuses commandes Linux.

La commande read

La commande read permet de saisir une chaîne de caractères pour la stocker dans une variable.

Syntaxe de la commande read
read [-n X] [-p] [-s] [variable]
Exemple de la commande read
$ read nom prenom
$ read -p "Veuillez saisir votre nom : " nom
Table 2. Options de la commande read
Option Observation

-p

Affiche un message de prompt

-n

Limite le nombre de caractères à saisir

-s

Masque la saisie

Lors de l’utilisation de l’option -n, le shell valide automatiquement la saisie au bout du nombre de caractères précisés. L’utilisateur n’a pas à appuyer sur la touche [ENTREE].

$ read -n5 nom

La commande read permet d’interrompre l’exécution du script le temps que l’utilisateur saisisse des informations. La saisie de l’utilisateur est découpée en mots affectés à une ou plusieurs variables prédéfinies. Les mots sont des chaînes de caractères séparées par le séparateur de champs.

La fin de la saisie est déterminée par la frappe sur la touche [ENTREE] ou le caractère spécial de fin de ligne.

Une fois la saisie validée, chaque mot sera stocké dans la variable prédéfinie.

Le découpage des mots est défini par le caractère séparateur de champs. Ce séparateur est stocké dans la variable système IFS (Internal Field Separator).

$ set | grep IFS
IFS=$' \t\n'

Par défaut, l’IFS contient l’espace, la tabulation \t et le saut de ligne \n.

Utilisée sans préciser de variable, cette commande met simplement le script en pause. Le script continue son exécution lors de la validation de la saisie.

Cette utilisation permet de faire une pause lors du débogage d’un script ou pour inciter l’utilisateur à appuyer sur kbd:[ENTREE] pour continuer.

$ echo -n "Appuyer sur [ENTREE] pour continuer..."
$ read

La commande cut

La commande cut permet d’isoler une colonne dans un fichier ou dans un flux.

Syntaxe de la commande cut
cut [-cx] [-dy] [-fz] fichier
Exemple d’utilisation de la commande cut
$ cut -d: -f1 /etc/passwd
Table 3. Options de la commande cut
Option Observation

-c

Spécifie les numéros d’ordre des caractères à sélectionner

-d

Spécifie le séparateur de champs

-f

Spécifie le numéro d’ordre des colonnes à sélectionner

Le principal intérêt de cette commande sera son association avec un flux, par exemple la commande grep et le pipe |.

  • La commande grep travaille verticalement (isolation d’une ligne parmi toutes celles du fichier).

  • La combinaison des deux commandes permet d’isoler un champ précis du fichier.

Syntaxe de la commande cut
# grep "^root:" /etc/passwd | cut -d: -f3
0

Les fichiers de configurations comportant une structure unique utilisant le même séparateur de champs sont des cibles idéales pour cette combinaison de commandes.

La commande tr

La commande tr permet de convertir une chaîne de caractères.

Syntaxe de la commande tr
tr [-csd] chaîne1 chaîne2
Table 4. Options de la commande tr
Option Observation

-c

Tous les caractères qui ne sont pas spécifiés dans la première chaîne sont convertis selon les caractères de la seconde.

-d

Efface le caractère spécifié.

-s

Réduire à une seule unité le caractère spécifié.

Exemple d’utilisation de la commande tr
$ grep root /etc/passwd
root:x:0:0:root:/root:/bin/bash
$ grep root /etc/passwd | tr -s "o"
rot:x:0:0:rot:/rot:/bin/bash

Exercice : Extraire le niveau d’exécution du fichier /etc/inittab

#!/usr/bin/env bash

#
# Auteur : Antoine Le Morvan
# Date : Janvier 2019
# Version 1.0.0 : Extrait le niveau d'exécution du fichier /etc/inittab

# Variables globales

INITTAB=/etc/inittab

niveau=`grep "^id" $INITTAB | cut -d: -f2`

# Affichage du résultat :
echo "Le niveau d'init au démarrage est : $niveau"

Extraire le nom et le chemin d’un fichier

  • La commande basename permet d’extraire le nom du fichier à partir d’un chemin.

  • La commande dirname permet d’extraire le chemin parent d’un fichier.

Exemple :

$ echo $FICHIER=/usr/bin/passwd
$ basename $FICHIER
passwd
$ dirname $FICHIER
/usr/bin

Arguments d’un script

La demande de saisie d’informations grâce à la commande read interrompt l’exécution du script tant que l’utilisateur ne fait pas de saisie.

Cette méthode, bien que très conviviale, présente des limites s’il s’agit d’un script à l’exécution programmée la nuit par exemple. Afin de palier ce problème, il est possible d’injecter les informations souhaitées via des arguments.

De nombreuses commandes Linux fonctionnent sur ce principe.

Cette façon de faire à l’avantage qu’une fois le script exécuté, il n’aura plus besoin d’intervention humaine pour se terminer.

Son inconvénient majeur est qu’il faudra prévenir l’utilisateur de la syntaxe du script pour éviter des erreurs.

Les arguments sont renseignés lors de la saisie de la commande du script. Ils sont séparés par un espace.

$ ./script argument1 argument2

Une fois exécuté, le script enregistre les arguments saisis dans des variables prédéfinies : les variables positionnelles.

Ces variables sont utilisables dans le script comme n’importe quelle autre variable, à l’exception faite qu’elles ne peuvent pas être affectées.

  • Les variables positionnelles non utilisées existent mais sont vides.

  • Les variables positionnelles sont toujours définies de la même façon :

Table 5. Les variables positionnelles
Variable Observation

$0

contient le nom du script tel qu’il a été saisi.

$1 à $9

contiennent les valeurs du 1er et du 9ème argument.

${x}

contient la valeur de l’argument x, supérieur à 9.

$#

contient le nombre d’arguments passés.

$* ou $@

contient en une variable tous les arguments passés

Exemples :

un_deux_trois.sh
#!/usr/bin/env bash
#
# Auteur : Damien dit LeDub
# Date : septembre 2019
# Version 1.0.0 : Affiche la valeur des arguments positionnels
# de 1 à 3

# Le séparateur de champ sera "," ou l'espace
# Important pour visualiser la différence en $* et $@
IFS=", "

# Affiche un texte à l'écran :
echo "Le nombre d'argument (\$#) = $#"
echo "Le nom du script     (\$0) = $0"
echo "Le 1er argument      (\$1) = $1"
echo "Le 2e argument       (\$2) = $2"
echo "Le 3e argument       (\$3) = $3"
echo "Tous séparés par IFS (\$*) = $*"
echo "Tous sans séparation (\$@) = $@"
$ ./un_deux_trois.sh un deux "trois quatre"
Le nombre d'argument ($#) = 3
Le nom du script     ($0) = ./un_deux_trois.sh
Le 1er argument      ($1) = un
Le 2e argument       ($2) = deux
Le 3e argument       ($3) = trois quatre
Tous séparés par IFS ($*) = un,deux,trois quatre
Tous sans séparation ($@) = un deux trois quatre

Attention à la différence entre $@ et $*.

Elle se fait au niveau du format de stockage des arguments :

  • $* : Contient les arguments au format "$1 $2 $3 …​"

  • $@ : Contient les arguments au format "$1" "$2" "$3" …​

C’est en modifiant la variable d’environnement IFS que la différence est visible.

La commande shift

La commande shift permet de décaler les variables positionnelles.

Exemples :

un_deux_trois_shift.sh
#!/usr/bin/env bash
#
# Auteur : Damien dit LeDub
# Date : septembre 2019
# Version 1.0.0 : Affiche la valeur des arguments positionnels
# de 1 à 3 avant et après un «shift»

# Le séparateur de champ sera "," ou l'espace
# Important pour visualiser la différence en $* et $@
IFS=", "

# Récupère les arguments avant le «shift»
AVANT_SHIFT_NB="$#"
AVANT_SHIFT_NOM="$0"
AVANT_SHIFT_IER="$1"
AVANT_SHIFT_2E="$2"
AVANT_SHIFT_3E="$3"
AVANT_SHIFT_TOUS_IFS="$*"
AVANT_SHIFT_TOUS="$@"

# Récupère les arguments après le «shift»
shift 2
APRES_SHIFT_NB="$#"
APRES_SHIFT_NOM="$0"
APRES_SHIFT_IER="$1"
APRES_SHIFT_2E="$2"
APRES_SHIFT_3E="$3"
APRES_SHIFT_TOUS_IFS="$*"
APRES_SHIFT_TOUS="$@"

# Affiche toutes les informations récupérées
echo "Le nombre d'argument (\$#) : ${AVANT_SHIFT_NB}"
echo "  après le shift 2        : ${APRES_SHIFT_NB}"
echo "Le nom du script     (\$0) : ${AVANT_SHIFT_NOM}"
echo "  après le shift 2        :${APRES_SHIFT_NOM}"
echo "Le 1er argument      (\$1) : ${AVANT_SHIFT_IER}"
echo "  après le shift 2        :${APRES_SHIFT_IER}"
echo "Le 2e argument       (\$2) :${AVANT_SHIFT_2E}"
echo "  après le shift 2        :${APRES_SHIFT_2E}"
echo "Le 3e argument       (\$3) : ${AVANT_SHIFT_3E}"
echo "  après le shift 2        :${APRES_SHIFT_3E}"
echo "Tous séparé par IFS  (\$*) : ${AVANT_SHIFT_TOUS_IFS}"
echo "  après le shift 2        :${APRES_SHIFT_TOUS_IFS}"
echo "Tous sans séparation (\$@) : ${AVANT_SHIFT_TOUS}"
echo "  après le shift 2        :${APRES_SHIFT_TOUS} "
$ ./un_deux_trois_shift.sh un deux "trois quatre"
Le nombre d'argument ($#) : 3
  après le shift 2        : 1
Le nom du script     ($0) : ./un_deux_trois_shift.sh
  après le shift 2        :./un_deux_trois_shift.sh
Le 1er argument      ($1) : un
  après le shift 2        :trois quatre
Le 2e argument       ($2) :deux
  après le shift 2        :
Le 3e argument       ($3) : trois quatre
  après le shift 2        :
Tous séparé par IFS  ($*) : un,deux,trois quatre
  après le shift 2        :trois quatre
Tous sans séparation ($@) : un deux trois quatre
  après le shift 2        :trois quatre

Lors de l’utilisation de la commande shift, les variables $# et $* sont modifiées en conséquence.

La commande set

La commande set découpe une chaîne en variables positionnelles.

Syntaxe de la commande set
set [valeur] [$variable]

Exemple :

$ set un deux trois
$ echo $1 $2 $3 $#
un deux trois 3
$ variable="un deux trois"
$ set $variable
$ echo $1 $2 $3 $#
un deux trois 3

Ci-dessous, la version de notre script de sauvegarde mettant en oeuvre les variables positionnelles :

#!/usr/bin/env bash

#
# Auteur : Antoine Le Morvan
# Date : Janvier 2019
# Version 1.0.0 : Sauvegarde dans /root les fichiers passwd, shadow, group et gshadow
# Version 1.0.1 : Création d'un répertoire avec le quantième du jour.
#		  Améliorations diverses
# Version 1.0.2 : Modification pour utiliser les variables positionnelles
#                 Limitation à 5 fichiers

# Variables globales

## Dossier destination
DESTINATION=/root

# Un nom de dossier avec le quantieme du jour
rep="backup-$(date +%j)"

# Nettoie l'écran :
clear

# Lancer la sauvegarde
echo "****************************************************************"
echo "     Script de sauvegarde - Sauvegarde sur la machine $HOSTNAME "
echo "****************************************************************"
echo "La sauvegarde sera faîte dans le dossier ${rep}."
echo "Création du répertoire..."
mkdir -p $DESTINATION/$rep
echo "                                                  [ OK ]"
echo "La sauvegarde de ${1} ${2} ${3} ${4} ${5} vers ${DESTINATION}/$rep va commencer :"

cp $1 $2 $3 $4 $5 $DESTINATION/$rep

echo "La sauvegarde est terminée !"

Tester vos connaissances

Parmi ces 4 shells, lequel n’existe pas :
Bash
Ksh
Tsh
Csh

Quelle est la bonne syntaxe pour affecter un contenu à une variable :
variable:=valeur
variable := valeur
variable = valeur
variable=valeur

Comment stocker le retour d’une commande dans une variable :
fichier=$(ls)
fichier=`ls`
fichier:=$ls
fichier = $(ls)

La commande read permet de lire le contenu d’un fichier :
Vrai
Faux

Parmi les propositions ci-dessous, laquelle est la bonne syntaxe pour la commande cut :
cut -f: -D1 /etc/passwd
cut -d: -f1 /etc/passwd
cut -d1 -f: /etc/passwd
cut -c ":" -f 3 /etc/passwd

Quelle commande permet de décaller des variables positionnelles :
left
shift
set
decalle

Quelle commande transforme une chaîne de caractères en variables positionnelles :
left
shift
set
array