Systèmes

CentOS 7

centos logo

Etiquettes: 

Divers

CentOS: Les différents paquets à installer

Voici une liste des paquets à installer en priorité:

# yum install \
epel-release.noarch \
bash-completion.noarch \
bash-completion-extras.noarch \
net-tools.x86_64 \
dpkg-devel.x86_64 dpkg-dev.noarch dpkg.x86_64 \
perl-Apache-Htpasswd.noarch \
python34.x86_64 \
gcc.x86_64 \
python34-devel.x86_64 \
python-devel.x86_64 \
python-pip.noarch \
python34-setuptools.noarch \
glances.noarch \
python34-pip.noarch \
man-db.x86_64 \
bind-utils

Liste non exhaustive.

Etiquettes: 

CentOS: Quelques commandes utiles

Lister les paquets installés

# yum list installed

Connaitre le statut d'un service (exemple avec le service ntpd)

# systemctl status ntpd

ou

# service ntpd status

Redémarrer le réseau

# systemctl restart network

Activer un service (exemple avec le service nginx)

# systemctl enable nginx

Démarrer un service (exemple avec le service nginx)

# systemctl start nginx

 

CentOS: localtime

Pour configurer le bon fuseau horaire sur CentOS, il faut indiquer les bons paramètres dans le fichier /etc/localtime

On trouve dans le dossier /usr/share/zoneinfo tous les fichiers pour toutes les zones de la planète.

Il suffit donc de faire un lien entre le bon fichier fichier correspondant à la zone souhaitée et le fichier /etc/localtime.

# unlink /etc/localtime
# ln -s /usr/share/zoneinfo/Europe/Paris /etc/localtime

 

Etiquettes: 

Réseau

CentOS: Configuration IP statique

Sous CentOS, la configuration de l'interface réseau avec une adresse IP statique diffère de celle sous Debian ou Ubuntu.

Pour identifier les cartes réseaux présentes sur la machine, exécuter la commande suivante:

# nmcli d

Pour une configuration avec un assistant, exécuter la commande suivante et suivre les indications à l'écran:

# nmtui

Une fois la configuration réseau terminée, assistée ou manuelle, redémarrer le service réseau:

# systemctl restart network

Pour une configuration manuelle, voir ci-dessous.

Sous CentOS, il faut créer un fichier ifcfg-eth0, correspondant bien sûr au nom de l'interface réseau à configurer. Dans ce cas, il s'agit de l'interface eth0.

Ce fichier est à créer dans le dossier /etc/sysconfig/network-scripts

Il doit contenir les informations suivantes:

# cat /etc/sysconfig/network-scripts/ifcfg-eth0
DEVICE="eth0"
HWADDR="A6:B5:6C:4F:E5:C0"
NM_CONTROLLED="no"
ONBOOT="yes"
BOOTPROTO=static
# BOOTPROTO=dhcp
IPADDR=172.16.1.115
NETMASK=255.255.255.0
#
#   the GATEWAY is sometimes in: /etc/sysconfig/network
GATEWAY=172.16.1.1

Les paramètres à renseigner sont assez explicites.

Il faut également modifier le fichier /etc/sysconfig/network

# cat /etc/sysconfig/network
NETWORKING="yes"
DNS1=8.8.8.8
DNS2=8.8.4.4
SEARCH=mondomaine.fr

Là également, les paramètres à renseigner sont assez explicites.

Reste à exécuter la commande suivante afin d'initialiser les différents scripts.

# rpm -qd initscripts

Et voilà, c'est terminé. Redémarrer le serveur afin de prendre en compte les modifications.

La commande ifconfig permet de vérifier que tout est correct.

Si la commande ifconfig n'est pas installée:

# yum install net-tools.x86_64

Puis:

# ifconfig
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 172.16.1.115  netmask 255.255.255.0  broadcast 172.16.1.255
        inet6 fe80::a4b5:6cff:fe4f:e5c0  prefixlen 64  scopeid 0x20<link>
        ether a6:b5:6c:4f:e5:c0  txqueuelen 0  (Ethernet)
        RX packets 43646  bytes 64538893 (61.5 MiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 20396  bytes 1157263 (1.1 MiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        inet6 ::1  prefixlen 128  scopeid 0x10<host>
        loop  txqueuelen 0  (Local Loopback)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

 

GNU/Linux

Logo Linux
Tous mes trucs et astuces pour utiliser GNU/Linux

Programmation shell sous GNU/Linux

Bash Shell

Qu'est ce que le shell sous GNU/Linux ?

Le shell est à Linux ce que MS-DOS est à Windows.

En effet, sur un système GNU/Linux, il est très important de connaitre les bases du shell.
Même si les interfaces graphique sont là pour simplifier les opérations, il est parfois nécessaire, voir indispensable, de savoir utiliser des commandes GNU/Linux.

Parfois, il n'y a pas toujours de programmes avec de belles interfaces graphiques pour faire ce que nous souhaitons.
Parfois, il est plus simple et plus rapide de faire telle ou telle action via les lignes de commandes.

Rechercher des fichiers, créer des répertoires, rechercher du texte dans plusieurs fichiers, renommer en masse tout un ensemble de fichier selon certains critères, se déplacer au sein de l'arborescence GNU/Linux etc etc ...

Et enfin, le plus important, écrire ses propres scripts afin d'automatiser certaines actions répétitives.

Extraits du livre "Programmation Shell sous Unix / Linux" aux éditions ENI que je conseil très fortement de se procurer.

Programmation shell sous Linux

Les mécanismes du shell

Commandes internes et externes

Les commandes externes

Une commande externe est un fichier présent dans l'arborescence.

Quand un utilisateur exécute la commande ls, le shell demande au noyau Linux d'exécuter le fichier /bin/ls

Sont considérés comme commandes externes, tous les fichiers au format binaire exécutable ainsi que tous les fichiers au format texte représentant un script de commandes.

La commande file indique le type de données contenues dans un fichier.

$ file /bin/ls
/bin/ls: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.15, stripped

$ file monscript
monscript: POSIX shell script text executable

L'argument de la commande file est un nom de fichier indiqué en relatif ou en absolu

Etiquettes: 

Les commandes internes

Une commande interne est intégrée au processus shell.

Elle n'a aucune correspondance avec un fichier sur le disque.

La commande type indique si une commande est interne ou externe.

$ type cd
cd est une primitive du shell

$ type ls
ls est un alias vers « ls --color=auto »

La commande type prend en argument le nom d'une commande. Si cette dernière n'est pas une commande interne, elle est recherchée dans les répertoires indiqués dans la variable PATH

Etiquettes: 

Les commandes internes et externes

Certaines commandes ont une implémentation interne et externe.

  • La commande interne est exécutée en priorité.
  • L'exécution d'une commande interne est plus rapide.
  • La commande type, indique que la commande est interne mais ne précise pas qu'elle peut également être une commande externe.

La commande pwd est une commande interne :

$ type pwd
pwd est une primitive du shell

La commande pwd possède également une implémentation externe :

$ ls -l /bin/pwd
-rwxr-xr-x 1 root root 34376 2010-09-21 20:33 /bin/pwd

Pour forcer l'utilisation de la commande externe, il faut indiquer l'emplacement de la commande :

$ /bin/pwd
/home
$ cd /bin
$ ./pwd
/bin

Affichage à l'écran

La commande interne echo permet d'afficher des données à l'écran.

$ echo Ceci est un exemple
Ceci est un exemple

Il faut échapper l'apostrophe avec l'antislash

$ echo Un exemple avec l\'apostrophe
Un exemple avec l'apostrophe

Il faut échapper les guillemets avec l'antislash

$ echo Un exemple avec des \"guillemets\"
Un exemple avec des "guillemets"

En bash, il faut obligatoirement utilisé l'option "-e" pour utiliser les caractères spéciaux suivants.

  • Le caractère "\n" sert à provoquer un saut de ligne :

$ echo -e "Un exemple\navec un saut de ligne"
Un exemple
avec un saut de ligne

  • Le caractère "\c" supprime le saut de ligne naturel de la commande echo :

Sans le caractère "\c"

$ echo -e "Une ligne" ; echo -e "Une autre ligne"
Une ligne
Une autre ligne

Avec le caractère "\c"

$ echo -e "Une ligne\c" ; echo -e "Une autre ligne"
Une ligneUne autre ligne

L'option -n remplace le caractère "\c"

$ echo -n "Une ligne" ; echo "Une autre ligne"
Une ligneUne autre ligne

  • Le caractère "\t" sert à afficher une tabulation :

$ echo -e "Voici 1 tabulation\tet la suite"
Voici 1 tabulation      et la suite

  • Le caractère "\\" permet d'afficher un antislash :

$ echo -e "Afficher un antislash\\"
Afficher un antislash\

Liste des caractères spéciaux :

\0NNN Valeur d'un caractère exprimé en octal
\\ Antislash
\a Bip
\b Effacement du caractère précédent
\c Suppression du saut de ligne en fin de ligne
\f Saut de page
\n Saut de ligne
\r Retour chariot
\t Tabulation horizontale
\v Tabulation verticale

 

Le caractère ~ (tilde)

Le caractère "~" représente le répertoire HOME de l'utilisateur.

Par exemple, pour l'utilisateur "toto"

$ cd ~
$ pwd
/home/toto

Copier le fichier "fichier1" du répertoire /tmp dans le répertoire /home/toto

$ cd /tmp
$ cp fichier1 ~

Copier le fichier "fichier2" du répertoire /tmp dans le répertoire /home/toto/mesfichiers

$ cd /tmp
$ cp fichier2 ~/mesfichiers

Si le caractère "~" est immédiatement suivi d'un mot, ce dernier est considéré comme un nom d'utilisateur.

Copier le fichier "fichier3" du répertoire /home/toto vers le répertoire /home/titi

$ cd ~
$ pwd
/home/toto
$ cp fichier3 ~titi

Copier le fichier "fichier4" du répertoire /home/toto vers le répertoire /home/titi/tmp

$ cd ~
$ pwd
/home/toto
$ cp fichier4 ~titi/tmp

 

La commande interne cd

La commande cd, sans arguments, permet à l'utilisateur de se placer dans son répertoire HOME.

$ pwd
/tmp
$ cd
$ pwd
/home/toto

Identique en utilisant le caractère "~"

$ cd ~

Pour se rendre dans le répertoire HOME de tata :

$ pwd
/home/toto
$ cd ~tata
$ pwd
/home/tata

Pour revenir au répertoire précédent avec la commande "cd -" :

$ cd -
$ pwd
/home/toto

Remplacement de noms de fichiers

Expressions simples

Attention, certaines de ces expressions ne fonctionnent pas toutes avec les mêmes shell.
Pour certaines, elles sont compatibles BASH, pour d'autres ZSH et certaines ne fonctionnent qu'avec KSH.

Le caractère "*" permet de remplacer n'importe quel caractère.

$ ls
fichier1 fichier2.a monfichier tOnfichier.b

  • Afficher uniquement les fichiers se terminant par ".a" :

$ ls *.a
fichier2.a

  • Afficher uniquement les fichiers commançant par "f" :

$ ls f*
fichier1 fichier2.a

Le caractère "?" représente un caractère quelconque.

  • Afficher uniquement les fichiers ayant une extension composée d'un seul caractère :

$ ls *.?
fichier2.a tOnfichier.b

  • Afficher uniquement les fichiers composés de 8 caractères :

$ ls ????????
fichier1

Les caractères "[ ]" permettent d'indiquer la liste des caractères que l'on recherche à une position bien précise dans le noms des fichiers.

  • Afficher les fichiers commençant par la lettre "f" ou "t" et se terminant
    par le "." suivi d'une lettre minuscule :

$ ls [ft]*.[a-z]
fichier2.a tOnfichier.b

  • Afficher tous les fichiers ayant en deuxième caractère une lettre majuscule, ou un chiffre,
    ou la lettre "e" :

% ls ?[A-Z0-9e]*
cOucou  f1chier  F2chier  Hello

  • Afficher tous les fichiers ne commançant pas par une lettre minuscule :

$ ls [!a-z]*
1coucou  Coucou  F2chier  Fichier  Hello

  • Supprimer tous les fichiers se terminant par .b ou .c :

% rm -i *.b *.c
rm : supprimer fichier vide «fichier1.b» ? y
rm : supprimer fichier vide «fichier1.c» ? y

 

Expressions complexes

Les expressions complexes sont compatible BASH à condition d'activer l'option extglob avec la commande shopt (shopt -s extglob).

$ ls
1coucou   coucou.t    fichier159159159.log  fichier161.log  fichier.log
cOucou    coucou.uvw  fichier159159.log     fichier1.a      Hello.txt
Coucou    f1chier     fichier159160.log     fichier1.abc
coucou.r  F2chier     fichier159.log        fichier1.b
coucou.s  Fichier     fichier160.log        fichier1.c

  • ?(expression)

L'expression sera présente 0 ou 1 fois.

Afficher tous les fichiers dont le nom contient 0 ou 1 fois "159"

$ ls fichier?(159).log
fichier159.log  fichier.log

  • *(expression)

L'expression sera présente entre 0 et x fois.

Afficher tous les fichiers dont le nom contient 0 ou x fois "159"

$ ls fichier*(159).log
fichier159159159.log  fichier159159.log  fichier159.log  fichier.log

  • +(expression)

L'expression sera présente entre 1 et x fois.

Afficher tous les fichiers dont le nom contient 1 ou x fois "159"

$ ls fichier+(159).log
fichier159159159.log  fichier159159.log  fichier159.log

  • @(expression)

L'expression sera présente exactement 1 fois.

Afficher tous les fichiers dont le nom contient 1 fois "159"

$ ls fichier@(159).log
fichier159.log

  • !(expression)

L'expression ne sera pas présente.

Afficher tous les fichiers dont le nom ne contient pas 1 fois "159"

$ ls fichier!(159).log
fichier159159159.log  fichier159160.log  fichier161.log
fichier159159.log     fichier160.log     fichier.log

Afficher tous les fichiers dont le nom ne contient pas "fichier"

$ ls !(fichier*)
1coucou  Coucou    coucou.s  coucou.uvw  F2chier  Hello.txt
cOucou   coucou.r  coucou.t  f1chier     Fichier

Une barre verticale dans une expression correspond à "ou bien"

Afficher tous les fichiers dont le nom contient 1 fois "159" ou "160"

$ ls fichier@(159|160).log
fichier159.log  fichier160.log

Afficher tous les fichiers dont le nom contient 1 ou x fois "159" ou "161"

$ ls fichier+(159|161).log
fichier159159159.log  fichier159159.log  fichier159.log  fichier161.log

Afficher tous les fichiers dont le nom contient 1 fois ( 1 ou x fois "159" ou "161")

$ ls fichier@(+(159)|+(161)).log
fichier159159159.log  fichier159159.log  fichier159.log  fichier161.log

Séparateur de commandes

Le caractère ";" permet d'écrire plusieurs commandes sur une même ligne. Toutes les commandes sont exécutées dans l'ordre.

$ pwd
/home/toto
$ ls
1coucou   coucou.t    fichier159159159.log  fichier161.log  fichier.log
cOucou    coucou.uvw  fichier159159.log     fichier1.a      Hello.txt
Coucou    f1chier     fichier159160.log     fichier1.abc
coucou.r  F2chier     fichier159.log        fichier1.b
coucou.s  Fichier     fichier160.log        fichier1.c
$ mkdir tmp; chmod 755 tmp; chown toto:toto tmp; cd tmp; pwd
/home/toto/tmp

Redirections

Les redirections sont souvent utilisées dans les commandes Linux.
Elles permettent de récupérer le résultat d'une ou plusieurs commandes dans un ou plusieurs fichiers ou de faire lire le contenu d'un fichier à une commande.

Entrée et sorties standard des commandes

Les commandes Linux ont par défaut 3 descripteurs de fichier différent.

  • Entrée standard :

L'entrée standard d'une commande correspond au descripteur de fichier 0.
Les commandes qui attendent des informations de la part de l'utilisateur déclenche une requête de lecture sur le descripteur 0.
Par défaut, ce descripteur est associé au terminal et donc par une saisie au clavier.

  • Sortie standard :

La sortie standard d'une commande correspond au descripteur de fichier 1.
Le résultat d'une commande est, par défaut, affichée à l'écran via ce descripteur mais il peut être redirigé dans un fichier.

  • Sortie d'erreur standard :

La sortie d'erreur standard d'une commande correspond au descripteur de fichier 2.
Quand une commande rencontre une erreur, celle-ci est retournée à l'écran via le descripteur 2 mais elle peut également être retournée dans un fichier.

Redirection des sorties vers un fichier

Cette redirection permet d'écrire dans un fichier le résultat d'une commande au lieu de l'afficher à l'écran.

  • Sortie standard (descripteur de fichier 1)

Simple redirection

$ commande > fichier
ou
$ commande 1> fichier

Si le fichier n'existe pas, il est automatiquement créé. S'il existe déjà, il est tout simplement écrasé.

Récupérer le résultat de la commande ls dans un fichier "liste"

$ ls > liste
$ cat liste
1coucou
cOucou
Coucou

Double redirection

Elle permet de concaténer le résultat d'une commande au contenu d'un fichier déjà existant.

$ commande >> fichier
ou
$ commande 1>> fichier

Si le fichier n'existe pas, il est automatiquement créé. S'il existe déjà, le résultat de la commande est ajouté au fichier.

$ pwd >> liste
$ cat liste
1coucou
cOucou
Coucou
/home/toto

  • Sortie d'erreur standard (descripteur de fichier 2)

Simple redirection

$ commande 2> fichier

$ ls /root 2> erreur
$ cat erreur
ls: impoossible d'ouvrir le répertoire /root: Permission non accordée

Double redirection

$ commande 2>> fichier

$ mkdir /root/tmp 2>> erreur
$ cat erreur
ls: impoossible d'ouvrir le répertoire /root: Permission non accordée
mkdir: impossible de créer le répertoire «/root/tmp»: Permission non accordée

  • Sortie standard et sortie d'erreur standard

Il est possible de rediriger plusieurs sorties sur une même ligne de commande.

$ commande 1> fichier1 2> fichier2
ou
$ commande 2> fichier2 1> fichier1

$ find /etc -name smb.conf 1> resultat 2> erreur
$ cat resultat
/etc/samba/smb.conf
$ cat erreur
find: "/etc/lvm/cache": Permission non accordée
find: "/etc/lvm/backup": Permission non accordée
find: "/etc/lvm/archive": Permission non accordée

Si l'on ne souhaite pas afficher et/ou enregistrer les erreurs retournées, il est possible de rediriger le descripteur 2 vers un fichier spécial existant sur tous les systèmes Linux "/dev/null"

$ find /etc -name smb.conf 1> resultat 2> /dev/null
$ cat resultat
/etc/samba/smb.conf
$ cat /dev/null
$
 

Redirection de l'entrée standard

La redirection de l'entrée standard concerne toutes les commandes attendant une saisie de la part de l'utilisateur sur le descripteur 0 (saisie écran).

$ mail toto
>Coucou
>Comment vas tu ?
>^d (équivalent de CTRL+d)
$

La commande mail lit sur l'entrée standard toutes les données saisies à l'écran. La saisie se termine par la fonction CTRL+d.
Ensuite, la commande mail envoie ces données dans un message à l'utilisateur indiqué (toto).

Il est tout à fait possible d'écrire le contenu du message dans un fichier et de "l'injecter" à la commande mail sur son descripteur 0.

$ commande 0< fichier
ou
$ commande < fichier

$ echo "Coucou, comment vas tu ?" > message
$ cat message
Coucou, comment vas tu ?
$ mail toto < message

 

Redirections avancées

Rediriger les descripteurs 1 et 2 vers le même fichier :

$ commande 1> fichier1 2>&1
ou
$ commande 2> fichier2 1>&2

Le principe consiste à écrire dans un fichier le résulat du descripteur 1 dans le fichier "fichier1" (1> fichier1) puis le résultat du descripteur 2 vers le descripteur 1 (2>&1) et par conséquent dans le fichier "fichier1".

$ find /etc -name smb.conf 1> resultat 2>&1
$ cat resultat
find: "/etc/lvm/cache": Permission non accordée
find: "/etc/lvm/backup": Permission non accordée
find: "/etc/lvm/archive": Permission non accordée
/etc/samba/smb.conf

Attention :

$ commande 2>&1 1> fichier1

Cette syntaxe n'agit pas de la même manière que les précédentes.

En effet, nous indiquons dans un premier temps de rediriger le descripteur 2 (sortie d'erreur standard) vers le descripteur 1, c'est à dire vers la sortie standard qui est, par défaut, l'affichage à l'écran, puis dans un second temps nous redirigeons le descripteur 1 (sortie standard) vers le fichier "fichier1".
En conclusion, tous les messages d'erreurs seront affichés à l'écran et le résulat de la commande dans le fichier "fichier1".

Cela revient à saisir :

$ commande 1> fichier1

La double redirection en lecture :

Elle est principalement utilisée dans les scripts shell.
Elle permet de connecter l'entrée standard d'une commande sur une portion du script

Par exemple, avec la commande mail, cela permet de terminer la saisie du texte avec un caractère ou une chaine de caractère.

$ mail toto<<end
> bonjour
> ceci est un test
> end
$

Pour mettre fin à la commande mail, il suffit simplement de saisir l'expression inscrite juste après les doubles chevrons "<<". Dans l'exemple, la commande se termine après avoir saisi "end".
Identique à la fonction ^d (CTRL+d) en console.

Utilisation dans un script :

$ cat envoiMail.sh
#!/bin/sh
mail toto<<end
Bonjour,
Ceci est un test
Voici la liste des fichiers presents dans ton repertoire :
`ls -lhtr`
end
exit 0

Exécution du script

$ sh ./envoiMail.sh

Fermeture d'un descripteur :

Il est tout à fait possible de fermé un descripteur d'entrée ou de sortie en utilisant les symboles "<&-" ou ">&-" ou "2>&-".

Descripteur d'entrée standard "0" :

$ commande <&-

Descripteur de sortie standard "1" :

$ commande >&-

Descripteur de sortie d'erreur standard "2" :

$ commande 2>&-

Tubes de communications

Un tube de communication, ou pipe en anglais, permet de faire communiquer 2 commandes.
Ce "tube" est représenté par la barre verticale "|".
Le résultat de la commande de gauche est envoyé dans le tube et récupéré par la commande de droite.
C'est à dirte que la sortie standard "1" de la commande de gauche est connecté directement à l'entrée standard "0" de la commande de droite.
La sortie d'erreur standard "2" de la commande de gauche n'est pas envoyée dans le tube.

Pour que cette utilisation est un sens il faut impérativement que la commande de gauche utilise la sortie standard "1" et que la commande de droite utilise l'entrée standard "0".

Les commandes lisant leur entrée standard sont facilement identifiable car elles demandent une saisie au clavier.

Envoyer par mail la liste des users connectés :

$ who | mail toto

Envoyer par mail la liste des fichiers d'un répertoire :

$ ls -lht | mail toto

Envoyer un message à un utilisateur connecté au système :

$ echo "coucou, comment vas tu ?" | write tata

Afficher le nombre de fichiers d'un répertoire :

$ ls | wc -l
29

Envoyer par mail le nombre de fichiers d'un répertoire :

$ ls | wc -l | mail toto

Afficher avec pagination le contenu d'un fichier :

$ cat /etc/passwd | more

Lister le contenu d'un répertoire avec pagination :

$ ls -lht /etc | more

Afficher uniquement certains éléments d'un fichier :

$ cat /etc/passwd | grep root | cut -d':' -f1,7
root:/bin/bash

Envoyer par mail certains éléments d'un fichier :

$ cat /etc/passwd | grep root | cut -d':' -f1,7 | mail toto

Afficher à l'écran et enregistrer dans un fichier le contenu d'un répertoire :

$ ls -t | tee listeFichiers
listeFichiers
envoiMail.sh
message
script.sh
$ cat listeFichiers
listeFichiers
envoiMail.sh
message
script.sh

Il est donc tout à fait possible de cumuler autant de commandes que l'on souhaite à partir du moment où l'on respecte l'ordre des commandes et des sorties / entrées standard.

Rediriger la sortie d'erreur standard dans un tube

$ ls -l /root 2>&1 | tee listeFichiers
ls: impoossible d'ouvrir le répertoire /root: Permission non accordée
$ cat listeFichiers
ls: impoossible d'ouvrir le répertoire /root: Permission non accordée

 

Regrouper des commandes

Le regroupement de commandes est utilisé pour rediriger les sorties standards de plusieurs commandes vers un même fichier ou vers un tube ou pour exécuter des commandes dans un même environnement.

$ date ; ls > listeFichiers
lundi 19 septembre 2011, 08:47:11 (UTC+0200)
$ cat listeFichiers
1coucou
cOucou
Coucou
coucou.r
coucou.s
coucou.t
coucou.uvw
envoiMail.sh

Dans l'exemple ci-dessus, la commande date et ls sont regroupées grâce au caractère ";".
Le résultat de la commande date est affiché à l'écran alors que le résultat de la commande ls est redirigé dans le fichier "listeFichiers".

Afin de rediriger la sortie standard des 2 commandes au même endroit, ils faut obligatoirement les regroupées avec des parenthèses "()" ou des accolades "{}".

$ ( date ; ls ) > listeFichiers
$ cat listeFichiers
lundi 19 septembre 2011, 08:51:58 (UTC+0200)
1coucou
cOucou
Coucou
coucou.r
coucou.s
coucou.t
coucou.uvw
envoiMail.sh

Les commandes regroupées entre parenthèses sont exécutées par le shell enfant alors que les commandes regroupées entre accolades sont exécutées par le shell parent.

Regroupement avec parenthèses :

$ pwd
/home/toto
$ ( mkdir temp ; cd temp ; touch fichierTemp ; pwd ; ls ) > listeFichiers
$ cat listeFichiers
/home/toto/temp
fichierTemp
$ pwd
/home/toto

Après exécution des commandes, le répertoire courant est le même qu'avant exécution.

Regroupement avec accolades :

$ pwd
/home/toto
$ { mkdir temp ; cd temp ; touch fichierTemp ; pwd ; ls ; } > listeFichiers
$ pwd
/home/toto/temp
$ cat ../listeFichiers
/home/toto/temp
fichierTemp

Après exécution des commandes, le répertoire courant n'est plus le même qu'avant exécution.

  • L'exécution de commandes regroupées entre accolades est plus rapide que les commandes regroupées entre parenthèses.
  • Le regroupement entre accolades doit obligatoirement se terminer par un point-virgule.
    Les accolades doivent toujours être suivies et précédées par une espace.

     

Généralement, le regroupement entre parenthèses est plus utilisé que le regroupement entre accolades car la syntaxe est plus simple et cela ne modifie pas le shell courant mais pour un gain de performances le regroupement entre accolades est préférable.

Exécuter des commandes en arrière-plan

Pour exécuter des commandes en arrière-plan, il suffit de rajouter à la fin le caractère "&".
Cela permet de récupérer le shell aussitôt après sans être obligé d'attendre la fin de l'exécution de la commande précédente.
Par contre, il est préférable d'utiliser la redirection de la sortie standard et de la sortie d'erreur standard.

$ find /etc -name passwd 1>listePasswd 2>/dev/null &
$ echo "On peut saisir d'autre commandes en attendant de voir le message ci-dessous une fois le processus terminé"
[1]+  Exit 1                  find /etc -name passwd > listePasswd 2> /dev/null
$ cat listePasswd
/etc/passwd
/etc/webmin/passwd
/etc/pam.d/passwd

Paramétrer son environnement de travail

Les variables d'environnement

Le commande set permet d'obtenir la liste des variables paramétrées pour le shell courant.

$ set
BASH=/bin/bash
HOME=/home/toto
HOSTNAME=myhostname
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games
PS1='\[\e]0;\u@\h: \w\a\]${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h$
PS2='> '
PS4='+ '
SHELL=/bin/bash
...

Le caractère $ permet d'obtenir la valeur d'une variable :

$ echo $BASH
/bin/bash

Pour créer ou modifier une variable :

$ VARIABLE='valeur'
$ echo $VARIABLE
valeur

Attention, car toutes variables créées ou modifiées de cette manière ne sont valables que pour la session en cours.

$ MAVARIABLE='<= Ceci est le contenu de ma variable =>'
$ echo $MAVARIABLE
<= Ceci est le contenu de ma variable =>

Les principales variables :

HOME : cette variable contient le chemin du répertoire d'accueil de l'utilisateur.

PATH : cette variable contient une liste de répertoire dans lesquels le shell recherche toutes les commandes qui sont exécutées.
Si une commande est exécutée et qu'elle ne se trouve dans aucun des répertoires indiqués dans la variable PATH, une erreur sera retournée en indiquant que la commande est introuvable.
Si l'on souhaite exécuter une commande qui se trouve dans un répertoire non indiqué dans la variable PATH, il suffit tout simplement de modifier le contenu de la variable.

$ PATH=$PATH:/leRepertoireDeMaCommande

Pour modifier la variable PATH définitivement, il suffit d'ajouter une ligne au fichier ~/.bashrc :

> export PATH=$PATH:/mon_autre_repertoire

Ou modifier directement le fichier /etc/environment :

> PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/mon_autre_repertoire"

Pour exécuter une commande présente dans le répertoire courant, il suffit d'ajouter à la variable PATH la valeur ":." ou ":".

PWD : cette variable contient le chemin du répertoire courant.

PS1 : cette variable contient la chaine de caractères correspondant au prompt ($ en règle générale).

Pour faire apparaitre la valeur du répertoire courant dans le prompt :

$ PS1='$PWD$ '
ou
$ PS1='\w$ '

BASH : Séquence d'échappement permettant de paramétrer la variable PS1

Séquence échappement Valeur
\u Nom de l'utilisateur
\h Nom de la machine
\w Répertoire courant
\W Partie terminale du répertoire courant

PS2 : cette variable contient la chaine de caractères correspondant au prompt secondaire (> en règle générale).

$ echo 'ceci est le début
> de ma chaine de texte
> et tant que je ne saisi pas
> le caractère apostrophe
> ça continue
> '
ceci est le début
de ma chaine de texte
et tant que je ne saisi pas
le caractère apostrophe
ça continue
$

$ mail toto<<fin
> un autre exemple
>
> fin
$

TERM : cette variable contient le type du terminal de l'utilisateur.

LOGNAME : cette variable contient le nom de l'utilisateur connecté.

Exporter des variables :

Il est parfois nécessaire d'exporter une variable car toutes ne le sont pas.
Pour savoir quelles sont les variables exportées d'office il suffit d'utiliser la commande env.

$ env
TERM=xterm
SHELL=/bin/bash
CDPATH=:.:/home/
USER=toto
...

Pour exporter une variable :

$ MAVARIABLE='maValeur'
$ export MAVARIABLE

ou

$ export MAVARIABLE='maValeur'

Par exemple, en BASH, pour utiliser le programme nano (éditeur de texte) comme éditeur par défaut du programme mutt (client mail en ligne de commande), il suffit d'inscrire dans son fichier ~/.bashrc :

export EDITOR=/usr/bin/nano

et pour une prise en compte immédiate, sans être obligé de se reconnecter, saisir dans la console :

$ export EDITOR=/usr/bin/nano
Et pour vérifier :
$ set | grep EDITOR
EDITOR=/usr/bin/nano
$ env | grep EDITOR
EDITOR=/usr/bin/nano

Les options du shell

Pour activer ou désactiver les options du shell, il suffit d'utiliser la commande set avec les options -o et +o.

Activation :

$ set -o option

Désactivation :

$ set +o option

Pour visualiser  la liste des options disponibles ainsi que leur état, saisir dans une console :

$ set -o
allexport       off
braceexpand     on
emacs           on
errexit         off
errtrace        off
functrace       off
hashall         on
histexpand      on
history         on
ignoreeof       off
interactive-comments    on
keyword         off
monitor         on
noclobber       off
noexec          off
noglob          off
nolog           off
notify          off
nounset         off
onecmd          off
physical        off
pipefail        off
posix           off
privileged      off
verbose         off
vi              off
xtrace          off

Détails de certaines options :

ignoreeof

Pour quitter le shell, il existe 3 méthodes :

  • La commande exit.
  • La commande logout.
  • La combinaison des touches ^d (CTRL+d).

Si l'option ignoreeof est activée, il n'est plus possible de quitter le shell en appuyant sur ^d.

noclobber

Quand une redirection est faite vers un fichier déjà existant, celui-çi est automatiquement écrasé sans confirmation. Pour inverser se fonctionnement, il suffit d'activer l'option noclobber.

On vérifie l'état de l'option noclobber

$ set -o | grep noclobber
noclobber       off

On redirige le résultat de la commande ls vers le fichier liste

$ ls -l > liste

On redirige le résultat de la commande pwd vers le fichier liste déjà existant

$ pwd > liste

On active l'option noclobber

$ set -o noclobber

On vérifie que l'option noclobber est bien activée

$ set -o | grep noclobber
noclobber       on

On redirige le résultat de la commande pwd vers le fichier liste déjà existant

$ pwd > liste
-bash: liste : impossible d'écraser le fichier existant

On force la redirection de la commande pwd vers le fichier liste déjà existant

$ pwd >| liste

emacs & vi

Ces 2 options permettent de paramétrer la rappel des commandes.
En ksh, ces 2 options sont désactivées.
En bash, seule l'option emacs est activée.

xtrace

Cette option est utilisée pour déboguer les scripts shell.

Les alias

Les alias permettent de créer des raccourcis vers des commandes et de les personnaliser.

Pour visualiser la liste des alias déjà existant :

$ alias
alias egrep='egrep --color=auto'
alias fgrep='fgrep --color=auto'
alias grep='grep --color=auto'
alias l='ls -CF'
alias la='ls -A'
alias ll='ls -lF'
alias ls='ls --color=auto'
alias tarc='tar -cvzf'
alias tarx='tar -xvzf'

Pour visualiser un alias en particulier :

$ alias la
alias la='ls -A'

Pour créer un alias :

$ alias c='clear'
$ alias rm='rm -i'
$ rm liste
rm : supprimer fichier «liste» ? y

En bash, pour créer un alias définitivement, il suffit de le renseigner dans le fichier ~/.bashrc

Pour supprimer un alias :

$ unalias c
$ c
c : commande introuvable

Historique des commandes

Le shell enregistre toutes les commandes saisies dans un fichier texte.
En bash, il s'agit du fichier ~/.bash_history
En ksh, il s'agit du fichier ~/.sh_history
Pour utiliser le rappel des commandes, le shell utilise soit emacs soit vi.
En bash, c'est l'option emacs qui est activée par défaut mais il est possible d'utiliser vi.
En ksh, les 2 options sont par défaut désactivées.
Le choix d'activer l'un, désactive l'autre.

$ set -o | grep "^emacs\|^vi"
emacs           on
vi              off

Pour les utilisateurs non habitués à l'éditeur vi, il est préférable d'utiliser emacs car le rappel des commandes se fait avec les flèches du clavier.

Les fichiers d'environnement

Les fichiers d'environnement sont utilisés pour stocker de manière permanente tout le paramétrage de l'environnement de l'utilisateur.

Ce sont des scripts shell qui contiennent un ensemble de commandes Linux.

Certains scripts sont exécutés uniquement par le shell de connexion et d'autres par un shell ordinaire.

Le shell de connexion est lancé immédiatement après l'identification de l'utilisateur.

Le shell de connexion exécute en premier le script /etc/profile. Ce script contient le paramétrage commun à tous les utilisateurs.
Il recherche ensuite dans le répertoire d'accueil de l'utilisateur un script dont le nom dépend du shell utilisé.

En sh / ksh :

Le script de connexion se nomme ~/.profile

En bash :

L'un des 3 scripts suivants dans l'ordre

  1. ~/.bash_profile
  2. ~/.bash_login
  3. ~/.profile

 

En bash, le shell de connexion exécute en premier le script /etc/profile, puis le script ~/.profile et enfin le script ~/.bashrc.

C'est dans ce dernier fichier, ~/.bashrc, que l'on peut définir de nouveaux alias, exporter automatiquement de nouvelles variables, paramétrer l'auto-complétion, définir les variables PS1 et PS2, paramétrer le nombre de commandes à historiser, etc etc.

Les bases de la programmation shell

Les variables utilisateur

Le shell permet de définir ou redéfinir des variables pour l'environnement de l'utilisateur.

Il est également possible de définir d'autres variables dites variables utilisateur qui vont permettre de stocker des informations utiles durant l'exécution de scripts.

Le nomage des variables

  • Le premier caractère doit être obligatoirement une lettre minuscule, majuscule ou un tiret bas [a-zA-Z_]
  • Les caractères suivants peuvent être des lettres en minuscule, majuscule, des chiffres de 0 à 9 ou un tiret bas [a-zA-Z0-9_]

Définition d'une variable

$ variable1=valeur1
$ echo $variable1
valeur1
$

Il ne faut surtout pas mettre d'espace avant et après le signe égal (=) ainsi que dans la valeur de la variable.

Si un espace est placé avant le signe '=', le shell va interpréter la chaine 'variable1' comme étant une commande et la chaine '=valeur1' comme étant un paramètre de la commande variable1.

Pour pouvoir affecter une valeur contenant un espace, il faut obligatoirement le protéger avec des simples quotes.

$ variable2='valeur2 valeur21'
$ echo $variable2
valeur2 valeur21
$

Pour supprimer le contenu d'une variable, il faut utiliser la commande unset :

$ variable3=valeur3
$ echo $variable3
valeur3
$ set | grep variable3
variable3=valeur3
$ unset variable3
$ echo $variable3
$ set | grep variable3
$

Concaténer des variables avec une chaine de caractères :

Un exemple qui produit une erreur

$ fichier=monFichier
$ dateJour=20111006
$ nouveauFichier=$fichier_$dateJour
$ echo $nouveauFichier
20111006
$

Le but de cet exemple est de concaténer la variable $fichier, un tiret bas '_', puis la variable $dateJour.
Le résultat final est erroné car au moment d'affecter la nouvelle variable nouveauFichier (ligne 3), le shell interprète $fichier_ comme étant une variable à part entière puisque le tiret bas '_' est autorisé dans le nommage des variables.
La variable $fichier_ n'existant pas, celle ci est égale à "blanc".
Pour indiquer au shell qu'il faut interpréter le tiret bas '_' comme étant une chaine de caractères, il faut obligatoirement entourer la variable qui le précède avec des {}.

$ fichier=monFichier
$ dateJour=20111006
$ nouveauFichier=${fichier}_$dateJour
$ echo $nouveauFichier
monFichier_20111006
$

Substituer des variables :

Le shell offre la possibilité d'attribuer une valeur par défaut aux variables non initialisées ou au contraire initialisées.

Expression ${variable:-valeur}

  • Si la variable n'est pas vide, l'expression est égale au contenu de la variable
  • Si la variable est vide, l'expression est égale au contenu de valeur

$ jour=mardi
$ echo "Nous sommes : ${jour:-dimanche}"
Nous sommes : mardi
$ unset jour
$ echo "Nous sommes : ${jour:-dimanche}"
Nous sommes : dimanche
$ echo $jour
$

Expression ${variable:=valeur}

  • Si la variable n'est pas vide, l'expression est égale au contenu de la variable
  • Si la variable est vide, l'expression et la variable sont égale au contenu de valeur

$ jour=mardi
$ echo "Nous sommes : ${jour:=dimanche}"
Nous sommes : mardi
$ echo $jour
mardi
$ unset jour
$ echo "Nous sommes : ${jour:=dimanche}"
Nous sommes : dimanche
$ echo $jour
dimanche
$

Expression ${variable:+valeur}

  • Si la variable n'est pas vide, l'expression est égale au contenu de valeur
  • Si la variable est vide, l'expression est égale à variable, donc vide

$ bool=1
$ echo "Si bool=1 alors j'affiche : ${bool:+true}"
Si bool=1 alors j'affiche : true
$ unset bool
$ echo "Si bool=1 alors j'affiche : ${bool:+true}"
Si bool=1 alors j'affiche :
$

Expression ${variable:?message}

  • Si la variable n'est pas vide, l'expression est égale au contenu de la variable
  • Si la variable est vide, l'expression est égale au nom de la variable suivi du contenu de message

Dans un script, si la variable est vide, le message est affiché et le script se termine aussitôt

$ nombre=56
$ echo ${nombre:?"nombre indefini"}
56
$ unset nombre
$ echo ${nombre:?"nombre indefini"}
-bash: nombre: nombre indefini
Affichage du message par défaut
$ echo ${nombre:?}
-bash: nombre : parametre vide ou non defini
$

Substitution de commandes

Les caractères de substitution permettent de remplacer une commande par le résultat de son exécution.

Par exemple, comment faire pour afficher un message affichant la date du jour.

$ echo "Nous sommes le date"
Nous sommes le date
$

Il suffit d'entourer la commande avec les caractères de substitution :

  • Les quotes inversés `commande`
  • $(commande)

$ echo "Nous sommes le `date`"
Nous sommes le vendredi 7 octobre 2011, 08:39:49 (UTC+0200)
$ echo "Nous sommes le $(date)"
Nous sommes le vendredi 7 octobre 2011, 08:40:05 (UTC+0200)
$

Idem pour initialiser une variable :

$ date=`date`
$ echo $date
vendredi 7 octobre 2011, 08:42:34 (UTC+0200)
$

Les caractères de protection

Les caractères de protection servent à utiliser les caractères spéciaux du shell comme n'importe quels caractères.

Les simples quotes

Les simples quotes désactivent tous les caractères spéciaux du shell. Ils doivent être utilisés en nombre pair sur une ligne de commande.

$ echo $PWD
/home/toto

Avec les simples quotes, la fonction du caractère '$' est désactivée :

$ echo '$PWD'
$PWD
$

Afficher tous les fichiers d'un dossier à l'aide de la fonction 'echo' et du caractère spécial '*'

$ echo *
1coucou cOucou Coucou coucou.r ...

Avec les simples quotes, la fonction du caractère '*' est désactivée :

$ echo '*'
*
$

$ echo Bonjour $(logname)
Bonjour toto
$ echo 'Bonjour $(logname)'
Bonjour $(logname)
$

La quote ne se protège pas elle-même.
Tant que les quotes ne sont pas par pair, le shell affiche le prompt secondaire

$ echo 'J'affiche un quote supplémentaire'
>

L'antislash '\'

L'antislash désactive la fonctionnalité du caractère qui le suit.

$ echo La liste des fichiers * du dossier $PWD
La liste des fichiers 1coucou cOucou Coucou coucou.r du dossier /volume1/home/ronan/atuer/toto
$ echo La liste des fichiers \* du dossier \$PWD
La liste des fichiers * du dossier $PWD
$

L'antislash se protège lui-même

$ echo \\
\
$

$ echo L\'antislash protège la quote
L'antislash protège la quote
$

Le premier antislash protège le second, le troisième protège le '$'

$ echo \\\$PWD
\$PWD
$

Les guillemets

Les guillemets protège tous les caractères spéciaux du shell à l'exception du dollar $, des quotes inversés ``, du dollar et des parenthèses $( ), de l'antislash \ et des guillemets ".

$ echo "
> La variable \$HOME est substituée par $HOME
> La commande \$(logname) est exécutée : $(logname)
> Je peux afficher des > et des |
> Et même des guillemets \"."
La variable $HOME est substituée par /home/toto
La commande $(logname) est exécutée : toto
Je peux afficher des > et des |
Et même des guillemets ".
$

En règle générale, il est préférable d'utiliser la commande echo avec des guillemets

Récapitulatif des caractères spéciaux

Caractères Signification
espace - tabulation - saut de ligne Séparateurs de mots sur la ligne de commande
& Arrière-plan
|   <<   <   >   >> Tubes et redirections
() et {} Regroupement de commandes
; Séparateur de commandes
*   ?   [ ]   ?( )   +( )   *( )   !( )   @( ) Caractères de génération de noms de fichier
$ et ${ } Valeur d'une variable
``   $( ) Substitution de commandes
' '   " "   \ Caractères de protection

 

Interprétation d'une ligne de commande

:Les caractères spéciaux du shell sont interprétés dans un ordre bien précis.

  1. Isolement des mots séparés par les caractères espace, tabulation, saut de ligne.
  2. Traitement des caractères de protections ( ' ', " ", \).
  3. Substitution des variables ($)
  4. Substitution des commandes (``, $( ) )
  5. Substitution des caractères de génération des noms de fichiers (*, ?, [ ], ?( ), +( ), *( ), !( ), @( ))
  6. Traitement des tubes et redirections (|, <<, <, >, >>)
  7. Lancement de la commande

Exemple :

$ echo "\$HOME --> $HOME
> Mon login --> $(logname)
> Nous sommes le `date`
> La liste des fichiers :" * | nl > test ; cat test
     1  $HOME --> /home/toto
     2  Mon login --> toto
     3  Nous sommes le jeudi 20 octobre 2011, 08:27:05 (UTC+0200)
     4  La liste des fichiers : fichier1 fichier2 fichier3 fichier4
$

Interprétation :

  1. \$HOME (traitement des caractères de protection)
  2. $HOME (substitution des variables)
  3. $(logname) et `date` (substitution des commandes)
  4. * (substitution des caractères de génération des noms de fichiers)
  5. | nl > test (traitement des tubes et redirections)
  6. echo "...." ; cat test (exécution des commandes)

Ecriture et exécution d'un script shell

Un script shell est un fichier texte contenant des commandes Linux internes ou externes.

Le nom du script peut avoir une extension mais cela n'est pas obligatoire.

En règle générale, tous les scripts portent l'extension .sh

Exemple :

$ nl monPremierScript.sh
     1  pwd
     2  echo "Liste des fichiers commençant par la lettre C"
     3  ls -lh c*
$

Exécution :

$ bash monPremierScript.sh
/home/toto
Liste des fichiers commençant par la lettre C
-rw-r--r-- 1 toto toto 0 2011-09-14 13:55 cOucou
-rw-r--r-- 1 toto toto 0 2011-09-15 07:20 coucou.r
-rw-r--r-- 1 toto toto 0 2011-09-15 07:20 coucou.s
-rw-r--r-- 1 toto toto 0 2011-09-15 07:20 coucou.t
-rw-r--r-- 1 toto toto 0 2011-09-15 07:21 coucou.uvw
$

Exécuter un script par le shell enfant

Il existe 3 méthodes pour exécuter un script.

La première méthode consiste à appeler la commande bash, sh, ksh etc.. (l'interpréteur de commande désiré) suivi du nom du script.

$ bash monPremierScript.sh

Dans ce cas, le droit de lecture sur le fichier est suffisant.

$ ls -l monPremierScript.sh
-rw-r--r-- 1 toto toto 68 2011-10-20 08:52 monPremierScript.sh
$

La seconde méthode consiste à utiliser l'entrée standard de la commande bash, sh, ksh etc.. afin de lui faire lire le contenu du script.

$ bash < monPremierScript.sh

Dans ce cas, le droit de lecture sur le fichier est également suffisant.
Cette méthode est très peu utilisée.

La troisième méthode consiste à rendre le script exécutable.

$ chmod u+x monPremierScript.sh
$ ls -l monPremierScript.sh
-rwxr--r-- 1 toto toto 68 2011-10-20 08:52 monPremierScript.sh
$ ./monPremierScript.sh

Choisir un interpréteur de commande :

Pour indiquer au script quel interpréteur de commande utiliser, il faut indiquer sur la première ligne du script les caractères #! suivi du chemin absolu de l'interpréteur.

Par exemple, pour utiliser l'interpéteur de commande BASH, on recherche son chemin absolu :

$ whereis bash
bash: /bin/bash /etc/bash.bashrc /usr/share/man/man1/bash.1.gz
$

La résultat de la commande nous indique le répertoire /bin/bash
Inscrire sur la première ligne du script #! /bin/bash

$ nl monPremierScript.sh
     1  #! /bin/bash
     2  pwd
     3  echo "Liste des fichiers commençant par la lettre C"
     4  ls -lh c*
$

De cette manière, le script sera toujours exécuté avec l'interpréteur de commande BASH.

Exécuter un script par le shell courant

L'exécution d'un script par le shell courant permet de modifier l'environnement du shell courant.

Les droits d'exécution sur le script ne sont pas nécessaires.
L'utilisation de la commande interne "." est nécessaire pour l'exécution.

Par exemple, pour modifier l'éditeur par défaut, il est nécessaire de modifier la variable environnement EDITOR.

$ env | grep EDITOR
EDITOR=/usr/bin/vi
echo $EDITOR
/usr/bin/vi
nano .profile
export EDITOR='/usr/bin/nano'
^o (enregistrer)
^x (quitter)
$ . .profile
$ echo $EDITOR
/usr/bin/nano
env | grep EDITOR
EDITOR=/usr/bin/nano
$

Attention, l'appel de la commande interne "." est obligatoirement suivi d'un espace et d'un script shell.

Les commentaires

Il est possible d'écrire dans un script des commentaires afin de faciliter la compréhension du script.

Les commentaires sont désignés à l'aide du caractère #.
Ne pas confondre avec #! inscrit sur la première ligne du script qui sert à renseigner l'interpréteur de commande.

$ nl monPremierScript.sh
     1    #! /bin/bash
       
     2    # Ceci est un commentaire
     3    # La commande PWD indique le répertoire courant
     4    pwd
     5    # La commande ECHO permet d'afficher du texte et des informations
     6    echo "Liste des fichiers commençant par la lettre C"
     7    # La commande LS permet de lister tous les fichiers commençant par la lettre "c"
     8    ls -lh c*
$

Les variables réservées du shell

Dans un script, il est possible de récupérer en lecture un certain nombre de variables réservées.
Ces variables sont initialisées par le shell et contiennent des informations diverses et variées.

Les paramètres positionnels

Les scripts shell sont capables de récupérer des arguments placés juste après l'appel du script.

  • $# indique le nombre d'arguments passés au script
  • $0 indique le nom du script
  • $1, $2, $3 ... $9 contient la valeur de l'argument 1, 2, 3 ... 9

En KSH et en BASH, il est possible d'aller au delà de 9 arguments en utilisant les variables spéciales ${10}, ${11} etc...
Les accolades sont obligatoires à partir du moment où le nom de la variable contient plus d'un chiffre.

  • $* et $@ contient la liste de tous les arguments

Exemple :

$ nano monSecondScript.sh
#! /bin/bash
echo "Il y a $# arguments passés au script"
echo "Le script se nomme $0"
echo "La valeur du premier argument : $1"
echo "La valeur du second argument : $2"
echo "La valeur du troisième argument : $3"
echo "Les valeurs de tous les arguments : $*"
^o (enregistrer)
^x (quitter)
$ chmod u+x monSecondScript.sh
$ ./monSecondScript.sh arg1 arg2 arg3 arg4 arg5
Il y a 5 arguments passés au script
Le script se nomme ./monSecondScript.sh
La valeur du premier argument : arg1
La valeur du second argument : arg2
La valeur du troisième argument : arg3
Les valeurs de tous les arguments : arg1 arg2 arg3 arg4 arg5
$

Exemple avec 3 arguments :

$ ./monSecondScript.sh 25 + 15
Il y a 3 arguments passés au script
Le script se nomme ./monSecondScript.sh
La valeur du premier argument : 25
La valeur du second argument : +
La valeur du troisième argument : 15
Les valeurs de tous les arguments : 25 + 15
$

Tous les arguments doivent être séparés les uns des autres par un espace ou une tabulation

La commande shift

La commande shift permet de décaler la liste des arguments d'une ou plusieurs positions vers la gauche.

Cette commande est utilisée dans le cas où le premier argument n'a pas à subir le même traitement que les suivants.
Dans ce cas, le premier argument doit être sauvegardé dans une variable et l'exécution de la commande shift entraine le remplacement du premier argument par le second et ainsi de suite.

$ nl monTroisiemeScript.sh
     1  #! /bin/bash
     2  # Ce script doit recevoir en premier argument le nom d'un dossier puis des noms de fichiers pour les suivants
     3  # Affichage des variables avant l'utilisation de la commande shift
     4  echo -e "Affichage avant exécution de la commande shift\n"
     5  echo "1er argument \$1 : $1"
     6  echo "1er argument \$2 : $2"
     7  echo "1er argument \$3 : $3"
     8  echo "1er argument \$4 : $4"
     9  echo "Tous les arguments \$* : $*"
    10  echo -e "Le nombre d'argument \$# : $#\n"
    11  # On sauvegarde le premier argument dans la variable rep
    12  rep=$1
    13  # On décale tous les arguments avec la commande shift
    14  shift
    15  # Affichage des variables après l'exécution de la commande shift
    16  echo -e "Affichage après exécution de la commande shift\n"
    17  echo "1er argument \$1 : $1"
    18  echo "1er argument \$2 : $2"
    19  echo "1er argument \$3 : $3"
    20  echo "1er argument \$4 : $4"
    21  echo "Tous les arguments \$* : $*"
    22  echo -e "Le nombre d'argument \$# : $#\n"
    23  # Création du répertoire
    24  mkdir $rep
    25  # On se positionne dans le nouveau répertoire
    26  cd $rep
    27  # Création des fichiers dans le nouveau répertoire
    28  for fichier in $*
    29  do
    30          touch $fichier
    31  done
$ chmod u+x monTroisiemeScript

Exécution du script :

$ ./monTroisiemeScript.sh test fic1 fic2 fic3 fic4 fic5 fic6
Affichage avant exécution de la commande shift
1er argument $1 : test
1er argument $2 : fic1
1er argument $3 : fic2
1er argument $4 : fic3
Tous les arguments $* : test fic1 fic2 fic3 fic4 fic5 fic6
Le nombre d'argument $# : 7
Affichage après exécution de la commande shift
1er argument $1 : fic1
1er argument $2 : fic2
1er argument $3 : fic3
1er argument $4 : fic4
Tous les arguments $* : fic1 fic2 fic3 fic4 fic5 fic6
Le nombre d'argument $# : 6
ls -l ./test/
total 0
-rw-r--r-- 1 toto toto 0 2011-10-25 09:01 fic1
-rw-r--r-- 1 toto toto 0 2011-10-25 09:01 fic2
-rw-r--r-- 1 toto toto 0 2011-10-25 09:01 fic3
-rw-r--r-- 1 toto toto 0 2011-10-25 09:01 fic4
-rw-r--r-- 1 toto toto 0 2011-10-25 09:01 fic5
-rw-r--r-- 1 toto toto 0 2011-10-25 09:01 fic6
$

Code de retour d'une commande

Toutes les commandes Linux retournent un code d'erreur compris entre 0 et 255.
La valeur 0 représente la valeur vrai (succès de la commande).
Les valeurs supérieur à 0 représente la valeur faux (échec de la commande).
Le code erreur de la dernière commande utilisée est contenu dans la variable $?

$ ls f*
f1chier               fichier159159.log  fichier159.log  fichier161.log  fichier1.abc  fichier1.c   fset
fichier159159159.log  fichier159160.log  fichier160.log  fichier1.a      fichier1.b    fichier.log
$ echo $?
0
$ ls 2*
ls: impossible d'accéder à 2*: Aucun fichier ou dossier de ce type
$ echo $?
2

Dans un script shell, le test du code de retour d'une commande permet d'effectuer différentes actions.

Un script shell étant lui-même une commande, il est possible de lui faire retourner un code d'erreur avec la commande exit.

Par exemple, il est possible d'indiquer dans un script exit 1 afin d'indiquer une erreur rencontrée et/ou exit 0 afin d'indiquer que tout c'est bien déroulé.

Dans l'exemple suivant, le script test s'il reçoit bien au minimum 2 arguments et renvoi le code erreur 1 si c'est faux.

$ nl ./script.sh
1  #! /bin/bash
2  # Le script doit recevoir au minimum 2 arguments
3  if [ $# -lt 2 ]
4  then
5          # Si le nombre d'arguments est inférieur à 2
6          # on retourne le code erreur 1
7          echo "Nombre arguments incorrect"
8          exit 1
9  else
10          # Si le nombre d'arguments est supérieur ou égal à 2
11          # on retourne le code erreur 0
12          echo "Nombre arguments correct"
13          exit 0
14  fi
$

Exécution du script :

$ ./script.sh
Nombre arguments incorrect
$ echo $?
1
$ ./script.sh test
Nombre arguments incorrect
$ echo $?
1
$ ./script.sh test test2
Nombre arguments correct
$ echo $?
0
$

Autres variables spéciales

La variable $$ représente le PID du shell qui interprète le script.
La valeur de cette variable est la même pendant toute la durée d'exécution du script et différente à chaque utilisation du script.

Exemple :

Dans ce script, la variable $$ est utilisée pour générer le nom d'un dossier différent à chaque exécution du script.

$ nl monQuatriemeScript.sh
     1  #! /bin/bash
     2  dossierTemp=dossier_$$
     3  echo "Création du dossier \"$dossierTemp\""
     4  mkdir $dossierTemp
     5  cd $dossierTemp
     6  for (( i=0 ; i<10 ; i++)) do
     7          touch fichier_$i
     8  done
     9  exit 0
$

$ ./monQuatriemeScript.sh
Création du dossier "dossier_26563"
$ ./monQuatriemeScript.sh
Création du dossier "dossier_26581"
$

La variable $! représente le PID d'une commande exécutée en arrière plan.

exemple :

$ nl monCinquiemeScript.sh
     1  #! /bin/bash
     2  echo "Le script est exécuté sous le PID $$"
     3  find /etc -name $1 1> resultat 2> /dev/null &
     4  echo "La commande FIND est en cours d'exécution sous le PID $!"
     5  ps
     6  exit 0
$

$ ./monCinquiemeScript.sh hosts.allow
Le script est exécuté sous le PID 29999
La commande FIND est en cours d'exécution sous le PID 30000
  PID TTY          TIME CMD
19703 pts/0    00:00:00 bash
29999 pts/0    00:00:00 monCinquiemeScr
30000 pts/0    00:00:00 find
30001 pts/0    00:00:00 ps
$

La commande read

La commande read lit son entrée standard et affecte les valeurs saisies dans la ou les variables passées en argument.

Lecture au clavier

$ read var1
coucou
$ echo $var1
coucou
$

Tous les mots saisis sont stockés dans la variables var1

$ read var1
coucou tout le monde
$ echo $var1
coucou tout le monde
$

Le premier mot est stocké dans var1 et le second dans var2

$ read var1 var2
A bientot
$ echo $var1
A
$ echo $var2
bientot
$

Le premier mot est stocké dans var1 et les autres dans var2

$ read var1 var2
A bientot tout le monde
$ echo $var1
A
$ echo $var2
bientot tout le monde
$

Le mot est stocké dans var1 et var2 est vide

$ read var1 var2
Bonjour
$ echo $var1
Bonjour
$ echo $var2
 
$

En KSH, il est possible d'associer un message à la commande read

$ read var1?"Saisir une valeur : "
Saisir une valeur : coucou
$ echo $var1
coucou
$

Code de retour

Le code retour de la commande read est vrai (0) si un texte est saisi et faux (1) si la commande est interrompue en appuyant sur ctrl+d (^d)

$ read var1
coucou
$ echo $?
0
$ echo $var1
coucou
$

$ read var1
[Entrée]
$ echo $?
0
$ echo $var1
 
$

$ read var1
$ ^d
$ echo $?
1
$ echo $var1
 
$

La variable IFS

Cette variable contient les caractères qui permettent de scinder les entrées au clavier.
Par défaut elle contient les caractères espace, tabulation (\t) et saut de ligne (\n)

Le contenu de cette variable peut être modifié

$ OLDIFS="$IFS"
$ IFS="|"                                       # modification du caractère de séparation
$ read var1 var2 var3
colonne1|colonne2|colonne3
$ echo $var1
colonne1
$ echo $var2
colonne2
$ echo $var3
colonne3
$ IFS="$OLDIFS"
$

Les expression $IFS et $OLDIFS doivent obligatoirement être placées entre guillemets pour que les caractères internes ne soient pas interprétés par le shell

En BASH, il est possible d'associer un message à la commande read grâce à l'option -p :

$ read -p "Votre nom ? " NAME
Votre nom ? toto
$ echo $NAME
toto

En y ajoutant l'option -s , il est possible d'utiliser la commande read pour saisir un mot de passe :

$ read -s -p "Votre passwd ? " PASSWD; echo
Votre passwd ?
$ echo $PASSWD
aaaa

Avec l'option -s, il ne faut pas oublier d'ajouter la commande echo pour afficher un saut de ligne.

Exécution de tests

La commande test permet de faire des tests sur des fichiers, des chaines de caractères et des nombres.

Elle renvoie le code retour 0 (vrai) ou 1 (faux) qu'il est possible de consulter en affichant la valeur de $?

Il existe 2 syntaxes pour utiliser la commande test

$ test expression

$ [ expression ]

La paire de crochet signifie la même chose que la commande test.
Les crochets ouvrants et fermants doivent obligatoirement être suivis et précédés d'un espace.

La commande test

Tests sur les fichiers

Expression Code de retour
-b FILE Vrai si le fichier existe et est du type spécial bloc
-c FILE Vrai si le fichier existe et est du type spécial caractère
-d FILE Vrai si le fichier existe et est du type répertoire
-e FILE Vrai si le fichier existe
-f FILE Vrai si le fichier existe et est du type ordinaire
-G FILE Vrai si le fichier existe et si l'utilisateur appartient au groupe propriétaire du fichier
-h FILE Vrai si le fichier existe et est du type lien symbolique
-L FILE Vrai si le fichier existe et est du type lien symbolique (idem -h)
-O FILE Vrai si le fichier existe et si l'utilisateur est le propriétaire du fichier
-r FILE Vrai si le fichier existe et est accessible en lecture
-s FILE Vrai si le fichier existe et n'est pas vide
-S FILE Vrai si le fichier existe et est du type socket
-w FILE Vrai si le fichier existe et est accessible en écriture
-x FILE Vrai si le fichier existe et est exécutable
FILE1 -ef FILE2 Vrai si les fichiers ont le même lien physique
FILE1 -nt FILE2 Vrai si FILE1 est plus récent que FILE2
FILE1 -ot FILE2 Vrai si FILE1 est plus ancien que FILE2

Exemple :

Le fichier /etc/group est un fichier ordinaire

$ test -f /etc/group
$ echo $?
0
$

Le fichier /etc/groupe n'existe pas (test avec l'autre syntaxe)

$ [ -f /etc/groupe ]
$ echo $?
1
$

Le fichier /etc/init.d existe et est un répertoire

$ [ -d /etc/init.d ]
$ echo $?
0
$

Le fichier /etc/group n'est pas un répertoire ou il n'exsite pas

$ test -d /etc/group
$ echo $?
1
$

Le fichier contenu dans la variable file n'est pas un répertoire ou n'existe pas

$ file=/etc/group
$ test -d $file
$ echo $?
1
$

L'utilisateur n'a pas le droit d'écriture sur le fichier /etc/group

$ [ -w /etc/group ]
$ echo $?
1
$

Tests sur les chaines de caractères

Expression Code de retour
-n STRING Vrai si la longueur de la chaine n'est pas égale à 0
-z STRING Vrai si la longueur de la chaine est égale à 0
STRING1 = STRING2 Vrai si les 2 chaines sont égales
STRING1 != STRING2 Vrai si les 2 chaines sont différentes
STRING Vrai si la chaine n'est pas vide (idem -n)

Pour les tests sur les chaines de caractères, il est recommandé de mettre le nom des variables entre guillemets.

Exemple :

Avec les variables suivantes :

$ str1="test1"
$ str2="test2"
$ str3="test1"
$

La variable $str1 n'est pas vide

$ [ -n "$str1" ]
$ echo $?
0
$

$ [ "$str1" ]
$ echo $?
0

$ [ -z "$str1" ]
$ echo $?
1
$

La variable $str4 est vide

$ [ -n "$str4" ]
$ echo $?
1
$

$ [ -z "$str4" ]
$ echo $?
0
$

$ [ "$str4" ]
$ echo $?
1
$

$str1 & $str3 sont identiques

$ [ "$str1" = "$str3" ]
$ echo $?
0
$

$ [ "$str1" != "$str3" ]
$ echo $?
1
$

$str1 & $str2 sont différentes

$ [ "$str1" != "$str2" ]
$ echo $?
0
$

$ [ "$str1" = "$str2" ]
$ echo $?
1
$

Tests sur les nombres

Expression Code de retour
INT1 -eq INT2 Vrai si INT1 est égal à INT2 (=)
INT1 -ge INT2 Vrai si INT1 est supérieur ou égal à INT2 (>=)
INT1 -gt INT2 Vrai si INT1 est supérieur à INT2 (>)
INT1 -le INT2 Vrai si INT1 est inférieur ou égal à INT2 (<=)
INT1 -lt INT2 Vrai si INT1 est inférieur à INT2 (<)
INT1 -ne INT2 Vrai si INT1 est différent de INT2 (!=)

Exemple :

Avec les variables suivantes

$ int1=1
$ int2=2
$ int3=3
$ int4=2
$

$int2 & $int4 sont égaux

$ [ $int2 -eq $int4 ]
$ echo $?
0

$int2 est supérieur ou égal à $int4

$ [ $int2 -ge $int4 ]
$ echo $?
0

$int3 est supérieur ou égal à $int1

$ [ $int3 -ge $int1 ]
$ echo $?
0

$int4 n'est pas supérieur ou égal à $int3

$ [ $int4 -ge $int3 ]
$ echo $?
1

$int3 est supérieur à $int2

$ [ $int3 -gt $int2 ]
$ echo $?
0

$int2 n'est pas supérieur à $int3

$ [ $int2 -gt $int3 ]
$ echo $?
1

$int2 est inférieur ou égal à $int3

$ [ $int2 -le $int3 ]
$ echo $?
0

$int2 est inférieur à $int3

$ [ $int2 -lt $int3 ]
$ echo $?
0

$int2 est inférieur ou égal à $int4

$ [ $int2 -le $int4 ]
$ echo $?
0

$int2 est différent de $int3

$ [ $int2 -ne $int3 ]
$ echo $?
0

$int2 n'est pas différent de $int4

$ [ $int2 -ne $int4 ]
$ echo $?
1
$

Les opérateurs

Opérateur Signification
! Négation
-a ET
-o OU

Les opérateurs sont exécutés avec une priorité bien précise :

  1. ! (négation)
  2. -a (ET)
  3. -o (OU)

 

Le fichier /etc/group n'est pas un répertoire

$ [ ! -d /etc/group ]
$ echo $?
0
$

Le fichier monPremierScript.sh existe et est exécutable

$ [ -f monPremierScript.sh -a -x monPremierScript.sh ]
$ echo $?
0
$

Le fichier monPremierScript.sh n'est pas un répertoire mais il est exécutable

$ [ -d monPremierScript.sh -o -x monPremierScript.sh ]
$ echo $?
0
$

Il est possible de modifier la priorité d'exécution des opérateurs en utilisant des paranthèses.
\(........\)
Les parenthèses doivent être protégées par des antislashes afin de ne pas être interprétées par le shell comme étant un regroupement de commandes.

L'utilisateur doit avoir le droit d'écriture sur le fichier fic1 et le fichier fic4 ou fic7 doit exister

$ ls
fic1  fic2  fic3  fic4  fic5  fic6  script.sh
$ [ -w fic1 -a \( -e fic4 -o -e fic7 \) ]
$ echo $?
0
$

Il doit toujours y avoir un espace autour des opérateurs !, -a et -o.

Exemples d'utilisation

Utilisation de la commande test avec la structure de controle if.

Principe d'utilisation :

if  commande1 
then
     commande2
     commande3
     ...
else
     commande4
     ...
fi

if  commande1  ; then
     commande2
     commande3
     ...
else
     commande4
     ...
fi

La commande1 est exécutée, si son code retour ($?) vaut 0 (vrai) alors les commandes 2 & 3 sont exécutées, sinon c'est la commande4 qui est exécutée (code retour de la commande1 supérieur à 0 - faux).

Exemple :

Dans l'exemple suivant, le script test s'il reçoit bien au minimum 2 arguments.
Dans le cas contraire, le script affiche un message indiquant que le nombre d'arguments est incorrect et se termine en retournant un code erreur 1.

$ nl monTroisiemeScript.sh
     1  #! /bin/bash
     2  # Ce script doit recevoir en premier argument le nom d'un dossier puis des noms de fichiers pour les suivants
     4  # Ce script doit recevoir au minimum 2 arguments
     5  # Le premier étant le nom d'un dossier
     6  # Les suivants étant les noms des fichiers
     7  # On test si il y a 2 arguments au minimum et on retourne le code erreur 1 si c'est faux
     8  if  [ $# -lt 2 ] 
     9  then
    10          echo "Nombre d'arguments incorrect !!!"
    11          exit 1
    12  fi
    13  # On sauvegarde le premier argument dans la variable rep
    14  rep=$1
    15  # On décale tous les arguments avec la commande shift
    16  shift
    17  # Création du répertoire
    18  mkdir $rep
    19  # On se positionne dans le nouveau répertoire
    20  cd $rep
    21  # Création des fichiers dans le nouveau répertoire
    22  for fichier in $*
    23  do
    24          touch $fichier
    25  done
    26  exit 0

$ ./monTroisiemeScript.sh test
Nombre d'arguments incorrect !!!
$ echo $?
1
$

$ ./monTroisiemeScript.sh test3 coucou
$ echo $?
0
$

La commande [[ ]]

La commande [[ ]] est une version améliorée de la commande test.
Tous les opérateurs utilisés avec la commandes test restent valables à l'exception des opérateurs logiques -a et -o respectivement remplacés par && et ||.

Tests sur les chaines

Contrairement à la commande test, il n'est plus nécessaire d'entourer les variables avec des guillemets.

Les différentes syntaxes utilisables :

$ echo $null
 
$ test -z "$null"
$ echo $?
0
$ [ -z "$null" ]
$ echo $?
0
$ [[ -z $null ]]
$ echo $?
0
$ [[ -z "$null" ]]
$ echo $?
0
$ [[ $null = "" ]]
$ echo $?
0
$

Les opérateurs suivants ont été ajoutés :

Opérateurs Code de retour
$chaine = modele Vrai si $chaine correspond au modèle
$chaine != modele Vrai si $chaine ne correspond pas au modèle
$chaine1 < $chaine2 Vrai si $chaine1 est lexicographiquement avant $chaine2
$chaine1 > $chaine2 Vrai si $chaine1 est lexicographiquement après $chaine2

En utilisant les expressions, il est possible de comparer des chaines à des modèles identiques à celles permettant le remplacement des noms de fichiers.

Caractères spéciaux pour modèles de chaines de caractères Signification
Caractères spéciaux valables dans tous les shells :
* 0 à n caractères
? 1 caractère quelconque
[abc] 1 caractère parmis ceux inscrits entre les crochets
[!abc] 1 caractère ne faisant pas partie de ceux inscrits entre les crochets
Caractères spéciaux non valides en Bourne Shell.
En bash, il faut activer l'option extglob (shopt -s extglob)
?(expression) de 0 à 1 fois l'expression
*(expression) de 0 à n fois l'expression
+(expression) de 1 à n fois l'expression
@(expression) 1 fois l'expression
!(expression) 0 fois l'expression
?(expression1 | expression2 | ...)
*(expression1 | expression2 | ...)
+(expression1 | expression2 | ...)
@(expression1 | expression2 |...)
!(expression1 | expression2 | ...)
alternatives

Exemple :

Le script suivant test si le numéro de téléphone saisi correspond bien au format +33240346523 ou 0240346523

$ nl test_telephone.sh
     1  #! /bin/bash
 
     2  echo -e "Saisir un numéro de téléphone : \c"
     3  read telephone
 
     4  # Test si le téléphone saisi est de la forme
     5  # +33240346523 ou 0240346523
 
     6  if [[ $telephone = @(+33)@([1-9])@([0-9])@([0-9])@([0-9])@([0-9])@([0-9])@([0-9])@([0-9])@([0-9]) ||
     7        $telephone = @(0)@([0-9])@([0-9])@([0-9])@([0-9])@([0-9])@([0-9])@([0-9])@([0-9])@([0-9]) ]]
     8  then
     9          echo "Le numéro est correct"
    10          exit 0
    11  else
    12          echo "Le numéro est incorrect"
    13          exit 1
    14  fi
$ ./test_telephone.sh
Saisir un numéro de téléphone : 0240020202
Le numéro est correct
$ ./test_telephone.sh
Saisir un numéro de téléphone : +33256985478
Le numéro est correct
$ ./test_telephone.sh
Saisir un numéro de téléphone : 2356958457
Le numéro est incorrect
$ ./test_telephone.sh
Saisir un numéro de téléphone : +33025146987
Le numéro est incorrect
$ ./test_telephone.sh
Saisir un numéro de téléphone : g52365
Le numéro est incorrect
$

Tests logiques

Rappels :

  • Les opérateurs -a et -o sont respectivement remplacés par && et ||
  • Les parenthèses n'ont plus besoin d'être protégées
Commande test ( [ ] ) Commande [[ ]] Signification
\(.....\) (.....) Regroupement d'expressions
! ! Négation
-a && ET logique
-o || OU logique

Exemple avec la commande test :

if [ -w $fic1 -a \( -e $rep1 -o -e $rep2 \) ]
then
.....

Exemple avec la commande [[ ]] :

if [[ -w $fic1 && ( -e $rep1 || -e $rep2 ) ]]
then
.....

Les opérateurs du shell

Ces opérateurs permettent d'exécuter ou non une commande en fonction du code de retour d'une autre commande.

Opérateur Signification
&& ET logique
|| OU logique

 

Evaluation de l'opérateur &&

Syntaxe :

commande1 && commande2

La seconde commande (commande2) est exécutée uniquement si le code de retour de la commande (commande1) est égale à 0 (vrai).

Le code de retour global est égal à 0 (vrai) si le code de retour de chaque commande est égal à 0 (vrai).

Exemple :

Le répertoire temp/temp2 n'existe pas donc la commande cd n'est pas exécutée

$ ls -d temp/temp2
ls: impossible d'accéder à temp/temp2: Aucun fichier ou dossier de ce type
$ pwd
/home/toto
$ [[ -d temp/temp2 ]] && cd temp/temp2
$ echo $?                     # code de retour de la commande [[ ]]
1
$ pwd
/home/toto
$

Le répertoire temp/temp2 existe donc la commande cd est exécutée

$ mkdir temp/temp2
$ pwd
/home/toto
$ [[ -d temp/temp2 ]] && cd temp/temp2
$ echo $?                     # code de retour de la commande globale
0
$ pwd
/home/toto/temp/temp2
$

Le répertoire temp/temp2 existe mais le répertoire temp/temp3 n'existe pas donc la commande cd retourne un code erreur égal à 1

$ [[ -d temp/temp2 ]] && cd temp/temp3
-bash: cd: temp/temp3: Aucun fichier ou dossier de ce type
$ echo $?                     # code de retour de la commande cd
1
$

Ces actions peuvent également être exécutées avec la structure de commande if

$ pwd
/home/toto
$ ls -d temp/temp2
temp/temp2
$ if [[ -d temp/temp2 ]]
> then
> cd temp/temp2
> fi
$ echo $?
0
$ pwd
/home/toto/temp/temp2
$

Evaluation de l'opérateur ||

Syntaxe :

commande1 || commande2

La seconde commande (commande2) est exécutée uniquement si le code de retour de la commande (commande1) est égale à 1 (faux).

Le code de retour global est égal à 0 (vrai) si au moins une des commandes retourne un code égal à 0 (vrai).

Exemple :

Le répertoire temp/temp2 n'existe pas donc la commande echo est exécutée

$ ls -d temp/temp2
ls: impossible d'accéder à temp/temp2: Aucun fichier ou dossier de ce type
$ [[ -d temp/temp2 ]] || echo "Le répertoire n'existe pas"
Le répertoire n'existe pas
$ echo $?
0
$

Le répertoire temp/temp2 existe donc la commande echo n'est pas exécutée

$ mkdir temp/temp2
$ ls -d temp/temp2
temp/temp2
$ [[ -d temp/temp2 ]] || echo "Le répertoire n'existe pas"
$ echo $?
0
$

Ces actions peuvent également être exécutées avec la structure de commande if

$ ls -d temp/temp2
ls: impossible d'accéder à temp/temp2: Aucun fichier ou dossier de ce type
$ if [[ ! -d temp/temp2 ]]
> then
> echo "Le répertoire n'existe pas"
> fi
Le répertoire n'existe pas
$

Ne pas confondre les opérateurs du shell && et || qui effectuent une opération logique entre deux commandes et les opérateurs && et || de la commande [[ ]] qui sont internes à celle-ci

L'arithmétique

La commande expr

Syntaxe :

expr $nbr1 opérateur $nbr2
expr $chaine : expression régulière

Opérateurs :

Attention, certains opérateurs ayant une signification particulière pour le shell, ceux ci doivent être protégés par un antislash.

Opérateurs Signification
Opérateurs arithmétiques
$nb1 + $nb2 Addition
$nb1 - $nb2 Soustraction
$nb1 \* $nb2 Multiplication
$nb1 / $nb2 Division
$nb1 % $nb2 Modulo
Opérateurs de comparaison
$nb1 \> $nb2 VRAI si $nb1 est strictement supérieur à $nb2
$nb1 \>= $nb2 VRAI si $nb1 est supérieur ou égal à $nb2
$nb1 \< $nb2 VRAI si $nb1 est strictement inférieur à $nb2
$nb1 \<= $nb2 VRAI si $nb1 est inférieur ou égal à $nb2
$nb1 = $nb2 VRAI si $nb1 est égal à $nb2
$nb1 != $nb2 VRAI si $nb1 est diférent de $nb2
Opérateurs logiques
$chaine1 \& $chaine2 VRAI si les 2 chaines sont vraies
$chaine1 \| $chaine2 VRAI si l'une des 2 chaines est vraie
Opérateurs divers
-$nb1 Opposé de $nb1
\( expression \) Regroupement
$chaine : expression_reguliere Compare la chaine avec l'expression régulière

Les arguments de la commande expr doivent toujours être séparés par au moins un espace ou une tabulation.

Exemple :

$ nb=3
$ expr $nb + 5
8
$ expr $nb \* 6
18
$ expr $nb / 2
1
$ nb=10
$ expr $nb % 3
1
$ expr $nb - -5
15
$

Récupérer le résultat dans une variable :

$ nb2=`expr $nb - 2`
$ echo $nb2
8
$

Priorité d'exécution des opérateurs :

$ nb=5
$ nb2=`expr $nb \* 3 + 4`
$ echo $nb2
19
$ nb2=`expr $nb \* \( 3 + 4 \)`
$ echo $nb2
35
$

Résultat d'une comparaison VS valeur du code de retour :

$ nb=2
$ expr $nb \>= 1
1                            # Résultat de la comparaison
$ echo $?
0                            # Résultat du code de retour
$ expr $nb \>= 3
0                            # Résultat de la comparaison
$ echo $?
1                            # Résultat du code de retour
$

Différents types de comparaison :

$ nl comparaison.sh
     1  #!/bin/bash
 
     2  # Test sur le nombre d'arguments
     3  if [[ $# -ne 2 ]]
     4  then
     5          echo "Mauvais nombre d'arguments"
     6          echo "Utilisation : $0 expr1 expr2"
     7          exit 1
     8  fi
 
     9  # On compare expr1 et expr2 avec la commande EXPR et redirection du résultat dans /dev/null
    10  if expr $1 \> $2 > /dev/null
    11  then
    12          echo "Comparaison EXPR : $1 est supérieur à $2"
    13  else
    14          echo "Comparaison EXPR : $1 est inférieur à $2"
    15  fi
 
    16  # On compare expr1 et expr2 avec la commande [[ ]] (lexicographiquement)
    17  if [[ $1 > $2 ]]
    18  then
    19          echo "Comparaison lexico.. [[ ]] : $1 est supérieur à $2"
    20  else
    21          echo "Comparaison lexico.. [[ ]] : $1 est inférieur à $2"
    22  fi
 
    23  # On compare expr1 et expr2 avec la commande [[ ]]
    24  if [[ $1 -gt $2 ]]
    25  then
    26          echo "Comparaison [[ ]] : $1 est supérieur à $2"
    27  else
    28          echo "Comparaison [[ ]] : $1 est inférieur à $2"
    29  fi
 
    30  exit 0
$ ./comparaison.sh 9 5
Comparaison EXPR : 9 est supérieur à 5
Comparaison lexico.. [[ ]] : 9 est supérieur à 5
Comparaison [[ ]] : 9 est supérieur à 5
$ ./comparaison.sh 50 9
Comparaison EXPR : 50 est supérieur à 9
Comparaison lexico.. [[ ]] : 50 est inférieur à 9
Comparaison [[ ]] : 50 est supérieur à 9
$ ./comparaison.sh a b
Comparaison EXPR : a est inférieur à b
Comparaison lexico.. [[ ]] : a est inférieur à b
Comparaison [[ ]] : a est inférieur à b
$ ./comparaison.sh t r
Comparaison EXPR : t est supérieur à r
Comparaison lexico.. [[ ]] : t est supérieur à r
Comparaison [[ ]] : t est inférieur à r
$

Le résultat de la commande EXPR est toujours exact que ce soit des chiffres ou des caractères.

Etiquettes: 

La commande (( ))

Syntaxe :

((expression_arithmétique))

Utilisation :

La commande (( )) dispose de nombreux avantages par rapport à la commande expr

  • Opérateurs supplémentaires
  • Les arguments n'ont pas besoin d'être séparés par des espaces
  • Les variables n'ont pas besoin d'être préfixées par le symbole $
  • Les caractères spéciaux du shell n'ont pas besoin d'être protégés par des antislashes
  • Les affectations se font dans la commande
  • Son exécution est plus rapide

Une grande partie des opérateurs proviennent du langage C

Opérateurs Signification
Opérateurs arithmétiques
nbr1 + nbr2 Addition
nbr1 - nbr2 Soustraction
nbr1 * nbr2 Multiplication
nbr1 / nbr2 Division
nbr1 % nbr2 Modulo
Opérateurs travaillant sur les bits
~nbr1 Complément à 1
nbr1 >> nbr2 Décalage sur nbr1 de nbr2 bits à droite
nbr1 << nbr2 Décalage sur nbr1 de nbr2 bits à gauche
nbr1 & nbr2 ET bit à bit
nbr1 | nbr2 OU bit à bit
nbr1 ^ nbr2 OU exclusif bit à bit
Opérateurs de comparaison
nbr1 > nbr2 VRAI si nbr1 est strictement supérieur à nbr2
nbr1 >= nbr2 VRAI si nbr1 est supérieur ou égal à nbr2
nbr1 < nbr2 VRAI si nbr1 est strictement inférieur à nbr2
nbr1 <= nbr2 VRAI si nbr1 est inférieur ou égal à nbr2
nbr1 == nbr2 VRAI si nbr1 est égal à nbr2
nbr1 != nbr2 VRAI si nbr1 est différent de nbr2
Opérateurs logiques
!nbr1 Inverse la valeur de vérité de nbr1
&& ET
|| OU
Opérateurs divers
-nbr1 Opposé de nbr1
nbr1 = expression Assignement
(expression) Regroupement
nbr1 binop= nbr2 binop représente l'un des opérateurs suivants : +, -, /, *, %, >>, <<, &, |, ^. Equivalent à nbr1 = nbr1 binop nbr2

Exemples :

Ajouter 10 à nbr1 (2 méthodes différentes)

$ nbr1=10
$ ((nbr1=nbr1+10))
$ echo $nbr1
20
$ nbr1=10
$ ((nbr1+=10))
$ echo $nbr1
20
$

Test si nbr1 est supérieur à nbr2 et inversement

$ nbr1=5
$ nbr2=6
$ ((nbr1>nbr2))
$ echo $?
1                           # Code retour 1 (faux) car nbr1 n'est pas supérieur à nbr2
$ ((nbr1<nbr2))
$ echo $?
0                           # Code retour 0 (vrai) car nbr1 est inférieur à nbr2
$

Le script suivant compare les 2 arguments passés en paramètre

$ nl comparaison2.sh
     1  #!/bin/bash
 
     2  # Test sur le nombre d'arguments
     3  if (($#!=2))
     4  then
     5          echo "Mauvais nombre d'arguments"
     6          echo "Utilisation : $0 nbr1 nbr2"
     7          exit 1
     8  fi
 
     9  # On compare nbr1 et nbr2 avec la commande (( ))
    10  if (($1<$2))
    11  then
    12          echo "$1 est inférieur à $2"
    13  else
    14          if (($1>$2))
    15          then
    16                  echo "$1 est supérieur à $2"
    17          else
    18                  if (($1==$2))
    19                  then
    20                          echo "$1 est égal à $2"
    21                  else
    22                          echo "Comparaison impossible"
    23                  fi
    24          fi
    25  fi
 
    26  exit 0
$ ./comparaison2.sh 2 8
2 est inférieur à 8
$ ./comparaison2.sh 8 2
8 est supérieur à 2
$ ./comparaison2.sh 8 8
8 est égal à 8
$

Regroupements et tests logiques

$ nbr1=2
$ nbr2=5
$ if (( (nbr1>0) && (nbr2>nbr1) ))
> then
> echo "nbr1 est supérieur à 0 et inférieur à nbr2"
> else
> echo "nbr1 est égal à 0 ou supérieur à nbr2"
> fi
nbr1 est supérieur à 0 et inférieur à nbr2
$

La commande let

La commande let est équivalente à ((expression))

Syntaxe :

let "expression"

Exemple :

Multiplier nbr1 par 3

$ nbr1=5
$ let "nbr1=nbr1*3"
$ echo $nbr1
15
$

Calculer le modulo de nbr1 par 2 et l'affecter à la variable nbr2

$ nbr1=5
$ let "nbr2=nbr1%2"
$ echo $nbr1
5
$ echo $nbr2
1
$

Etiquettes: 

Substitution d'expressions arithmétiques

Il existe les caractères de substitution de commandes mais il existe également les caractères de substitution d'expressions arithmétiques.

Syntaxe :

commande argument1 $((expression_arithmetique)) ... argumentn

Exemple :

Rappel sur la substitution de commandes

$ echo "Nombre de users connectes : `who | wc -l`"
Nombre de users connectes : 1
ou
$ echo "Nombre de users connectes : $(who | wc -l)"
Nombre de users connectes : 1

Substitution d'expressions arithmétiques

$ cpt=1
$ ((cpt+=1))                               # Le résultat de la commande n'est pas affichée
$ echo $cpt
2
$

$ cpt=1
$ echo "Nouveau compteur : `((cpt+=1))`"
Nouveau compteur :                  # Le résultat de la commande n'est pas affichée et le compteur n'est pas incrémenté
$ echo $cpt
1
$

$ cpt=1
$ echo "Nouveau compteur : $((cpt+=1))"
Nouveau compteur : 2                # Le résultat de la commande est affiché et le compteur est incrémenté
$ echo $cpt
2
$

Il ne faut pas confondre (( )) et $(( )).
(( )) est une commande interne au shell.
$(( )) sont des caractères spéciaux du shell à l'égal de `` ou $().

Mise au point d'un script

Le shell propose quelques options qui permettent de débugger des scripts shell.

Option -x

L'option -x permet de débugger un script shell en affichant l'exécution des commandes après traitement des caractères spéciaux du shell.

Les différentes syntaxes permettant d'activer l'option -x :

Activer l'option

  1. set -x
  2. set -o xtrace
  3. bash -x nom_du_script

Désactiver l'option

  1. set +x
  2. set +o xtrace

Exemple :

Dans l'exemple suivant, la variable fichier n'a pas été préfixée par le symbole $.

$ nl liste.sh
     1  #!/bin/bash
     2  for fichier in `ls`
     3  do
     4          if [[ -f fichier ]]
     5          then
     6                  echo "$fichier"
     7          fi
     8  done
$

L'exécution du script ne retourne aucun résultat malgré la présence de fichiers dans le dossier d'exécution du script.

$ ./liste.sh
$

L'exécution du script avec activation de l'option -x démontre effectivement que la variable fichier n'est pas remplacée par sa valeur.

$ bash -x liste.sh
++ ls
+ for fichier in '`ls`'
+ [[ -f fichier ]]
+ for fichier in '`ls`'
+ [[ -f fichier ]]
+ for fichier in '`ls`'
+ [[ -f fichier ]]
...
$

L'activation de l'option de débuggage peut également être lancée directement dans le script.

$ nl liste.sh
     1  #!/bin/bash
     2  set -x
     3  for fichier in `ls`
     4  do
     5          if [[ -f fichier ]]
     6          then
     7                  echo "$fichier"
     8          fi
     9  done
$

Après correction de l'erreur et exécution du script en mode débuggage.

$ nl liste.sh
     1  #!/bin/bash
     2  set -x
     3  for fichier in `ls`
     4  do
     5          if [[ -f "$fichier" ]]
     6          then
     7                  echo "$fichier"
     8          fi
     9  done
$ ./liste.sh
++ ls
+ for fichier in '`ls`'
+ [[ -f 1coucou ]]
+ echo 1coucou
1coucou
+ for fichier in '`ls`'
+ [[ -f 24902 ]]
+ for fichier in '`ls`'
+ [[ -f 25013 ]]
+ for fichier in '`ls`'
+ [[ -f 25031 ]]
+ for fichier in '`ls`'
+ [[ -f 25043 ]]
+ for fichier in '`ls`'
+ [[ -f comparaison2.sh ]]
+ echo comparaison2.sh
comparaison2.sh
...
$

 

Autres options

Fonction Bourne shell, ksh, bash ksh, bash
Lecture des commandes sans exécution et détection des erreurs de syntaxe. set -n
set +n
set -o noexec
set +o noexec
Affichage des commandes avant substitution des caractères spéciaux du shell set -v
set +v
set -o verbose
set +o verbose

Exemple :

Dans l'exemple suivant, un guillemet a été volontairement omis.

$ nl liste.sh
     1  #!/bin/bash
     2  set -n
     3  for fichier in `ls`
     4  do
     5          if [[ -f "$fichier ]]
     6          then
     7                  echo "$fichier"
     8          fi
     9  done
$ ./liste.sh
./liste.sh: line 7: Caractère de fin de fichier (EOF) prématuré lors de la recherche du « " » correspondant
./liste.sh: line 10: argument inattendu pour l'opérateur conditionnel à un argument
./liste.sh: line 10: Erreur de syntaxe : fin de fichier prématurée
$

$ nl liste.sh
     1  #!/bin/bash
     2  set -v
     3  for fichier in `ls`
     4  do
     5          if [[ -f "$fichier ]]
     6          then
     7                  echo "$fichier"
     8          fi
     9  done
$ ./liste.sh
for fichier in `ls`
do
        if [[ -f "$fichier ]]
        then
                echo "$fichier"
        fi
done
./liste.sh: line 7: Caractère de fin de fichier (EOF) prématuré lors de la recherche du « " » correspondant
./liste.sh: line 10: argument inattendu pour l'opérateur conditionnel à un argument
./liste.sh: line 10: Erreur de syntaxe : fin de fichier prématurée
$