Présentation et cours Korn shell (compatible avec le Bash)

Le shell permet de réaliser des petits programmes qui deviennent des outils.
Ces outils faciliteront les tâches répétitives de l'administrateur, de l'utilisateur.
Pour le programmeur, un encapsulage de ces sources et un enchaînement de programmes peuvent être utiles.

Le shell est :

• l'interpréteur de commande ;
• l'interface entre l'utilisateur et les commandes ;
• un langage de programmation (interpréteur), il permet donc de réaliser de nouvelles commandes ;
• un gestionnaire de processus ;
• un environnement de travail configurable.

Le Korn shell regroupe les fonctions du C shell et du Bourne shell, tout en apportant de nouvelles propriétés, afin d'obtenir un shell plus convivial, plus puissant et plus rapide.

Le Korn shell a les possibilités supplémentaires suivantes :

• un historique des commandes peut-être mis en place et utilisé (vi ou emacs) ;
• une compatibilité Bourne shell ;
• des variables d'environnements supplémentaires (par exemple : la définition de dossiers) ;
• des commandes Bourne avec de nouvelles fonctionnalités (test, expr, echo) ;
• des sélections par menu possible ;
• des messages d'erreur plus significatifs ;
• des alias peuvent être créés.

Les différences entre le Korn shell et le Bash sont suffisamment faibles pour envisager des scripts communs.

Les choix possibles :

• le Bourne shell /bin/sh (sous AIX : /bin/bsh) ;
• le C shell /bin/csh ;
• le Korn shell /bin/ksh ;
• le Bourne shell again (Bash) /bin/bash.

Le positionnement d'un shell peut se faire :

• par l'administrateur (fichier /etc/passwd) ;

• après le login, par une demande utilisateur grâce aux commandes :

  • . bsh
  • . csh
  • . ksh
  • . bash

La variable SHELL est affectée lors du login et n'est plus modifiée par la suite (entre autres par les commandes précédentes).

Une fois le sous shell (bsh, csh ou ksh) démarré, il est possible de le quitter à l'aide de la commande exit ou CTRL D.

La forme générale est la suivante :

commande options arguments

Plusieurs commandes peuvent être passées sur une même ligne, pour ce faire, elles doivent être séparées par « ; ».

Les paramètres d'une commande peuvent être séparés par :

• une tabulation ou un blanc ;
• le caractère entré (« NL »).

Ces séparateurs sont définis par la variable IFS.

Dans le cas de commandes placées dans un fichier ASCII, celui-ci doit être rendu exécutable, ce fichier exécutable est également appelé script shell.

• Ce fichier est exécutable comme un processus.
• Ce fichier peut réaliser l'équivalent d'une suite de commandes UNIX ou (et) Korn shell.
• Ce fichier est exécuté sous le shell standard, sauf spécification contraire sur la première ligne du fichier.

Exemple :

#!/bin/ksh

Les commandes peuvent être lancées en avant plan (l'utilisateur doit donc attendre la fin de la commande avant de pouvoir exécuter la suivante).

Les commandes peuvent être lancées en arrière-plan (dans ce cas le numéro du process est visualisé et l'utilisateur peut continuer immédiatement à exécuter d'autres commandes).

Un processus lancé en arrière-plan peut être interrompu par la commande KILL ou CTRL Z.

Un script shell doit avoir des droits d'exécution pour que le shell en cours lance un shell pour l'exécuter.

Exemple:

script

Un script shell peut être lancé qu'il est ou non des droits d'exécution en passant le nom du script comme paramètre à un shell.

Exemple :

ksh script

Dans les deux cas précédents, un autre shell est exécuté, donc tout environnement modifié dans le script n'existera plus à la fin de l'exécution de ce script.

Pour visualiser les droits d'un fichier la commande ls peut être utilisée avec comme paramètre -al

Les droits sont visualisés ainsi :

Les droits de l'utilisateur, du groupe ou du reste du monde sont représentés par :

• absence d'autorisation ;
• r autorisation en lecture (en octal : 4) ;
• w autorisation en écriture (en octal : 2) ;
• x autorisation en exécution (en octal : 1) ;
• ou en droit de passage pour les dossiers.

Des droits par défaut sont positionnés lors de la création d'un fichier.

La commande umask permet de positionner les droits par défaut.

Le paramètre de la commande umask est une valeur de 3 chiffres exprimés en octal.

Exemple :

umask 022

Le masque de l'exemple positionne pour un fichier les droits suivants :

rw- r-- r--

Les droits sont calculés par la méthode suivante (complément à 666) :

• 666 octal de référence pour les fichiers ;
• 022 le umask ;
• 644 les droits par défaut soit rw- r-- r-- ;
• (110 100 100).

Du fait de l'octal de référence, il est impossible de positionner par défaut le droit d'exécution pour un fichier.

Pour un dossier (répertoire), l'octal de référence est 777 soit :

• 777 octal de référence pour les fichiers ;
• 022 le umask ;
• 755 les droits par défaut soit rwx r-x r-x ;
• (111 101 101).

Il est donc possible pour un dossier d'avoir les droits de passage par défaut.

La commande chmod permet de modifier les droits d'un fichier ou d'un dossier.

Il est possible de modifier les droits par :

• utilisation de l'octal correspondant au choix.

   

  Sélectionnez

  r-x r-x r-x

  Exemple : chmod 555 toto

  (555 correspondant à 101101101 en binaire)

• utilisation de symbole ;

• u pour l'utilisateur ;

• g pour le group ;

• o pour le reste du monde ;

• a pour tous (u et g et o) ;

• r pour lecture ;

• w pour écriture ;

• x pour exécution (ou passage) ;

• + pour ajout d'un droit ;

• - pour retrait d'un droit.

Exemples :

chmod gu+r toto
chmod uo-x *
chmod

Le shell utilise des variables d'environnement : (attention aux MAJUSCULES)

• PS1 pour le prompt primaire, par défaut $ ;
• PS2 pour le prompt secondaire, par défaut > ;
• PATH pour les répertoires de recherche des exécutables ;
• MANPATH pour les répertoires de recherche des fichiers de man ;
• LANG pour la langue utilisée ;
• HOME pour le dossier de base de l'utilisateur (appelé également home directory) ;
• LOGNAME pour le nom de l'utilisateur ;
• SHELL pour le shell utilisé ;

• le Korn shell utilise d'autres variables d'environnement nécessaires à l'utilisation de ses fonctions :

  • HISTFILE pour le fichier historique,
  • HISTSIZE pour la limite de commandes historiques accessibles,
  • EDITOR pour l'éditeur de ligne de commandes,
  • VISUAL pour remplacer $EDITOR si préalablement défini.

Le Korn shell a la possibilité de définir des variables désignées :

• RANDOM : pour définir un nombre aléatoire compris entre 0 et 2E 15 c'est-à-dire 32767.
• LINENO : pour définir le numéro de ligne courante d'un script shell ou d'une fonction.
• SECONDS : pour le temps écoulé depuis l'appel du shell (en secondes).
• PWD : pour le répertoire actuel.
• OLDPWD : pour le répertoire précédemment utilisé, c'est-à-dire avant le dernier cd.

Le Korn shell possède des fichiers de configuration spécifiques. Lorsque celui-ci est appelé lors de la connexion, ces fichiers de configurations sont alors exécutés :

• /etc/environment
• /etc/profile
• .profile

ENV=nom_fichier (par convention .kshrc)

À chaque nouveau lancement d'un Korn shell explicite (c'est-à-dire utilisation de l'appel ksh ou ksh nom_script ou # !/bin/ksh), il y a exécution du fichier affecté à la variable ENV.

On affecte les paramètres de ENV à l'aide de la commande export dans le fichier .profile

Exemple :

Export ENV=$HOME/.kshrc

La personnalisation est un des atouts majeurs du Korn shell.

I-G-1. Le fichier .profile (.bash_profile)▲

I-G-2. Les alias▲

I-G-3. Échantillon de fichiers .profile et .kshrc▲

ulimit -c 0

umask 022
PATH=\usr\ucb:\bin:/usr/bin :usr/local/bin : .
LPDEST=ps
EDITOR=emacs
MORE=-c
ARCH_DIR=/home/pubg95/archdir/
mesg y
biff y
PS1= « uname -n`-\ !> »
export PATH LPDEST EDITOR MORE ARCH_DIR PS1 
export TIMEOUT
echo « Entrez le type du terminal : \c » ; read tt
if [ « $tt » != « »] then
  TERM=$tt ; export TERM
  tset
endif

alias j=jobs
alias h=history
alias l= « ls -aFx »
alias ll= « ls -aFxl »
alias psa= « ps -ef | head »
export HISTSIZE=60 #le répertoire principal de #l'utilisateur est fixé à 60
#commandes

Le Korn shell peut stocker (sur demande), dans un fichier, les commandes passées en interactif.

Pour que le Korn shell débute l'historisation, il est nécessaire de configurer la variable VISUAL (dans le fichier .profile ou en interactif par : export VISUAL=vi) ou de passer la commande :

set -o vi.

Le fichier de stockage est .sh_history dans le dossier home de l'utilisateur, il est possible de modifier ce fichier de stockage par défaut en modifiant la variable HISTFILE.
Le nombre d'anciennes commandes disponibles dans ce mode est configurable par la variable HISTSIZE.

À partir du moment où ce mode est actif l'utilisateur peut quitter le mode insertion (type vi) pour revenir au mode commande de vi par la touche « Echap ».

L'ensemble des possibilités du mode commande de vi sont accessibles.

Par exemple :

• k permet d'extraire des commandes du fichier historique en arrière ;
• j permet d'extraire des commandes du fichier historique en avant ;
• l permet de déplacer le curseur vers la droite ;
• h permet de déplacer le curseur vers la gauche.

Cf. petit lexique de commandes vi en annexe.

L'édition des commandes peut également ce faire par la commande interactive fc.

$ fc commande

Les premières lettres de la commande suffisent, il est également possible d'appeler la commande par son numéro.

Un éditeur peut être choisi grâce à l'option -e.

Exemple :

fc -e vi commande

La réexécution d'une commande peut être réalisée par la commande r.

Exemple :

• r réexécute la dernière commande ;
• r commande réexécute la dernière commande débutant par commande.

Exemples :

fc -e - #pour réexécuter la dernière commande.
fc -e - nom_commande #pour réexécuter la dernière commande nom_commande.
fc -e vi 20 30 #vi édite les lignes 20 à 30 du fichier historique
fc -l #pour lister les 16 dernières commandes 
(16 par défaut)

La sortie standard (l'écran de votre console) peut être redirigée (remplacée) par un fichier ou une sortie.

Exemple :

ls >toto
#le fichier toto est créé et contient le résultat du ls.
#si toto existait, son contenu serait écrasé par le 
#résultat de ls

>vide
#le fichier vide est créé et ne contient rien.

ls >/dev/null
#la commande ls est exécutée, le résultat est poubellisé.

ls >>titi
#le résultat de ls est ajouté à la fin du fichier titi.

L'entrée standard (le clavier de votre console) peut être redirigée (simulé).

Exemple :

mail destinataire ‹ clavier
#le fichier clavier contient le texte à destination de bruno

Il est également possible de simuler une saisie dans un shell script par ‹‹.

Exemple :

mail destinataire ‹‹ END
tu as brillamment réussi ta formation Korn shell
félicitations
END

Les erreurs peuvent être redirigées explicitement.

Exemple :

titi 2>fichier_erreur

La commande titi n'existant pas le fichier fichier_erreur contiendra le message d'erreur.

La sortie standard et les erreurs peuvent être redirigées sur le même fichier.

Exemple :

ls -al 1>fichier 2>&1 
Les erreurs sont redirigées sur le descripteur 1 soit "fichier".

Il est possible d'utiliser le résultat d'une commande comme entrée de la commande suivante, pour ce faire, il existe le pipe |.

Exemple :

ls -al | more # cette commande est pratique pour #lister page par page.

Cette ligne est équivalente à :

ls -al >fichier
more ‹ fichier

Il est possible d'utiliser plusieurs enchaînements successifs :

ps -eaf | grep root | wc -l

La commande tee permet de stocker un résultat intermédiaire.

Exemple :

ps -eaf | tee fichier | grep root | wc -l

Le fichier contient le résultat de ps -eaf.

Une commande ou un enchaînement de commandes peut servir de paramètre à une commande.

Exemple :

cat $(cat liste_des_fichiers_a_concatener) >resultat

La syntaxe pour le Bourne shell est le « ` » (accent grave).

Exemple Bourne shell :

cat `cat liste_des_fichiers_a_concatener` >resultat

Une suite de commandes, sans interaction entre elles, peut être réalisée en intercalant un « ; » entre chaque commande.

Exemple :

ls -al ; who am i

Dans le cas de certaines commandes (entre autres les commandes d'impression) il est nécessaire de protéger le caractère « ; » par un « \ » avant celui-ci pour qu'il soit interprété comme caractère et non comme séparateur de commande.

Exemple :

print bonjour \; vous êtes au cours Korn shell

Résultat :

bonjour ; vous êtes au cours Korn shell.

Il y a donc création d'un nouveau processus fils.

Il est possible de grouper des commandes dans un autre shell en utilisant les parenthèses ().

Il y a donc création d'un nouveau processus fils. L'exécution s'effectue dans un nouvel environnement et sans modification de l'environnement actuel.

Exemple :

(export LANG=france ; echo $LANG) ; echo $LANG

Il est possible de rediriger les sorties de l'ensemble des commandes groupées.

Exemple :

(export LANG=france ; echo $LANG) >fichier

Il est possible de grouper des commandes dans un même shell en utilisant les accolades {}; ces accolades doivent être précédées et suivies d'un blanc.

L'exécution s'effectue dans le même environnement et donc avec modification de l'environnement actuel.

Exemple :

{export LANG=france ; echo $LANG; } ; echo $LANG

Il est possible de rediriger les sorties de l'ensemble des commandes groupées.

Exemple :

{export LANG=france ; echo $LANG;} >fichier

Il est à noter qu'un « ; » existe obligatoirement avant l'accolade fermée ; effectivement « } » et vu par le shell comme une instruction.

• L'opérateur d'exécution si échec || (ou logique).

Exemple :

more fichier || >fichier

Affichage du fichier ou, si l'affichage est impossible, création du fichier.

• L'opérateur d'exécution si réussite && (et logique).

Exemple :

more fichier && echo "une ligne de plus" >fichier

Affichage du fichier et, si l'affichage est possible, ajout d'une ligne dans le fichier.

• | le pipe ;
• & lancement en arrière-plan ;
• || ou logique ;
• && et logique ;
• ; fin de commande ;
• › redirection d'une sortie ;
• ‹ redirection d'une entrée ;
• 2$# redirection d'une erreur ;
• () groupage de commande dans un autre shell ;
• {} groupage de commande dans le même shell ;
• ` substitution de commande en Bourne shell ;
• $() substitution de commande en Korn shell ;
• \ inhibition.

Le symbole * sert à remplacer de 0 à plusieurs caractères.

Il est déconseillé d'utiliser le symbole * dans un nom de fichier.

Prêtez attention tout particulièrement à la commande rm qui est très dangereuse avec le symbole *. En effet, il existe un risque important d'effacer des fichiers importants de façon irrémédiable. Notez bien que cela n'arrive en général qu'une fois.

Exemple :

ls fichier*
#liste les fichiers dont le nom débute par fichier.

ls *c
#liste les fichiers dont le nom se termine par c.

ls *t*
#liste les fichiers contenant t dans leur nom.

Pour remplacer un seul caractère par n'importe quel caractère le symbole ? est utilisé.

Il est déconseillé d'utiliser le symbole ? dans un nom de fichier.

Exemple :

ls -al fich?er

Pour remplacer un seul caractère par une liste de caractères les symboles […] sont utilisés.

• [246] choix possible entre le caractère 2, le 4 ou le 6 ;
• [1-3] choix parmi les caractères compris entre 1 et 3 dans l'ordre alphabétique ;
• [!135] tous sauf les caractères 1, 3 et 5.

Il est déconseillé d'utiliser les symboles [] dans un nom de fichier.

Exemple :

ls [a-c]r?toto[!b]*
# liste les fichiers commençant par a b ou c suivi de r suivi de n'importe quel caractère
#suivi de la chaine toto suivi de tous sauf b et se terminant par n'importe quelle chaine 
#(y compris rien).

Un remplacement de 0 à n occurrences est réalisable par la symbolique :

• *( )

Il peut être nécessaire d'avoir plusieurs expressions permettant d'avoir différentes solutions (logique ou).

• Symbolique : |

Un remplacement de 1 à n occurrences est réalisable par la symbolique :

• +( )

Un remplacement de 0 à 1 occurrence est réalisable par la symbolique :

• ?( )

Un remplacement de une occurrence, exactement, est réalisable par la symbolique :

• @( )

Un remplacement de toutes les chaînes, sauf celles qui correspondent à une expression, est réalisable par la symbolique :

• !( )

Exemple :

ls -al *!(.[cho])

liste tous les fichiers sauf ceux se terminant par .c, .o ou .h.

Il s'agit de commandes contenues dans le programme KSH. Elles ne créent pas de processus et laissent l'environnement inchangé. Leur exécution est rapide.

• CD : Change Directory ;
• cd : sert à se déplacer dans l'arborescence.

* Particularités KSH :

Le KSH utilise des variables d'environnements facilitant le déplacement dans l'arborescence.

• PWD : dossier courant.
• OLDPWD : dossier précédent.
• cd - :retour au dossier précédent

Exemple :

$ pwd
/home/masociété
$ cd /etc
/etc
$ cd -
$ pwd
/home/masociété

CDPATH : variable contenant des chemins d'accès aux répertoires et permettant l'accès direct.

Exemple :

$ export CDPATH=/home/user1:/home/user1/tp:/home/rep
$export S1='$PWD $'
/home/user1 $ cd tp
/home/user1/cours/tp $ cd rep
/home/user2/rep $ cd exo
/home/user1/cours/exo $

wait (n) permet de conditionner l'exécution du process père à la fin du process fils dont le PID est n.

kill permet d'émettre un signal vers un autre processus.

kill -signal PID

La liste des signaux est dans /usr/include/sys/signal.h ou accessible via la commande kill -l

Il est possible d'envoyer des signaux par l'intermédiaire du clavier :

• ‹ CTRL C› signal 2 (INT) ;
• ‹ CTRL D› signal 3 (QUIT) ;
• ‹ CTRL Z› signal 17 (STOP).

Pour terminer un processus, il suffit de lui envoyer le signal -15 : kill -15 PID

La plupart des utilisateurs utilisent le signal -9 :

trap associe une exécution de fichier à la réception d'un signal :

trap action signal

trap '$home/.finish' INT # exécution de .finish à la réception du signal INT

trap " " signal # désactive le signal

Conseil : utiliser les symboles des signaux plutôt que leur valeur.

ulimit permettent de visualiser ou de positionner les limites des ressources du système.

Visualisation :

ulimit -a # toutes les limites du système (dépendent de l'*nix)

Positionnement :

ulimit -c ulimited (mise a taille illimitée du fichier « core » (système Linux) indispensable pour déboguer !).

ou ulimit -c 150000 (mise à 150000 octets).

Les droits de chaque utilisateur sur ses propres fichiers sont positionnés à la création du compte par la commande umask.

Ces droits peuvent être changés par l'utilisateur.

Visualisation :

$ umask
$ 022 # masque par défaut

Positionnement :

$ umask 004 # pas de droit de lecture pour les autres
$ umask 020 # pas de droit d'écriture pour le groupe

alias permettent de donner un synonyme à une commande ou à un groupement de commandes.

Cela permet de gagner du temps et de simplifier les commandes.

On peut mettre un certain nombre d'alias dans le fichier .profile (cf. personnalisation).

La syntaxe est la suivante : alias nom_alias = ' commande '

Exemple :

$ alias l='ls-al|more' # est une commande très #pratique.
$ alias goappli='cd /home/compte_appli/appli'

Pour obtenir la liste des alias définis : alias.

whence (type) permet de connaître le chemin absolu d'une commande, d'un exécutable ou son type (option -v uniquement whence).

Exemple :

$ whence vi
/usr/bin/vi
$ whence -v pwd
pwd is shell built-in

En bash pour connaître le type du fichier c'est la commande : file

Ces commandes sont des fichiers exécutables que l'on trouve dans /bin ;/usr/bin ;/etc; voir /sbin et /usr/local/bin.

L'ordre de recherche correspond à celui mis dans la variable PATH des fichiers :

• /etc/profile (/etc/bash_profile et/ou /etc/profile.d/*)
• $HOME/.profile ($HOME/.bash_profile)

find effectue une recherche récursive dans toute l'arborescence à partir du répertoire spécifié.

Syntaxe :

find répertoire critère_recherche commande

répertoire est le répertoire de départ de la recherche : /toto; /;

Et critère_recherche est le critère de recherche des fichiers.

Cela peut être :

• par nom -name toto ;
• par user -user toto ;
• par type -type f fichier, exécutable… ;
• et bien d'autres (voir man find).

commande est la commande appliquée aux fichiers trouvés :

• -print pour les imprimer à l'écran ;
• -ls pour les lister ;
• -exec … pour leur appliquer des commandes plus complexes.

Exemples :

$ find . -user user1 -print

#à partir du répertoire courant afficher les fichiers et répertoire du user user1
$ find / -type f -name *.core -exec rm {} \;

#à partir de la racine rechercher les fichiers *.core et les détruire,
# {} remplace les fichiers trouvés par le find et le \ protège-le ;
# de l'interprétation du shell, en effet il est utilisé pour terminer le -exec

$ find / -name "*toto" -user toto -print;

#à partir de la racine, recherche des fichiers finissant par la chaîne
# "toto" et appartenant à l'utilisateur toto

$find / \( -type f -name "toto*"\) -o \(-type d -name tata \)
# à partir de la racine recherche des fichiers de type ordinaire
# commençant par la chaîne toto OU de type répertoire de nom "tata"

head n fic

• visualise sur la sortie standard les n premières lignes du fichier fic.

tail -n fic

• visualise sur la sortie standard les n dernières lignes du fichier fic.

tail -f

• fic permet de visualiser la fin du fichier fic. Si celui-ci croît, l'affichage est mis à jour.

grep permet de rechercher une chaîne de caractères.

$ grep masociété * pour rechercher toutes les chaînes de caractères contenant masociété dans le répertoire courant.

Résultat :

fic1: masociété est aux services de ces clients.
fic2: ils seront référencés par le code : masociété_client

$ grep -l masociété * pour rechercher les fichiers contenant masociété dans le répertoire courant.

Résultat :

fic1:
fic2:

$ grep -w masociété * pour rechercher les fichiers ne contenant pas masociété dans le répertoire courant.

grep peut également être utilisé dans un pipe.

ps -eaf |grep ksh|wc -w pour retourner le nombre de processus Korn Shell tournant sur la machine +1, grep ksh étant lui aussi un processus.

Pour éviter cet effet, il suffit de rajouter en find de commande : | grep -v grep!

le ET logique et donc obtenue via une succession de | par contre grep ne sait pas réaliser le OU logique pour ceci utiliser la commande egrep

sed est un éditeur permettant de modifier un ou plusieurs fichiers.

Syntaxe :

sed 's/ancienne_chaîne/nouvelle_chaîne/g liste_fichiers

Plusieurs substitutions en une fois :

ls -al |sed -e 's/rwx/7/g' \
-e 's/rw-/6/g' -e 's/r-x/5/g'\
-e 's/r--/4/g' -e 's/-wx/3/g'\
-e 's/-w-/2/g'-e 's/--x/1/g'

Cette commande affiche la liste longue des fichiers en remplaçant les permissions rxx par leur valeur hexa.

On peut passer par l'intermédiaire d'un fichier.

$ cat substit
s/rwx/7/g
s/rw-/6/g
s/r-x/5/g
s/r--/4/g
s/-wx/3/g
s/-w-/2/g
s/--x/1/g

$ ls -al |sed -f substit

sed sait aussi ajouter ou supprimer, voir le man.

cut extrait les colonnes ou les champs précisés.

• par colonnes : option -c

ls -al |cut -c16-24,34-40

une colonne : un caractère, liste des propriétaires et la taille des fichiers.

• par champs : option -f, le séparateur est par défaut la tabulation, si l'on désire le changer d'option -d.

Exemple :

$ more cours
COURS nb_jour nb_participant
UNIX 3 10
KSH 2 5
ADM 5 10

$ more cours |cut -d=' ' -f1,3
COURS nb_participant
UNIX 10
KSH 5
ADM 10

awk est un outil très puissant et très utilisé sous UNIX, il permet de mettre en forme, de modifier le contenu des fichiers.

awk traite chaque ligne du fichier référence, les champs séparés par un blanc, les nomme $1,$2…, ce qui facilite leur manipulation.

ls -al |awk '{print $3,$5}'

affiche les propriétaires et la taille des fichiers.

awk est un langage complet orienté édition, et comporte bien d'autres possibilités, notamment les fonctions, bibliothèque mathématique… reportez-vous au manuel.

Il existe 2 types de variables shell :

• les variables d'environnements utilisées pour configurer l'environnement de travail : PS1, PWD, HOME… ;
• les variables utilisateurs définies pour ces propres besoins.

Les principales commandes de manipulation des variables sont :

• echo ;
• print ;
• export ;
• read ;
• set ;
• unset ;
• shift.

Ces commandes sont internes aux shell et ne créent donc pas de sous shell.

L'affectation se fait par l'intermédiaire du signe =, on accède à la valeur de la variable par le métacaractère $.

$ societe=masociété
$ print $societe
masociété

$ a='bonjour à '
$ b='ce soir'
$ c=' 22 heure'
$ print $a $c
bonjour à 22 heures
$ print $a $b $c
bonjour à ce soir 22 heures

print ${a}"à demain"
bonjour à demain

#La commande unset désaffecte une variable.
$ unset a

$ print $a
$

a="var1"
ab="var2" 

un print $a donnera :
var1
un print $ab donnera :
var1b

faire print ${ab} donnera le bon résultat

Il est possible d'affecter le résultat d'une commande à une variable.

Exemple :

$ nom_machine=$(hostname)
$ print $ nom_machine
masociété
$ print unix>cours #cours : fichier

$ var=$(‹mois) #var : variable
$ print $var
unix
$ ls -l fic*
fic1
fic2
fic3
$ liste=$(ls -l fic*)
$ print $liste
fic1 fic2 fic3

Remarque : dans ce cas les espaces, les tabulations et NL sont remplacés par un espace

Exportation de variables :

Les variables ne sont connues que du processus qui les ont créés, il est donc nécessaire de les transmettre aux processus fils de celui-ci.

La commande export permet aux variables d'être visibles par tous les processus fils.

$ variable=12
$export variable
$ export LANG=fr_FR

Mise en évidence des problèmes de visibilités de variables :

$ a=coucou
$ echo $a
$ coucou

$ ksh # lancement d'un shell fils
$ echo $a
$ # a n'est pas connu
$ a=voila
$ echo $a
$ voilà
$ exit # on quitte le fils pour retourner au père
$ echo $a $ coucou # le fils n'a pas modifié la variable du père

read permet de lire des données sur l'entrée standard, de les affecter à une variable ou à la variable d'environnement REPLY. IFS est utilisé comme séparateur lorsque plusieurs variables sont saisies à la fois

$ read jour

jeudi
$ print $jour
jeudi
$ read

nous sommes jeudi
$ print $REPLY
nous sommes jeudi

#Pour afficher un message avant de saisir une variable, on utilise read ?.

$ read a?"valeur de a : "
valeur de a : 1
$ print a=$a
a=1

#La concaténation des variables est possible par l'intermédiaire des accolades {} :

$ a=chaise;as=fauteuils
$ print nous avons 10 $as
nous avons 10 fauteuils
$ print nous avons 10 ${a}s
nous avons 10 chaises

Longueur d'une variable : ${#var}

$ print PATH a ${#PATH} caractères
PATH a 89 caractères

La substitution d'une variable par une autre dépend de son état :

• non définie ;
• définie mais vide ;
• définie et non vide.

De plus, il existe trois types de substitution :

• temporaire : signe - ;
• réelle, jusqu'à la prochaine modification : signe = ;
• impossible, protection : signe ?

VI-C-1. Substitution temporaire▲

${var-$sub} vaut var si var existe sub sinon
$ var='variable';sub='defaut'
$ print ${var-$sub}
variable

$ var=''
$ print ${var-$sub}
$ unset var
$ print ${var-$sub}
défaut

${var:-$sub} vaut var si var est non vide sub sinon
$ var='variable';sub='defaut'
$ print ${var:-$sub}
variable
$ var=''
$ print ${var:-$sub}
défaut
$ unset var
$ print ${var:-$sub}
défaut

VI-C-2. Substitution réelle =▲

${var=$sub} #vaut var si var existe sub sinon
$ var='variable';sub='defaut'
$ print ${var=$sub}
variable
$ var=''
$ print ${var=$sub}
$ unset var
$ print ${var=$sub}
défaut

${var:=$sub} #vaut var si var est non vide sub sinon
$ var='variable';sub='defaut'
$ print ${var:=$sub}
variable
$ var=''
$ print ${var:=$sub}
défaut
$ unset var
$ print ${var:=$sub}
défaut

VI-C-3. Substitution impossible ?▲

${var?$sub} #affiche le texte puis stop
$more proc1
var='variable';sub='message'
print ${var?$sub}
var=''
print ${var?$sub}
unset var
print ${var?$sub}
$
$proc1
variable
proc1[6]: var:message

${var?$sub} #affiche le texte puis stop
$more proc2
var='variable';sub='message'
print ${var:?$sub}
var=''
print ${var:?$sub}
unset var
print ${var:?$sub}
$
$proc2
variable
proc1[3]: var:message

La commande typeset positionne, réinitialise ou affecte les variables selon différentes options :

-L cadrage à gauche :

$ var=MASOCIÉTÉ;print $var
MASOCIÉTÉ
$ typeset -L3 var ;print $var
MAS

-R cadrage à droite :

$ var=MASOCIÉTÉ ;print $var
MASOCIÉTÉ
$ typeset -R4 var ;print $var
CIÉTÉ

-Z cadrage à droite et remplissage par des 0 à gauche :

$ typeset -Z8 var=$(who | wc -l)
00000005

-conversion en majuscule -u ou en minuscule -l :

$ var=masociété ; print $var
masociété
$ typeset -u var ; print $var
MASOCIÉTÉ
$ typeset -l var ; print $var
masociété

-protection d'une variable en lecture uniquement -r :

$ typeset -r var 
$ var=bonjour
ksh: var is read only
$ # autre méthode
$ readonly a
$ a=bonjour
ksh: a is read only

Si un accès en écriture est tenté dans un shell script, il est interrompu - supprimer un attribut + :

$ typeset -r var 
$ var=bonjour
ksh: var is read only
$ typeset +r var 
$ var=bonjour;print $var
bonjour

Le KSH (Bash) permet de manipuler des tableaux uniquement à une dimension et d'au maximum 1024 éléments (de 0 à 1023).

Il est nécessaire de déclarer un tableau. Les attributs de variables s'appliquent à tous les éléments du tableau.

Affectation :

#simple
$ tableau[1]=toto
$ a[4]=10
$
#multiple
$ set -A tab 1 2 3 4
#équivaut à
$ tab[0]=1
$ tab[1]=2
$ tab[2]=3$ tab[3]=4
$
affichage :
$
$ print ${tableau[1]}
toto
$ print ${a[12]}
10
$ print ${tab[0]}

1 $ print ${a[*]} # affiche tout le tableau en même temps
1 2 3 4
$ print ${#a[*]} # affiche la taille d'un tableau
16
$ print ${#a[12]} 
4

Voici la syntaxe d'un appel de script en KSH (Bash ou autres) :

commande arg1 arg2 arg3 ..... argn

À chaque champ de cette ligne est affecté un certain nombre de paramètres utilisables dans le fichier script.

• $0 nom de la commande, du script ;
• $1 premier argument ;
• $2 deuxième argument ;
• $n n ième argument ;
• ${n} n ième argument (n >9) ;
• $# nombre d'arguments excluant $0 ;
• $* tous les arguments ;
• $@ tous les paramètres.

Exemples :

affich argua argub arguc

$ more affich
print $0
print $1
print $3
print $#

$ affich argua argub arguc
affich
argua
arguc
3

#attention au-delà du 9e argument
$ print $1
argua
$ print $12
argua2
$ print ${12}
$

En shell (sh) au-delà du 9^e argument il n'est plus possible de l'utiliser directement il faut passer par la commande shift

Autres paramètres disponibles :

• $? valeur du code retour du dernier processus lancé (Rappel : un zéro indique que l'opération a réussi, un 1 ou autre, que l'opération n'a pas abouti) ;
• $$ PID du process lancé par le script s'exécutant ;
• $! PID du dernier process lancé en background.

shift permet de décaler le contenu de ces paramètres et de décrémenter $#

$more fonc
print ' $# vaut : '$# et '$1 vaut : '$1
shift
print ' $# vaut : '$# et '$1 vaut : '$1
shift
print ' $# vaut : '$# et '$1 vaut : '$1
shift
print ' $# vaut : '$# et '$1 vaut : '$1
shift
print ' $# vaut : '$# et '$1 vaut : '$1
shift
$ fonc aa bb cc dd ee
$# vaut : 5 $1 vaut : aa
$# vaut : 4 $1 vaut : bb
$# vaut : 3 $1 vaut : cc
$# vaut : 2 $1 vaut : dd
$# vaut : 1 $1 vaut : ee

La commande set permet d'affecter une variable d'environnement (cf. set -o vi), mais aussi d'affecter à n'importe quelle variable les paramètres $1, $2,$ #…

La commande set sans argument permet de lister les variables définies, avec leurs valeurs .

Exemple :

$ set titi tata toto
$ print $2 $3
tata toto
$ print $1
titi
$set coucou
$ print $1 $2 $3
$ coucou #si réaffectation les paramètres sont remis à vide
$
#affectation d'un résultat d'une commande aux paramètres $1, $2,$ #...
$
$ set $(hostname)
$ print le nom de la machine est $1
$ le nom de la machine est MaMachine

#affectation des tableaux set -A
$ set -A tab il fait beau
$ print ${tab[*]}
il fait beau

Le Korn shell offre de nouvelles possibilités à cette commande set :

• Set -o permet de lister les options et les paramètres du ksh ;
• set -o option permet d'activer d'une option ; ou set -L option

Exemple :

set -a #allexport permet d'exporter automatiquement chaque variable définie
set +o option #permet de désactiver l'option
#ou set +L option

Cette commande permet d'évaluer une expression selon la syntaxe suivante :

test expression
ou [expression]

Cette commande renvoie un 0 si l'expression est vraie, une valeur différente de 0 si l'expression est fausse (en général, la valeur 1).

Le Korn shell (Bash ) possède une version améliorée qui accepte des opérateurs de test plus nombreux et des métacaractères non étendus, rendant la commande test moins utilisée.

• [[ expression ]] pour les expressions « chaînes » ;
• (( expression )) pour les expressions numériques ;

• exp1 && exp2 si exp1 est correcte alors on exécute exp2.
• exp1 || exp2 si exp1 est incorrecte alors on exécute exp2.

Cas de la syntaxe [[ ?. ]] :

• [[exp1 && exp2]]cette expression est vraie si les deux expressions exp1 et exp2 sont vraies (la deuxième n'est évaluée que si la première est validée).
• [[ exp1 || exp2 ]] cette expression est vraie si aucune des deux expressions n'est vraie.
• [[ !exp ]] ceci permet l'inversion logique.

Idem pour la syntaxe (( ?. ))

Il existe de nombreux opérateurs de test qui permettent d'examiner l'état d'un fichier suivant la syntaxe suivante :

test option nom_fichier
ou test nom_fichier1 option nom_fichier2
ou [ option nom_fichier ]

Les options peuvent être :

• -f pour un fichier ordinaire existant ;
• -d pour un répertoire ;
• -s pour un fichier de taille supérieure à 0 ;
• -e pour fichier existant (fichier générique) ;
• -x pour fichier existant et exécutable ;
• … voir le manuel.

Le Korn shell présente des tests supplémentaires souvent pratiques :

• -o pour un fichier existant dont le propriétaire est l'ID utilisateur effectif ;
• -s pour un fichier spécial socket ;
• fichier1 -ef fichier2 pour tester si l'I-node du fichier1 est égale à l'I-node du fichier2 ;
• fichier1 -nt fichier2 pour tester si fichier1 est plus récent que fichier2 ;
• fichier1 -ot fichier2 pour tester si fichier1 est plus ancien que fichier2.

La syntaxe [[ ? ]] du Korn shell offre des expressions de tests supplémentaires :

• [[chaine1=chaine2]] pour tester si chaine1 est égale à chaine2 ;
• [[chaine1 !=chaine2]] pour tester si chaine1 n'est pas égale à chaine2 ;
• [[chaine1‹chaine2]] pour tester si la chaine1 est placée avant la chaine2 d'après le classement ASCII (codage des caractères *) ;
• [[chaine1›chaine2]] pour tester si la chaine1 est placée après la chaine2 d'après le classement ASCII (codage des caractères *).

* Les variables LC_TYPE LANGUAGE LC_MESSAGES LC_ALL LANG LESSCHARSET modifie l'ordre de comparaison des caractères donc des chaînes.

Les opérateurs arithmétiques :

• + : addition ;
• - : soustraction ;
• * : multiplication ;
• / : division ;
• ^ : puissance ;
• % : modulo, reste de la division entière ;
• () : priorité des calculs.

Les opérateurs de comparaisons :

• ‹ : inférieur ;
• › : supérieur ;
• ‹= : inférieur ou égal ;
• ›= : supérieur ou égal ;
• == :égal ;
• != : différent.

Les opérateurs logiques

• () : priorité des tests ;
• ! : non logique ;
• && : et logique ;
• || : ou logique.

1. De gauche à droite.
2. Les parenthèses.
3. * / %.
4. + - 5 : les comparaisons.
5. Les opérateurs logiques.

Il est possible d'utiliser les différentes bases (décimale, octale, hexadécimale ou binaire) pour définir une variable arithmétique.

Pour cela on utilise la commande typeset de la façon suivante :

typeset -i8 y=4
#on définit y à 4 en octal.

typeset -i2 x=6
#on définit x à 6 en binaire.

Exemple de script de conversion d'un nombre décimal en hexadécimal :

# script conversion (du type :conversion nombre)
# !/bin/ksh
var=$1 #var correspond au premier et donc au seul 
print « $var » #paramètre passé dans le script
typeset -i16 hexadecimal=$var
print « $hexadecimal »

Les commandes let et (( )) sont équivalentes, elles servent à :

#affecter des variables numériques.
$ let x=1
$ (( x=4 ))
#faire des calculs
$ let x=x+1
$ (( i +=1 ))
#évaluer les tests numériques
$ (( (x=x-1) ‹ 0 ))

Remarques :

Le ksh ne peut gérer que des nombres entiers relatifs compris entre -2³¹ et 2³¹.

Pour les calculs en décimaux utiliser la calculatrice bc -l.

Les calculs peuvent ce faire dans n'importe quelle base entre 2 et 32.

bc est une calculatrice interactive, elle peut effectuer des calculs réels et des calculs complexes (Cos, Sin, exposant grâce à l'option -l). On sort du mode interactif de la calculatrice par ‹CTRL +D› ;

$bc -l
(12+21)/7
4.714285714286
<CTRL D>

Exemple d'usage :

$ print "(12+21)/7" | bc
$ 4 Exemples de fonctions :
sqrt (x) pour 
s (x) pour sin(x)
c (x) pour cos(x)
e (x) pour exp(x)
l (x) pour ln(x)
a (x) pour arctan(x)
lenght (x) pour définir le nombre de chiffres significatifs
scale (x) pour le nombre de chiffres à droite du séparateur décimal

Les structures du type :

if - then -else - fi
Until et while, do ? done
For et case, do .. done

Sont utilisables par le Korn shell de la même manière que par le Bourne shell.

Le Korn shell offre la possibilité supplémentaire d'utiliser la syntaxe [[ ? ]]dans l'élaboration des tests.

Exemples :

if [ -f mon_fichier ]
then
   print mon_fichier existe
else
   print mon_fichier inexistant
fi

while true
do
   ??boucle infinie
done

for i in fic1 fic2 fic3
do
   ls -l $i
done
#pour lire un fichier texte ligne a ligne while read ligne
do
   echo $ligne
done ‹ le_fichier_a_lire

#pour effectuer une action sur la liste des arguments il suffit : for i in
do
   ls -l $i
done

La structure select permet de créer un menu de la façon suivante :

select x in option1 option2 option3 
do
    Commandes qui utilisent l'identificateur x
    (il s'agit souvent de la structure case)
done

Un message d'invite à faire un choix est contenu dans la variable d'environnement PS3.

PS3= « choisissez une option »

Le menu, c'est-à-dire les choix possibles est affiché automatiquement.

Exemple :

clear PS3= « choisissez une option numérique du menu »
select jour in lundi mardi mercredi jeudi vendredi fin
do
    case $jour in
    lundi) print réunion avec Monsieur X ;;
    mardi) print déplacement à Paris ;;
    mercredi) print repos ;;
    Jeudi) print arrivée clients entreprise X ;;
    vendredi) print réunion mise au point ;;
    fin) exit ;;
    *) print choisissez un jour de la liste SVP ; ;
    esac
exec $0 done

La commande 'exec $0' relance-le shell permettant ainsi d'avoir un affichage correct.

Il est nécessaire de prévoir tous les cas possibles de choix. C'est pourquoi on utilise toujours le cas *) qui prend en compte les choix différents de ceux décrit dans le menu. Si l'utilisateur tape une option non prévue dans le menu, on l'invite souvent à retaper une nouvelle option contenue dans le menu.

Les commandes break et continue permettent respectivement d'interrompre une boucle ou de continuer celle-ci sans exécuter le bloc de commande suivant.

En Korn shell (ou bash) il est possible d'indiquer avec ces commandes une sortie de boucle imbriquée :

while condition1
do
    while condition2
    do
        if (( condition ))
        then
            break 2
        fi
    done
done

Dans cet exemple le break sort de deux niveaux de boucle soit sort de la 1re boucle while (condition 1).