105.1 Leçon 2
Certification : |
LPIC-1 |
---|---|
Version : |
5.0 |
Thème : |
105 Shells et scripts shell |
Objectif : |
105.1 Personnaliser et utiliser l’environnement shell |
Leçon : |
2 sur 3 |
Introduction
Une variable est une sorte de boîte imaginaire dans laquelle on range provisoirement un bout d’information. Comme pour les scripts d’initialisation, Bash distingue deux types de variables : shell/local (celles qui n’existent que dans les limites du shell dans lequel elles ont été créées) et environment/global (celles qui sont héritées par les shells et/ou les processus enfants). Dans la leçon précédente, nous avons examiné les shells et leurs scripts de configuration ou d’initialisation. La puissance de ces fichiers de démarrage réside dans le fait qu’ils nous permettent d’utiliser des variables — ainsi que des alias et des fonctions — qui nous aident à créer et à personnaliser l’environnement shell de notre choix.
Variables : Affectation et référence
Une variable peut être définie comme un nom qui contient une valeur.
Dans Bash, l’attribution d’une valeur à un nom est appelée affectation de variable et c’est la manière par laquelle nous créons ou définissons des variables. D’autre part, le processus qui permet d’accéder à la valeur contenue dans le nom est appelé référencement de variable.
Voici la syntaxe pour affecter des variables :
<variable_name>=<variable_value>
Par exemple :
$ distro=zorinos
La variable distro
est égale à zorinos
, c’est-à-dire qu’il existe une portion de mémoire qui contient la valeur zorinos
— et distro
constitue le pointeur vers cette valeur.
Notez toutefois qu’il ne peut y avoir d’espace de part et d’autre du signe égal lors de l’affectation d’une variable :
$ distro =zorinos -bash: distro: command not found $ distro= zorinos -bash: zorinos: command not found
À cause de notre erreur, Bash a interprété distro
et zorinos
comme des commandes.
Pour référencer une variable (c’est-à-dire pour connaître sa valeur), on utilise la commande echo
en faisant précéder le nom de la variable du signe $
:
$ echo $distro zorinos
Noms de variables
Lorsque nous choisissons les noms des variables, nous devons prendre en compte un certain nombre de règles.
Le nom d’une variable peut contenir des lettres (a-z
, A-Z
), des chiffres (0-9
) et des tirets bas (_
) :
$ distro=zorinos $ echo $distro zorinos $ DISTRO=zorinos $ echo $DISTRO zorinos $ distro_1=zorinos $ echo $distro_1 zorinos $ _distro=zorinos $ echo $_distro zorinos
Il ne doit pas commencer par un chiffre, autrement Bash va s’embrouiller :
$ 1distro=zorinos -bash: 1distro=zorinos: command not found
Il ne peut pas contenir d’espaces (même entre guillemets) ; par convention, on utilise plutôt les tirets bas :
$ "my distro"=zorinos -bash: my: command not found $ my_distro=zorinos $ echo $my_distro zorinos
Valeurs des variables
En ce qui concerne la référence ou la valeur des variables, il faut également tenir compte d’un certain nombre de règles.
Les variables peuvent contenir tous les caractères alphanumériques (a-z
, A-Z
, 0-9
) ainsi que la plupart des autres caractères (?
,!
,*
,.
,/
, etc.) :
$ distro=zorin12.4? $ echo $distro zorin12.4?
Les valeurs des variables doivent être placées entre guillemets si elles contiennent des espaces simples :
$ distro=zorin 12.4 -bash: 12.4: command not found $ distro="zorin 12.4" $ echo $distro zorin 12.4 $ distro='zorin 12.4' $ echo $distro zorin 12.4
Les valeurs des variables doivent également être placées entre guillemets si elles contiennent des caractères tels que ceux utilisés pour la redirection (<
,>
) ou la barre verticale (|
). La seule chose que fait la commande suivante est de créer un fichier vide nommé zorin
:
$ distro=>zorin $ echo $distro $ ls zorin zorin
En revanche, ça fonctionne avec les guillemets :
$ distro=">zorin" $ echo $distro >zorin
En revanche, les guillemets simples et les guillemets doubles ne sont pas toujours interchangeables. Selon ce que l’on fait avec une variable (assignation ou référencement), l’utilisation de l’un ou de l’autre a des implications et donnera des résultats différents. Dans le contexte de l’affectation d’une variable, les guillemets simples prennent tous les caractères de la valeur de la variable littéralement, alors que les guillemets doubles permettent une substitution de la variable :
$ lizard=uromastyx $ animal='My $lizard' $ echo $animal My $lizard $ animal="My $lizard" $ echo $animal My uromastyx
Par ailleurs, lorsqu’on référence une variable dont la valeur inclut des espaces initiaux (ou supplémentaires) — parfois combinés avec des astérisques — il faut impérativement utiliser des guillemets doubles après la commande echo
pour éviter le fractionnement des champs et l'expansion des chemins :
$ lizard=" genus | uromastyx" $ echo $lizard genus | uromastyx $ echo "$lizard" genus | uromastyx
Si la référence de la variable contient un point d’exclamation final, celui-ci doit constituer le dernier caractère de la chaîne ( sans quoi Bash estimera qu’il s’agit d’un événement history
) :
$ distro=zorin.?/!os -bash: !os: event not found $ distro=zorin.?/! $ echo $distro zorin.?/!
Les antislashs doivent être échappés par un autre antislash. De plus, si une barre oblique inverse est le dernier caractère de la chaîne et que nous ne l’échappons pas, Bash va considérer que nous souhaitons un retour à la ligne et va nous afficher une nouvelle ligne :
$ distro=zorinos\ > $ distro=zorinos\\ $ echo $distro zorinos\
Dans les deux prochaines sections, nous allons présenter les principales différences entre les variables locales et les variables d’environnement.
Variables locales ou variables du shell
Les variables locales ou variables du shell n’existent que dans le shell dans lequel elles ont été créées. Par convention, les variables locales sont écrites en caractères minuscules.
Pour effectuer quelques tests, nous allons créer une variable locale. Comme nous l’avons vu plus haut, nous choisissons un nom de variable approprié et nous l’associons à une valeur appropriée. Par exemple :
$ reptile=tortoise
Utilisons maintenant la commande echo
pour référencer notre variable et vérifier que tout s’est passé comme prévu :
$ echo $reptile tortoise
Dans certains contextes, par exemple lors de l’écriture de scripts, l’immutabilité peut constituer une caractéristique intéressante pour les variables. Si nous souhaitons que nos variables soient immuables, nous pouvons soit les créer readonly
:
$ readonly reptile=tortoise
Ou les rendre telles une fois qu’elles ont été créées :
$ reptile=tortoise $ readonly reptile
Dorénavant, si nous essayons de changer la valeur de reptile
, Bash va refuser :
$ reptile=lizard -bash: reptile: readonly variable
Note
|
Pour afficher la liste de toutes les variables en lecture seule dans notre session actuelle, tapez |
Une commande pratique pour manipuler les variables locales est set
.
set
affiche toutes les variables et toutes les fonctions du shell actuellement assignées. Comme cela peut représenter beaucoup de lignes (essayez vous-même !), il est recommandé de l’utiliser en combinaison avec un visualiseur comme less
:
$ set | less BASH=/bin/bash BASHOPTS=checkwinsize:cmdhist:complete_fullquote:expand_aliases:extglob:extquote:force_fignore:histappend:interactive_comments:login_shell:progcomp:promptvars:sourcepath BASH_ALIASES=() BASH_ARGC=() BASH_ARGV=() BASH_CMDS=() BASH_COMPLETION_COMPAT_DIR=/etc/bash_completion.d BASH_LINENO=() BASH_SOURCE=() BASH_VERSINFO=([0]="4" [1]="4" [2]="12" [3]="1" [4]="release" [5]="x86_64-pc-linux-gnu") BASH_VERSION='4.4.12(1)-release' (...)
Est-ce que notre variable reptile
est là ?
$ set | grep reptile reptile=tortoise
Oui, la voilà !
En revanche, la variable locale reptile
ne sera pas héritée par les processus enfants créés à partir du shell actuel :
$ bash $ set | grep reptile $
Et, bien évidemment, nous ne pouvons pas non plus afficher sa valeur avec echo
:
$ echo $reptile $
Note
|
En tapant la commande |
Pour réinitialiser des variables (locales ou globales), nous utilisons la commande unset
:
$ echo $reptile tortoise $ unset reptile $ echo $reptile $
Note
|
|
Variables globales ou variables d’environnement
Les variables globales ou variables d’environnement existent pour le shell actuel ainsi que pour tous les processus ultérieurs créés à partir de celui-ci. Par convention, les variables d’environnement s’écrivent en majuscules :
$ echo $SHELL /bin/bash
Nous pouvons transmettre récursivement la valeur de ces variables à d’autres variables :
$ my_shell=$SHELL $ echo $my_shell /bin/bash $ your_shell=$my_shell $ echo $your_shell /bin/bash $ our_shell=$your_shell $ echo $our_shell /bin/bash
Pour qu’une variable locale du shell devienne une variable d’environnement, il faut utiliser la commande export
:
$ export reptile
Avec export reptile
nous avons transformé notre variable locale en une variable d’environnement de sorte que les shells enfants puissent la reconnaître et l’utiliser :
$ bash $ echo $reptile tortoise
De même, export
peut être utilisé pour définir et exporter une variable d’une traite :
$ export amphibian=frog
Nous pouvons désormais lancer une nouvelle instance de Bash et référencer la nouvelle variable avec succès :
$ bash $ echo $amphibian frog
Note
|
Avec |
La commande export
nous affichera également une liste de toutes les variables d’environnement existantes lorsqu’elle est invoquée sans argument (ou avec l’option -p
) :
$ export declare -x HOME="/home/user2" declare -x LANG="en_GB.UTF-8" declare -x LOGNAME="user2" (...) declare -x PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games" declare -x PWD="/home/user2" declare -x SHELL="/bin/bash" declare -x SHLVL="1" declare -x SSH_CLIENT="192.168.1.10 49330 22" declare -x SSH_CONNECTION="192.168.1.10 49330 192.168.1.7 22" declare -x SSH_TTY="/dev/pts/0" declare -x TERM="xterm-256color" declare -x USER="user2" declare -x XDG_RUNTIME_DIR="/run/user/1001" declare -x XDG_SESSION_ID="8" declare -x reptile="tortoise"
Note
|
La commande |
Deux autres commandes peuvent être utilisées pour afficher la liste de toutes les variables d’environnement : env
et printenv
:
$ env SSH_CONNECTION=192.168.1.10 48678 192.168.1.7 22 LANG=en_GB.UTF-8 XDG_SESSION_ID=3 USER=user2 PWD=/home/user2 HOME=/home/user2 SSH_CLIENT=192.168.1.10 48678 22 SSH_TTY=/dev/pts/0 MAIL=/var/mail/user2 TERM=xterm-256color SHELL=/bin/bash SHLVL=1 LOGNAME=user2 XDG_RUNTIME_DIR=/run/user/1001 PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games _=/usr/bin/env
En plus d’être un synonyme de env
, la commande printenv
peut être utilisée de la même manière que la commande echo
pour vérifier la valeur d’une variable :
$ echo $PWD /home/user2 $ printenv PWD /home/user2
Notez cependant qu’avec printenv
, le nom de la variable n’est pas précédé de $
.
Note
|
|
Exécuter un programme dans un environnement modifié
env
peut être utilisé pour modifier l’environnement du shell lors de l’exécution d’un programme.
Pour démarrer une nouvelle session Bash avec un environnement aussi vide que possible — en effaçant la plupart des variables (ainsi que les fonctions et les alias) — nous utiliserons env
avec l’option -i
:
$ env -i bash
À présent, la plupart de nos variables d’environnement ont disparu :
$ echo $USER $
Et il n’en reste que quelques-unes :
$ env LS_COLORS= PWD=/home/user2 SHLVL=1 _=/usr/bin/printenv
Nous pouvons également utiliser env
pour définir une variable donnée pour un programme en particulier.
Dans la leçon précédente, lors de la discussion sur les shells simples non-interactifs, nous avons vu comment les scripts ne lisent pas les fichiers de démarrage standard, mais recherchent plutôt la valeur de la variable BASH_ENV
pour l’utiliser en tant que fichier de démarrage si elle existe.
Voyons comment cela se passe :
-
Nous créons notre propre fichier de démarrage appelé
.startup_script
avec le contenu suivant :CROCODILIAN=caiman
-
Nous écrivons un script Bash nommé
test_env.sh
avec le contenu suivant :#!/bin/bash echo $CROCODILIAN
-
Nous rendons notre script
test_env.sh
exécutable :$ chmod +x test_env.sh
-
Enfin, nous utilisons
env
pour définirBASH_ENV
à.startup_script
pourtest_env.sh
:$ env BASH_ENV=/home/user2/.startup_script ./test_env.sh caiman
La commande
env
est implicite même si nous ne l’utilisons pas :$ BASH_ENV=/home/user2/.startup_script ./test_env.sh caiman
Note
|
Si vous ne comprenez pas la ligne |
Variables d’environnement courantes
Le moment est venu de passer en revue les variables d’environnement les plus pertinentes qui sont définies dans les fichiers de configuration de Bash.
DISPLAY
-
Liée au serveur X, la valeur de cette variable est normalement constituée de trois éléments :
-
Le nom d’hôte (l’absence de celui-ci signifie
localhost
) où le serveur X est exécuté. -
Un deux-points comme délimiteur.
-
Un chiffre (normalement
0
et se réfère à l’affichage de l’ordinateur).$ printenv DISPLAY :0
Une valeur vide pour cette variable signifie que le serveur n’a pas de système graphique. Un chiffre supplémentaire — comme dans
my.xserver:0:1
— ferait référence au numéro de l’écran s’il en existe plus d’un.
-
HISTCONTROL
-
Cette variable contrôle les commandes qui sont sauvegardées dans le
HISTFILE
(voir ci-dessous). Il y a trois valeurs possibles :ignorespace
-
Les commandes qui commencent par une espace ne sont pas enregistrées.
ignoredups
-
Une commande identique à la commande précédente ne sera pas enregistrée.
ignoreboth
-
Les commandes qui entrent dans l’une des deux catégories précédentes ne seront pas enregistrées.
$ echo $HISTCONTROL ignoreboth
HISTSIZE
-
Définit le nombre de commandes à stocker en mémoire pendant la durée de la session du shell.
$ echo $HISTSIZE 1000
HISTFILESIZE
-
Définit le nombre de commandes à enregistrer dans
HISTFILE
au début et à la fin de la session :$ echo $HISTFILESIZE 2000
HISTFILE
-
Le nom du fichier qui enregistre toutes les commandes au fur et à mesure qu’elles sont tapées. Par défaut, ce fichier se situe dans
~/.bash_history
:$ echo $HISTFILE /home/user2/.bash_history
NotePour voir le contenu de
HISTFILE
, il suffit de taperhistory
. Alternativement, nous pouvons spécifier le nombre de commandes que nous voulons voir en ajoutant un argument (le nombre de commandes les plus récentes) àhistory
comme danshistory 3
. HOME
-
Cette variable contient le chemin absolu du répertoire personnel de l’utilisateur actuel et elle est définie lorsque l’utilisateur se connecte.
Ce bout de code — issu de
~/.profile
— est assez intuitif (il source"$HOME/.bashrc"
s’il existe) :# include .bashrc if it exists if [ -f "$HOME/.bashrc" ]; then . "$HOME/.bashrc" fi
NoteSi vous ne comprenez pas bien l’instruction
if
, ne vous inquiétez pas : reportez-vous simplement aux leçons sur les scripts shell.Rappelez-vous que
~
équivaut à$HOME
:$ echo ~; echo $HOME /home/carol /home/carol
NoteLes commandes peuvent être combinées avec un point-virgule (
;
).Nous pouvons le prouver à l’aide d’une condition
if
:$ if [ ~ == "$HOME" ]; then echo "true"; else echo "false"; fi true
NoteRappelez-vous : Le signe égal
=
est utilisé pour l’affectation de variables.==
est utilisé pour tester l’égalité. HOSTNAME
-
Cette variable stocke le nom TCP/IP de l’ordinateur hôte :
$ echo $HOSTNAME debian
HOSTTYPE
-
Celle-ci stocke l’architecture du processeur de l’ordinateur hôte :
$ echo $HOSTTYPE x86_64
LANG
-
Cette variable enregistre la localisation du système :
$ echo $LANG en_UK.UTF-8
LD_LIBRARY_PATH
-
Cette variable consiste en une liste de répertoires, séparés par deux points, dans lesquels les programmes ont accès aux bibliothèques partagées :
$ echo $LD_LIBRARY_PATH /usr/local/lib
MAIL
-
Cette variable indique le fichier dans lequel Bash va chercher le courrier électronique :
$ echo $MAIL /var/mail/carol
Une autre valeur courante pour cette variable est
/var/spool/mail/$USER
. MAILCHECK
-
Cette variable enregistre une valeur numérique qui indique en secondes la fréquence à laquelle Bash vérifie l’arrivée de nouveaux e-mails :
$ echo $MAILCHECK 60
PATH
-
Cette variable d’environnement contient la liste des répertoires dans lesquels Bash va chercher les fichiers exécutables lorsqu’on lui demande d’exécuter un programme. Dans notre machine de test, cette variable est définie dans le fichier système
/etc/profile
:if [ "`id -u`" -eq 0 ]; then PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin" else PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games" fi export PATH
L’instruction
if
vérifie l’identité de l’utilisateur et — en fonction du résultat (root
ou autre) — nous obtenons l’un ou l’autre desPATH
. Au final, lePATH
sélectionné est propagé avecexport
.Notez deux détails concernant la valeur de
PATH
:-
Les noms des répertoires sont écrits en utilisant des chemins absolus.
-
Le deux-points est utilisé comme délimiteur.
Pour ajouter le dossier
/usr/local/sbin
dans lePATH
des utilisateurs réguliers, il faudrait modifier la ligne de manière à ce qu’elle ressemble à ceci :(...) else PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/usr/local/sbin" fi export PATH
Nous pouvons voir à présent comment la valeur de la variable change lorsque nous nous connectons en tant qu’utilisateur normal :
# su - carol $ echo $PATH /usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/usr/local/sbin
NoteNous aurions également pu ajouter
/usr/local/sbin
en ligne de commande en tapant soitPATH=/usr/local/sbin:$PATH
soitPATH=$PATH:/usr/local/sbin
— le premier faisant de/usr/local/sbin
le premier répertoire à rechercher pour les fichiers exécutables ; le second le dernier.
-
PS1
-
Cette variable enregistre la valeur de l’invite Bash. Dans le bout de code qui suit (également issu de
/etc/profile
), l’instructionif
teste l’identité de l’utilisateur et lui attribue une invite très discrète (#
pourroot
ou$
pour les utilisateurs normaux) :if [ "`id -u`" -eq 0 ]; then PS1='# ' else PS1='$ ' fi
NoteL’identifiant
id
deroot
est0
. Devenezroot
et voyez par vous-même avecid -u
.Voici les autres variables d’invite :
PS2
-
Normalement réglé sur
>
et utilisé comme invite de continuation pour les commandes longues et multilignes. PS3
-
Utilisé comme invite pour la commande
select
. PS4
-
Normalement fixé à
+
et utilisé pour le débogage.
SHELL
-
Cette variable contient le chemin absolu du shell utilisé :
$ echo $SHELL /bin/bash
USER
-
Enregistre le nom de l’utilisateur actuel :
$ echo $USER carol
Exercices guidés
-
Regardez l’affectation de la variable dans la colonne “Commande(s)” et indiquez si la variable résultante est “Locale” ou “Globale” :
Commande(s) Locale Globale debian=mother
ubuntu=deb-based
mint=ubuntu-based; export mint
export suse=rpm-based
zorin=ubuntu-based
-
Examinez la “Commande” et le “Résultat” et expliquez leur “Signification” :
Commande Résultat Signification echo $HISTCONTROL
ignoreboth
echo ~
/home/carol
echo $DISPLAY
reptilium:0:2
echo $MAILCHECK
60
echo $HISTFILE
/home/carol/.bash_history
-
Les variables sont définies de manière incorrecte dans la colonne “Commande erronée”. Fournissez les informations manquantes dans les colonnes “Commande correcte” et “Référence de la variable” afin d’obtenir le “Résultat attendu” :
Commande erronée Commande correcte Référence de la variable Résultat attendu lizard =chameleon
chameleon
cool lizard=chameleon
chameleon
lizard=cha{pipe}me{pipe}leon
cha{pipe}me{pipe}leon
lizard=/* :pipe: | :backtick: `* :pipe: | :backtick: ` chameleon * :pipe: | :backtick: `* :pipe: | :backtick: `/
/* :pipe: | :backtick: `* :pipe: | :backtick: ` chamelon * :pipe: | :backtick: `* :pipe: | :backtick: `/
win_path=C:\path\to\dir\
C:\path\to\dir\
-
Réfléchissez à l' “Objectif” et écrivez la “Commande” appropriée :
Objectif Commande Définir la langue du shell actuel en espagnol UTF-8 (
es_ES.UTF-8
).Afficher le nom du répertoire courant.
Référencer la variable d’environnement qui enregistre les informations sur les connexions
ssh
.Définir
PATH
pour inclure/home/carol/scripts
en tant que dernier répertoire dans lequel il faut chercher les exécutables.Définir la valeur de
my_path
àPATH
.Définir la valeur de
my_path
à celle dePATH
. -
Créez une variable locale nommée
mammal
et affectez-lui la valeurgnu
: -
En utilisant la substitution de variables, créez une autre variable locale nommée
var_sub
avec la valeur appropriée de sorte que lorsqu’elle est référencée parecho $var_sub
nous obtenonsThe value of mammal is gnu
: -
Transformez
mammal
en variable d’environnement : -
Retrouvez-la avec
set
etgrep
: -
Retrouvez-la avec
env
etgrep
: -
En deux commandes consécutives, créez une variable d’environnement nommée
BIRD
dont la valeur estpenguin
: -
En une seule commande, créez une variable d’environnement nommée
NEW_BIRD
dont la valeur estyellow-eyed penguin
: -
En supposant que vous êtes
user2
, utilisezmkdir
pour créer un dossier nommébin
dans votre répertoire personnel : -
Tapez la commande pour ajouter le dossier
~/bin
à votrePATH
afin qu’il soit le premier répertoire dans lequelbash
recherche des binaires : -
Pour assurer que la valeur de
PATH
reste inchangée après un redémarrage, quel bout de code — sous forme d’une instructionif
— devriez-vous ajouter dans~/.profile
?
Exercices d’approfondissement
-
let
: plus que l’évaluation d’une expression arithmétique :-
Faites une recherche dans le manuel en ligne ou sur le web à propos de
let
et son fonctionnement pour la définition des variables et créez une nouvelle variable locale nomméemy_val
dont la valeur est10
— en additionnant 5 et 5 : -
Ensuite, créez une autre variable nommée
your_val
et dont la valeur est5
— en divisant par 2 la valeur demy_val
:
-
-
Le résultat d’une commande dans une variable ? Bien sûr que c’est possible ; c’est ce qu’on appelle la substitution de commande. Essayez en étudiant la fonction suivante, nommée
music_info
:music_info(){ latest_music=`ls -l1t ~/Music | head -n 6` echo -e "Your latest 5 music files:\n$latest_music" }
Le résultat de la commande
ls -l1t ~/Music | head -n 6
devient la valeur de la variablelatest_music
. Ensuite, la variablelatest_music
est référencée dans la commandeecho
(qui affiche le nombre total d’octets occupés par le dossierMusic
et les cinq derniers fichiers musicaux stockés dans le dossierMusic
— un par ligne).Laquelle des commandes suivantes est un remplacement valide pour
latest_music=`ls -l1t ~/Music | head -n 6`
Option A :
latest_music=$(ls -l1t ~/Music| head -n 6)
Option B :
latest_music="(ls -l1t ~/Music| head -n 6)"
Option C :
latest_music=((ls -l1t ~/Music| head -n 6))
Résumé
Voici ce que nous avons vu dans cette leçon :
-
Les variables sont une partie très importante de l’environnement du shell étant donné qu’elles sont utilisées par l’interpréteur de commandes lui-même ainsi que par d’autres programmes.
-
Comment affecter et référencer des variables.
-
Les différences entre les variables locales et les variables globales (ou variables d’environnement).
-
Comment rendre les variables en lecture seule (readonly).
-
Comment transformer une variable locale en variable d’environnement avec la commande
export
. -
Comment afficher la liste de toutes les variables d’environnement.
-
Comment exécuter un programme dans un environnement modifié.
-
Comment rendre les variables persistantes à l’aide des scripts de démarrage.
-
Quelques variables d’environnement courantes :
DISPLAY
,HISTCONTROL
,HISTSIZE
,HISTFILESIZE
,HISTFILE
,HOME
,HOSTNAME
,HOSTTYPE
,LANG
,LD_LIBRARY_PATH
,MAIL
,MAILCHECK
,PATH
,PS1
(et d’autres variables d’invite),SHELL
etUSER
. -
La signification du tilde (
~
). -
Les fondamentaux des instructions
if
.
Commandes utilisées dans cette leçon :
echo
-
Référence une variable.
ls
-
Affiche le contenu d’un répertoire.
readonly
-
Rend les variables immuables. Affiche la liste de toutes les variables en lecture seule dans la session en cours.
set
-
Affiche toutes les variables et les fonctions de la session en cours.
grep
-
Affiche les lignes qui correspondent à un motif.
bash
-
Lance un nouveau shell.
unset
-
Réinitialise une variable.
export
-
Transforme une variable locale en variable d’environnement. Affiche les variables d’environnement.
env
-
Affiche les variables d’environnement. Lance un programme dans un environnement modifié.
printenv
-
Affiche les variables d’environnement. Référence une variable.
chmod
-
Modifie les permissions d’un fichier, par exemple pour le rendre exécutable.
history
-
Affiche les commandes précédentes.
su
-
Modifier l’ID de l’utilisateur ou devenir superutilisateur.
id
-
Affiche l’ID de l’utilisateur.
Réponses aux exercices guidés
-
Regardez l’affectation de la variable dans la colonne “Commande(s)” et indiquez si la variable résultante est “Locale” ou “Globale” :
Commande(s) Locale Globale debian=mother
Oui
Non
ubuntu=deb-based
Oui
Non
mint=ubuntu-based; export mint
Non
Oui
export suse=rpm-based
Non
Oui
zorin=ubuntu-based
Oui
Non
-
Examinez la “Commande” et le “Résultat” et expliquez leur “Signification” :
Commande Résultat Signification echo $HISTCONTROL
ignoreboth
Les commandes redondantes et celles qui commencent par un espace ne seront pas enregistrées dans
history
.echo ~
/home/carol
Le
HOME
decarol
est/home/carol
.echo $DISPLAY
reptilium:0:2
La machine
reptilium
a un serveur X en marche et nous utilisons le deuxième écran de l’affichage.echo $MAILCHECK
60
Le courrier est vérifié toutes les minutes.
echo $HISTFILE
/home/carol/.bash_history
history
sera enregistré dans/home/carol/.bash_history
. -
Les variables sont définies de manière incorrecte dans la colonne “Commande erronée”. Fournissez les informations manquantes dans les colonnes “Commande correcte” et “Référence de la variable” afin d’obtenir le “Résultat attendu” :
Commande erronée Commande correcte Référence de la variable Résultat attendu lizard =chameleon
lizard=chameleon
echo $lizard
chameleon
cool lizard=chameleon
cool_lizard=chameleon
(par exemple)echo $cool_lizard
chameleon
lizard=cha{pipe}me{pipe}leon
lizard="cha{pipe}me{pipe}leon"
oulizard='cha{pipe}me{pipe}leon'
echo $lizard
cha{pipe}me{pipe}leon
lizard=/* :pipe: | :backtick: `* :pipe: | :backtick: ` chameleon * :pipe: | :backtick: `* :pipe: | :backtick: `/
lizard="/* :pipe: | :backtick: `* :pipe: | :backtick: ` chameleon * :pipe: | :backtick: `* :pipe: | :backtick: `/"
oulizard='/* :pipe: | :backtick: `* :pipe: | :backtick: ` chameleon * :pipe: | :backtick: `* :pipe: | :backtick: `/'
echo "$lizard"
/* :pipe: | :backtick: `* :pipe: | :backtick: ` chamelon * :pipe: | :backtick: `* :pipe: | :backtick: `/
win_path=C:\path\to\dir\
win_path=C:\\path\\to\\dir\\
echo $win_path
C:\path\to\dir\
-
Réfléchissez à l' “Objectif” et écrivez la “Commande” appropriée :
Objectif Commande Définir la langue du shell actuel en espagnol UTF-8 (
es_ES.UTF-8
).LANG=es_ES.UTF-8
Afficher le nom du répertoire courant.
echo $PWD
oupwd
Référencer la variable d’environnement qui enregistre les informations sur les connexions
ssh
.echo $SSH_CONNECTION
Définir
PATH
pour inclure/home/carol/scripts
en tant que dernier répertoire dans lequel il faut chercher les exécutables.PATH=$PATH:/home/carol/scripts
Définir la valeur de
my_path
àPATH
.my_path=PATH
Définir la valeur de
my_path
à celle dePATH
.my_path=$PATH
-
Créez une variable locale nommée
mammal
et affectez-lui la valeurgnu
:mammal=gnu
-
En utilisant la substitution de variables, créez une autre variable locale nommée
var_sub
avec la valeur appropriée de sorte que lorsqu’elle est référencée parecho $var_sub
nous obtenonsThe value of mammal is gnu
:var_sub="The value of mammal is $mammal"
-
Transformez
mammal
en variable d’environnement :export mammal
-
Retrouvez-la avec
set
etgrep
:set | grep mammal
-
Retrouvez-la avec
env
etgrep
:env | grep mammal
-
En deux commandes consécutives, créez une variable d’environnement nommée
BIRD
dont la valeur estpenguin
:BIRD=penguin; export BIRD
-
En une seule commande, créez une variable d’environnement nommée
NEW_BIRD
dont la valeur estyellow-eyed penguin
:export NEW_BIRD="yellow-eyed penguin"
ou bien
export NEW_BIRD='yellow-eyed penguin'
-
En supposant que vous êtes
user2
, utilisezmkdir
pour créer un dossier nommébin
dans votre répertoire personnel :mkdir ~/bin
ou bien
mkdir /home/user2/bin
ou alors
mkdir $HOME/bin
-
Tapez la commande pour ajouter le dossier
~/bin
à votrePATH
afin qu’il soit le premier répertoire dans lequelbash
recherche des binaires :PATH="$HOME/bin:$PATH"
PATH=~/bin:$PATH
ouPATH=/home/user2/bin:$PATH
sont également valables. -
Pour assurer que la valeur de
PATH
reste inchangée après un redémarrage, quel bout de code — sous forme d’une instructionif
— devriez-vous ajouter dans~/.profile
?if [ -d "$HOME/bin" ] ; then PATH="$HOME/bin:$PATH" fi
Réponses aux exercices d’approfondissement
-
let
: plus que l’évaluation d’une expression arithmétique :-
Faites une recherche dans le manuel en ligne ou sur le web à propos de
let
et son fonctionnement pour la définition des variables et créez une nouvelle variable locale nomméemy_val
dont la valeur est10
— en additionnant 5 et 5 :let "my_val = 5 + 5"
ou bien
let 'my_val = 5 + 5'
-
Ensuite, créez une autre variable nommée
your_val
et dont la valeur est5
— en divisant par 2 la valeur demy_val
:let "your_val = $my_val / 2"
ou bien
let 'your_val = $my_val / 2'
-
-
Le résultat d’une commande dans une variable ? Bien sûr que c’est possible ; c’est ce qu’on appelle la substitution de commande. Essayez en étudiant la fonction suivante, nommée
music_info
:music_info(){ latest_music=`ls -l1t ~/Music | head -n 6` echo -e "Your latest 5 music files:\n$latest_music" }
Le résultat de la commande
ls -l1t ~/Music | head -n 6
devient la valeur de la variablelatest_music
. Ensuite, la variablelatest_music
est référencée dans la commandeecho
(qui affiche le nombre total d’octets occupés par le dossierMusic
et les cinq derniers fichiers musicaux stockés dans le dossierMusic
— un par ligne).Laquelle des commandes suivantes est un remplacement valide pour
latest_music=`ls -l1t ~/Music | head -n 6`
C’est l’option A :
latest_music=$(ls -l1t ~/Music| head -n 6)