1

2

Sommaire :

Remerciements…………………………………………………………..2

Introduction générale………………………………………………….3

Définition et historique du shell…………………………………....4

Les variables……………………………………………………………….5

Les commandes shell……………………………………………………8

Types de commandes…………………………………………...8

Commandes essentielles ……………………………………….10

Scripts shell ………………………………………………………………..17

Les structures de contrôles……………………………………………21

La commande test ………………………………………………..22

Les contrôleurs de test…………………………………………..23

La structure if……………………………………………………….26

La structure case…………………………………………………..27

Les boucles while , until ,for………………………………….28

Les paramètres positionnels………………………………………….30

La substitution……………………………………………………………..31

Conclusion.………………………………………………………………….33

3

On tient tout d’abord à remercier l’équipe pédagogique de la Faculté

des Sciences Ben M'Sik, pour leur suivi permanent afin de nous

assurer une bonne formation et nos chers professeurs qui ont contribué à

la réussite de cette formidable année universitaire.

Nous tenons à remercier spécialement Mme Sanaa El FILALI qui nous a

toujours aidé et apporté ses directives et remarques pertinentes. Nous la

remercions encore pour l’occasion qu’elle nous a donnée pour affronter le

public et récupérer notre confiance et nos estimes à nous même. Qu'elle

trouve ici le témoignage de notre reconnaissance, gratitude, admiration et

remerciement.

4

L'objectif d'un système d'exploitation est de faciliter l'interface entre

l'utilisateur et le matériel. Par des abstractions, un OS masque à

l'utilisateur les ressources matérielles et les lui présente sous une forme

unifiée. Ceci est valable pour le/les processeurs, la mémoire, les

périphériques, les disques, etc.Ces abstractions se font par le biais d'une

API qui standardise les interactions entre l'utilisateur et le matériel .

L'interaction avec l'utilisateur passe par un interpréteur de commandes

appelé shell. comment utiliser le shell ? et quel rapport avec une

coquille ? Ces deux questions nous amène au sujet de notre exposé : « la

programmation Shell » nous avons trouvés ce sujet très intéressant

puisqu’il s’agit pour nous d’un domaine inconnu ou nous aimerons

approfondir nos compétences .

5

Qu’es t ce qu’un shell :

Le « Shell » est ce que l’on appel un « Interpréteur de commandes ». Il date de l’époque d’UNIX, où le seul moyen de communiquer avec sa machine était d’écrire des lignes textes au clavier, dans un langage compréhensible à la fois par l’humain et la machine. Le rôle de la machine étant d'exécuter les commandes de l’utilisateur et d’afficher le résultat à l’écran. Le shell c'est un programme qui se trouve dans le répertoire /bin. Par définition, il doit être léger et rapide, et reste un service d’accès privilégié aux Noyau Linux (Kernel) pour l'exécution de primitives système. Depuis, cette « interface » avec la machine a perdurée car elle est rapide et fiable pour l’utilisateur qui la maitrise. Le shell a évoluée aux travers des années, plusieurs types de Shell existent :

sh : Bourne Shell. L'ancêtre de tous les shells. bash : Bourne Again Shell. Une amélioration du Bourne Shell,

disponible par défaut sous Linux et Mac OS X.

ksh : Korn Shell. Un shell puissant assez présent sur les Unix propriétaires, mais aussi disponible en version libre, compatible avec bash.

csh : C Shell. Un shell utilisant une syntaxe proche du langage C. tcsh : Tenex C Shell. Amélioration du C Shell. zsh : Z Shell. Shell assez récent reprenant les meilleures idées de

bash, ksh et tcsh.

Mais le principe de base et toujours resté le même : Les shells sont des interpréteurs, ils lisent chaque commande saisie par l’utilisateur (ou lue à partir d’un fichier), vérifient et traitent la syntaxe pour l’exécuter. Dans la suite on va utiliser le Shell Bash, l’un des plus couramment utilisé sur les systèmes GNU/Linux. Bash est un logiciel libre publié sous GNU GPL.

6

Historique shell

Variable: définition

Comme dans tous les langages de programmation, on trouve en bash ce que l'on appelle des variables. Elles nous permettent de stocker temporairement des informations en mémoire. C'est en fait la base de la programmation. En shell, pour désigner le contenu d'une variable, on écrit le nom de la variable précédé du signe dollar. Exemple : echo $HOME affiche le nom du répertoire personnel de l'utilisateur, mémorisé par la variable HOME. Les types des variables

Les variables simples Syntaxe : Variable=chaîne L'affectation d'une variable simple se fait par la syntaxe "variable=chaîne".

Notez Bien

Dans le cas où on voudrait entrer une chaîne avec des espaces dans la variable, il faut alors encadrer la chaîne par des quotes comme on a déjà vus

7

Exemple :

Les tableaux Le bash gère également les variables tableaux. Ce sont des variables qui contiennent plusieurs cases, comme un tableau Syntaxe : tableau[n]=chaîne tableau=(chaîne1 chaîne2 ...) Cela crée une variable tableau qui contient plusieurs valeurs Affichage : Pour accéder à une case du tableau, il faut utiliser la syntaxe suivante : ${tableau[2]} Ceci affichera le contenu de la case n° 2 Vous pouvez afficher l'ensemble du contenu du tableau d'un seul coup en utilisant ${tableau[*]}

Notez Bien

Variables d'environnement Les variables sont des valeurs associées à des noms explicites; elles constituent l'environnement d'exécution des commandes. On retrouve dans l'environnement standard du shell un certain nombre de variables dont il se sert à l'exécution. Les plus utilisées sont : HOME contient le répertoire d'utilisateur

si vous substituer * par @ ça sera la même chose

8

USER contient le login d'utilisateur

PWD contient le répertoire courant

SHELL contient le nom du shell de connexion

PATH contient la liste des répertoires où se trouvent les commandes que l'utilisateur peut exécuter

HOSTNAME contient le nom de la machine

HISTSIZE contient la taille maximale des commandes exécutées contenues dans le fichier historique

Commandes shell :

9

Le shell interprète la série de caractères tapés à chaque fois qu'un retour chariot (entrée) est reçu; en même temps, les caractères tapés sont affichés à l'écran. Les premiers caractères tapés jusqu'au premier séparateur (espace ou tabulation) sont interprétés par le shell comme le nom de la commande à exécuter, les chaînes de caractères suivantes étant considérées comme les arguments.

Syntaxe :

La syntaxe générique d'une commande shell est :

commande [options [argument1 [argument2 [... ]]]]

où une chaîne de caractères entre crochets est optionnelle. Le nombre d'argument peut être limité (se reporter au manuel de la

commande). Les options de la commande peuvent être :

des options courtes formées par un tiret suivi d'une lettre. Exemple : -s

des options longues formées par deux tirets suivis d'un mot. Exemple : --size

des options courtes ou longues qui exigent un argument. Exemples : --speed 50 ou -s 50

Types de commandes

Le Shell permet d'exécuter :

des commandes internes des commandes externes des commandes complexes des fichiers de commandes

1. commande interne : est une commande intégrer au shell, autrement dit un mot clé ou mot réservé du langage shell .Pour traiter une commande interne, le shell effectue lui-même un traitement spécifique, sans créer de sous processus.

10

Notez Bien

type nom : affiche la commande détaillée liée a nom.

2. Commande externe : est un fichier exécutable .Le shell recherche ce fichier exécutable dans chacun des répertoires spécifiés par la variable PATH. Pour traiter une commande, le shell créé un sous –processus .Cette commande ne peut donc en aucun cas modifier l’environnement du processus type : dans le cas d’une commande externe indique le chemin

absolu du fichier exécutable qui constitue la commande

3. Commande complexe : Les commandes complexes résultent de la combinaison de plusieurs commandes par l’intermédiaire de tubes.

4.Fichiers de commandes : Appelés aussi scripts Shell, ces fichiers textes regroupent une succession ordonnée de commandes et de structures de contrôles. Ecrire un script revient à faire de la programmation.

Selon le shelll utilisé les commandes internes peuvent être différentes

.

11

En résumé, voici un shéma qui représente l’exécution d’une commande par le shell, suivant que cette dernière est externe ou interne.

Commandes essentielles

echo : afficher une variable

Syntaxe :

$ echo [option] texte

Description :

echo est une commande centrale du shell : elle transmet tous ses

paramètres sur écran (ou canal de sortie standard).

Options courante :

-n : supprime le saut de ligne final

-e : interprète les séquences spéciales.

12

Exemple :

Pour afficher le mot bonjour, nous devons taper la commande suivante :

Si on veut insérer des retours à la ligne, il faudra activer le paramètre -e et utiliser le symbole \n :

Pour afficher une variable, nous allons de nouveau utiliser son nom précédé du symbole dollar $ :

Maintenant, supposons que l'on veuille afficher à la fois du texte et la variable. Nous serions tentés d'écrire :

Le problème est que cela ne fonctionne pas comme on le souhaite.

Pour bien comprendre ce qui se passe, intéressons-nous au fonctionnement de ce que l'on appelle les quotes

Avec des doubles quotes :

Ça fonctionne ! Cette fois, la variable est analysée et son contenu affiché. En fait, les doubles quotes demandent à bash d'analyser le contenu du message. S'il trouve des symboles spéciaux (comme des

13

variables), il les interprète. Avec de simples quotes, le contenu était affiché tel quel.

read : demander une saisie

Description :

read signifie "lire". Cette commande permet d'affecter des valeurs à

des variables à partir de l'entrée standard. Elle est souvent utilisée à

l'intérieur d'une boucle while. Elle varie beaucoup d'un shell à l'autre.

Syntaxe :

$ read nom_variable [...]

Options courantes:

Pas d'option.

Exemples :

L'exemple suivant montre que si le nombre de mots (séparés par des

espaces ou des tabulations) est supérieur au nombre d'arguments de la

commande read, alors la variable correspondant au dernier argument

reçoit toute la fin de la ligne.

Set : afficher une variable

Syntaxe :

set options

Description :

Il est possible d'affecter directement des paramètres au shell grâce à la commande "set". Une simple commande tel que : set param1 param2 param3

14

Initialisera automatiquement les paramètres positionnels "$1,$2,$3" avec les valeurs "param1, param2, param3", effaçant de ce fait les anciennes valeurs si toutefois elles existaient. Les paramètres spéciaux "#,* et @" sont automatiquement mis à jours en conséquence.

Options courante :

-a exporter toutes les variables

-u refuser les variables indéfinies

-v afficher les lignes de commandes avant exécution

-x afficher les développements avant exécution

Exemple :

expr :

Description :

expr vient de "expression". Cette commande permet d'effectuer des opérations arithmétiques et

logiques, ainsi que des opérations sur les chaînes de caractères plus sophistiquées que la simple concaténation, et renvoie le résultat de ces opérations sur la sortie standard.

Syntaxe :

expr argument1 opérateur1 argument2 [opérateur2 argument3 ...]

Où les arguments argument1, argument2, argument3, ... sont des

expressions du shell courant, et où les opérateurs opérateur1,

opérateur2, ... appartiennent à la liste non exhaustive suivante :

+ (addition), - (soustraction), * (multiplication), / (quotient de la division entière), % (reste de la division entière), si argument1 et argument2 ont comme valeurs des chaînes de

15

caractères constituées uniquement de chiffres (et donc interprétables en tant qu'entiers).

= (égalité), != (différence), >, >=, <, <= (comparaisons), si argument1 et argument2 ont comme valeurs des chaînes de caractères quelconques (attention : pour ces opérations, la valeur VRAI est codée par 1 et la valeur FAUX par 0, comme en C).

: (extraction de sous-chaînes de caractères). Avec cet opérateur, l'argument argument1 peut avoir comme valeur une chaîne de caractères quelconque, mais l'argument argument2 doit être une expression régulière .On peut spécifier l'ensemble des caractères devant être retirés de la chaîne argument1 par des caractères et des méta caractères des expressions régulières, et on doit indiquer la séquence de caractères à extraire de argument1 grâce à l'expression régulière \(.*\) (dans le cas où la correspondance est impossible, le résultat de l'opération est la chaîne vide).

Options courantes:

Pas d'option.

Exemple :

Produit l'affichage suivant : carac On aurait pu écrire l'expression régulière sous d'autres formes.

Exemple : '\(.*\)t.*' '\(.*\)tères'

16

Codes de retour :

Résultat de l'opération non nul : 0 Résultat de l'opération nul : 1 Syntaxe incorrecte : 2 Opération interrompue pour cause d'erreur : > 2

Notez Bien

shift :

syntaxe

shift [n]

Description :

shift signifie "déplacer". Cette commande permet de réaliser un décalage vers la gauche (d'un rang ou plus) des valeurs des paramètres positionnels du shell courant.

Options courantes:

Pas d'option.

Exemple :

L'utilisation des cinq opérateurs *, >, >=, < et <=, parmi tous ceux qui ont été décrits ci-dessus, nécessite une vigilance particulière, car *, > et <, étant des méta caractères du shell, doivent être protégés. Pour ce faire, on peut soit les faire précéder d'un caractère \, soit les entourer de délimiteurs " ou '.

Dans le cas où la commande expr est lancée avec plusieurs

opérateurs, il faut être vigilant, car l'ordre des opérations ne

se fait ni de gauche à droite, ni de droite à gauche, mais

suivant un ordre prédéfini de priorité des opérateurs.

17

Cette commande est très utile quand vous avez un programme shell qui a besoin d’analyser des options de la ligne de commande. Les options sont précédées typiquement par un trait d’union et une lettre qui indiquent pour lequel l’option sera utilisée. Parce que les options sont traitées habituellement dans une boucle de n’importe quel genre, vous voudrez souvent parfois sauter au prochain paramètre de position si vous avez identifié quelle option devrait venir ensuite.

exit :

Description :

exit signifie "sortie".

Cette commande permet de sortir d'un shell, en précisant ou non la valeur du code de retour.

Notez Bien

Syntaxe :

exit [code_retour]

Options courante :

Pas d'option.

Toutes les commandes qu’on a citées ci-dessus se sont des commandes internes, qui peuvent donc fortement varier d'un shell à l'autre.

18

Exemple :

Si la commande : exit est tapée dans la fenêtre "racine", sans qu'aucun shell fils n'ait été lancé, cela provoque une déconnexion.

Autres commandes

Cd [rep]

==> permet de changer de répertoire; la valeur par défaut de [rep] est le contenu de la variable HOME, le chemin d'accès celui de CDPATH

exec cmd

==> exécute la commande cmd a la place du shell, sans création d'une nouveau processus et sans retour possible au shell

hash [-r] [nom]

==> hash nom inscrit le chemin d'accès a la commande (ou le script) nom, dans une table, d'ou une exécution plus rapide; -r vide la table

Pwd ==> affiche le répertoire courant

Times ==> affiche le temps d'exécution du shell

type [nom]

==> précise le type de commande et son chemin d'accès

Clear ==> Efface l’écran

Script Shell Dans la programmation Shell on a deux moyens pour programmer : Direct : C'est-à-dire écrire des commandes directement sous le terminal.

Script et cela qui nous intéresse ! Définition :

Script correspond à une suit des commandes écrite dans un ficher, cela permet d'automatiser certain tâches répétitive où bien d'écrire des petits programmes adoptés au besoin de l'utilisateur.

Réalisation d'un script :

19

Pour écrire un script trois étapes suffisent : Création d'un fichier :

Premièrement on doit ouvrir un fichier texte par un éditeur du texte de notre choix (vi, vim, emacs,nano…).

-Indication du nom du Shell qu'on va utiliser : La première ligne de ce fichier doit commencer par une ligne très importante qui doit utiliser cette syntaxe suivante : #!<emplacement du Shell> Et cette ligne est très importante car si le script est écrit pour bash et la personne qui va l’exécuter utilise sh, l’exécution ne sera fait pas exactement.

Exemple :

* Utilisation d'un autre Shell : Si on veux essayer un autre Shell on doit le télécharger comme n'importe quel paquet . On va écrire cette syntaxe dans un terminal toujours en mode administrateur (root) : # apt-get install csh

Une fois installé on revient à simple utilisateur et écrit la commande : $ chsh C’est à dire change Shell, après on nous demandera où se

trouve le programme qui gère le shell. Vous devrez indiquer par exemple /bin/ksh pour ksh, /bin/sh pour sh, /bin/bash pour bash, etc...

20

-Exécution des commandes : Une fois indiquer le nom du Shell qu'on va utiliser, on va passer à coder c'est-à-dire mettre dans ce script toutes les commandes qu’on veut exécuter, soit en respectant la règle du base qui consiste à ne mettre qu'une seule commande par ligne, où bien de séparer chaque commande par « ; »

Exemple :

Cet exemple est fait pour afficher le répertoire courant et lister toutes les fichiers et répertoires qui se trouvent dedans. On remarque dans cet exemple qu'il y a des lignes qui commence par # ce sont des commentaires qui n'exécutent pas mais ils permettent d'exprimer ce qui fait notre script. La première ligne commence aussi par un # c'est un commentaire mais « commentaire spécial » car il est suivis par un « ! ».

- Rendre le script exécutable :

Les fichiers sur linux ne sont pas exécutables comme le montre ce dernier

Alors pour que le script soit exécutable, le fichier doit avoir le droit « Exécutable », et pour rendre le fichier exécutable il suffit d'utiliser la commande $chmod +x.

-Exécution du script :

21

Pour exécuter le script on a le choix de choisir à partir de deux de cette méthode soit : - on écrit «. /nom script »

Exemple :

Sous terminal : - On écrit « echo $PATH » pour simplifier l'appel du script. Après on aura la liste des répertoires :

Après il suffit de déplacer le script dans un de ces répertoires, comme /bin, /usr/bin ou /usr/local/bin (ou encore un autre répertoire du PATH). Notez qu'il faut être root pour pouvoir faire cela.

Exemple :

22

Notez Bien

Les structures de contrôle:

comme dans tous les langages, une programmation effective n'est pas possibles sans

Structures conditionnels : la structure if et la structure case

Les boucles : les structures while, until et for

Notez Bien

Il Convient de préciser que chaque Shell à sa propre syntaxe, ce qui rend les choses un peu compliqué, c'est à dire la syntaxe sera différente en Tcsh ou Sh par exemple mais les concepts restent toutefois les mêmes.

Notez bien que nous sommes travaillés par défaut dans le Shell Bash.

Si on reste on mode simple utilisateur et nous essayons de déplacer où bien copier notre script dans un de ces répertoires, le terminal va nous donner un message d’erreur. arguments contenant des séparateurs alors que $@ le fait !

On peut dépasser où bien négliger la deuxième partie dans la création du script c'est-à-dire exécuter le script sans rendre exécutable avec cette syntaxe suivante : $sh nom-script où bien $bash nom-script

23

Pour bien comprendre les structures de contrôles, il est nécessaire d'utiliser une commande permettant la vérification d'une ou plusieurs conditions, c'est la commande test.

La commande test:

Qu'est-ce qu'un test ?

Un test et est une opération dont le but est d'évaluer la valeur d'une expression.

Cette expression peut être vraie ou fausse.

Si l'expression est vraie c'est-à-dire elle est bien exécutée

le test renvoie un code de retour égale à 0.

Si l'expression est fausse c'est-à-dire il ya une erreur soit

d'exécution ou une erreur syntaxique le code de retour est

différent de 0.

Pour afficher le code de retour tapant la commande echo $?.

Syntaxe :

Le Shell propose deux types qui sont équivalents test expression

24

[ expression ] Soit on écrit test expression soit tout simplement expression entre deux

accolades.

Exemple :

Notez Bien

Exemple :

Contrôleurs de test :

En bash il est possible d'affecter trois types test différents : des tests sur des chaines de caractères des tests sur des nombres des tests sur des fichiers

Maintenant on va découvrir chaque types commençant par : Les tests sur des chaînes de caractères :

Comme on savait déjà que les variables sont considérer comme des chaînes de caractères. Il est donc très facile de tester ce que vaut une chaîne de caractères.

Il est important de mettre des espaces à l'intérieur des crochets on

ne doit pas écrire [expression] mais [↔ expression ↔]

(↔:espace).

25

Exemple :

Cet exemple est vérifier si la chaîne est vide ou pas.

Exécution :

Tests sur les nombres :

26

Exemple :

Dans cet exemple suivant on va tester si un nombre est négatif ou pas.

Exécution :

27

Test sur des fichiers :

Un des avantages de bash sur d'autres langages est que l'on peut très facilement faire des tests sur des fichiers : savoir s'ils existent, si on peut écrire dedans, s'ils sont plus vieux, plus récents, etc.

Passant maintenait à les structures conditionnels:

1. la structure if

La structure if permet de tester une suite de commandes.

Le fonctionnement de cette structure est le même dans tous les langages

de programmation Seulement la syntaxe qui change. Si l'expression est

vraie c'est-à-dire son code de retour est égale à 0, alors if exécute les

commandes ….

28

Syntaxe :

En Bash la syntaxe plus générale de if est:

les mots clés sont if then elif else , et fi .

les crochets [] pour montrer que elif et else sont optionnels ont

peut les faires ou pas.

Le point virgule (;) pour regrouper plusieurs commandes .aussi il

est équivalent à retour à la ligne.

2. la structure case:(choix parmi multiple choix)

Lorsque on a beaucoup des cas à traiter il devient difficile d'utiliser if,

donc il existe une méthode plus pratique c'est sélectionner un choix parmi

multiple choix.

Syntaxe :

les mots clés sont case in esac.

if test condition_1 # ou if [ condition_1 ]

then commandes1

[ elif test condition_2 ; then commandes ]… [ else commandes3 ]

fi # l'envers de if (fin de bloc)

Case $variable in

Valeur1)

Commande1;;

Valeur2)

Commande2;;

….….

*) # tous les autres cas

Commande;;

esac # (l'envers de case) ( Fin de bloc case )

29

chaque ligne de commande doit se termine par double point

virgule.

Double point virgule dit à Bash d'arrêter là c'est-à-dire de sortir

de bloc case. Il est équivalent à break de switch de langage C.

Caractère * signifie un choix par défaut équivalant à else en if

c'est-à-dire tous les autres cas.

Comment fonctionne ?

La valeur de la variable est comparé en séquence avec chacun des choix

fournit (valeur 1, valeur2 …..) si elle correspond à un des choix alors les

commandes spécifiés sont exécutés et les choix suivant sont ignorés.

Pour exécuter une série de commande plusieurs fois on utilise les boules

3. boucles while et until

Syntaxe :

boucle while

boucle until

Comme vous remarquez la syntaxe de la boucle while et until est

exactement la même.

Je vais vous expliquer la différence entre ces deux boucles.

while condition

do

commandes

done

Until condition

do

commandes

done

30

On sait que la boucle while permet de répéter des commandes tant que

la condition est vraie mais la boucle until répète les commandes

jusqu'à ce que la condition est vraie ; c'est-à-dire la commande until

fonctionne à l'inverse de la commande while ,il exécute les commandes

tant que la condition est fausse.

Notez Bien

4. boucle for

La boucle for permet de parcourir une liste des valeurs définis c'est-à-dire

de boucler autant de fois qu'il ya des valeurs.

Syntaxe :

Pour bien comprendre la syntaxe et le fonctionnement de la boucle for. Je

vais vous expliquer cet exemple.

Ce qu'il faut retenir : jusqu’à ce que la condition est vraie répéter

équivalent à tant que la condition est fausse répéter.

31

J'ai crée un script nommé groupe qui affiche les membres de mon groupe.

La variable nom va prendre successivement les valeurs de la variable

nom (Soukaina Boujadi ,Soukaina Najihi,Soukaina ajankar,et Meryem

Abounasr).

Et la boucle for sera afficher à chaque fois la valeur de la variable nom.

En terminale je fais l'appel de mon script avec la commande. /groupe

Et voilà le résultat.

Les paramètres positionnels ou bien Les arguments des programmes shell Dans un script, les paramètres ou arguments, positionnés par l'utilisateur exécutant le script, sont automatiquement et toujours stockés dans des "variables automatiques"(remplies automatiquement par le Shell). Ces variables sont : $# Contient le nombre d'arguments reçus par le script en cours d'exécution. $0 représente le nom du script. $1, $2, $3 ... $9 les 9 premiers arguments passés au script. ${10}, ${11}, ${12} ... les arguments suivants passés au script (uniquement pour bash et ksh). $* et $@ contiennent la liste de l'ensemble des arguments passée au script.

32

Notez Bien Exemple :

La substitution Substitution de variables :

Sous le terme de substitution de variables, se cache simplement la possibilité d'attribuer une valeur par défaut aux variables (qu'elles soient non initialisées). ${var:-valeur} si la variable n'est pas vide, la substitution retourne sa valeur, sinon elle retourne valeur.

${variable:=valeur} si la variable n'est pas vide, la substitution retourne sa valeur, sinon elle va créer et initialiser la variable par valeur .

La différence entre les deux formes * et @ si situe au niveau de leur utilisation avec des guillemets : "$*" ne protège pas les éventuels arguments contenant des séparateurs alors que $@ le fait !

33

${variable:+valeur} Initialisée la variable avec "valeur" si elle est définie. Dans le cas contraire (non définie) la laisser vide.

${variable:?message} si la variable n'est pas vide, la substitution retourne sa valeur, sinon le shell affiche le nom de la variable suivi de la chaine de caractères message. De plus, si cette forme de substitution est utilisée dans un script shell, celui s'arrête immédiatement après l'affichage du message.

Substitution de commandes

La substitution de commandes permet l'utilisation du résultat de l'exécution d'une commande dans une autre commande, ou de l'affecter à une variable. La syntaxe peut indifféremment prendre 2 formes d'écriture $(COMMANDE) ou bien `COMMANDE` Exemple :

34

Aucun langage de programmation n'est parfait. Il n'existe même pas un

langage meilleur que d'autre ; il n'y a que des langages en adéquation ou

peu conseillés pour des buts particuliers.

Écrire des scripts shell n'est pas difficile à apprendre car, d'une part, les

scripts peuvent être construits par petites sections et, d'autre part, il n'y a

qu'un assez petit nombre d'opérateurs et d'options spécifiques au shell à

connaître. La syntaxe est simple et directe, similaire à une suite d'appels

de différents utilitaires en ligne de commande et il n'existe que peu de

« règles » à apprendre. La plupart des petits scripts fonctionnent du

premier coup et le débogage, même des plus longs, est assez simple.

La programmation shell ramène à la philosophie classique des UNIX, de

découper des projets complexes en sous-tâches plus simples et

d'assembler des composants et les utilitaires. Beaucoup considèrent que

cette approche de la résolution de problème est meilleure ou, du moins,

plus abordable que l'utilisation de langages de nouvelle génération

puissamment intégrés comme Perl, qui essaient de tout faire pour tout le

monde mais au prix de vous forcer à changer votre processus de réflexion

pour vous adapter à l'outil.

35

Réalisé par :

36