105.1 Leçon 3

105.1 Leçon 3

Certification :

LPIC-1

Version :

5.0

Thème :

105 Shells et scripts shell

Objectif :

105.1 Personnaliser et utiliser l’environnement shell

Leçon :

3 sur 3

Introduction

Nous avons abordé les shells, les scripts de démarrage et les variables dans les leçons précédentes, et nous allons compléter la personnalisation du shell en regardant de près deux éléments importants du shell : les alias et les fonctions. En fait, c’est l’ensemble des variables, des alias et des fonctions — avec leurs interactions mutuelles — qui constitue l’environnement du shell.

Le point fort de ces deux éléments du shell, qui permettent de gagner en souplesse et en temps, est lié au concept d’encapsulation : ils offrent la possibilité de rassembler — sous une seule commande — une série de commandes répétitives ou récurrentes.

Créer des alias

Un alias est un nom de substitution pour une ou plusieurs autres commandes. Il peut être exécuté comme une commande normale, mais il exécute une autre commande en fonction de la définition de l’alias.

La syntaxe pour déclarer un alias est assez simple. Un alias est déclaré en écrivant le mot-clé alias suivi de l’affectation de l’alias. Cette dernière se compose du nom de l’alias, d’un signe égal et d’une ou plusieurs commandes :

alias alias_name=command(s)

Par exemple :

$ alias oldshell=sh

Cet alias peu commode va lancer une instance du shell ancestral sh lorsque l’utilisateur tape oldshell dans le terminal :

$ oldshell
$

La puissance des alias réside dans le fait qu’ils nous permettent d’écrire des versions courtes de commandes longues à taper :

$ alias ls='ls --color=auto'
Note

Pour en savoir plus sur ls et ses couleurs, tapez man dir_colors dans le terminal.

De même, nous pouvons créer un alias pour une série de commandes concaténées — le point-virgule (;) sera utilisé comme délimiteur. Nous pouvons, par exemple, avoir un alias qui nous donne des informations sur l’emplacement de l’exécutable git ainsi que sa version :

$ alias git_info='which git;git --version'

Pour invoquer un alias, il suffit de taper son nom dans le terminal :

$ git_info
/usr/bin/git
git version 2.7.4

La commande alias affiche la liste de tous les alias disponibles sur le système :

$ alias
alias git-info='which git;git --version'
alias ls='ls --color=auto'
alias oldshell='sh'

La commande unalias supprime un alias. Nous pouvons, par exemple, invoquer unalias git_info et le voir disparaître de la liste :

$ unalias git_info
$ alias
alias ls='ls --color=auto'
alias oldshell='sh'

Comme nous l’avons vu avec la commande alias hi='echo We salute you.' dans une leçon précédente, nous devons entourer les commandes de guillemets (simples ou doubles) lorsqu’elles contiennent des espaces en raison de la présence d’arguments ou de paramètres :

$ alias greet='echo Hello world!'
$ greet
Hello world!

Les commandes avec des espaces comprennent également celles avec des options :

$ alias ll='ls -al'

Maintenant ll va afficher tous les fichiers — y compris les fichiers cachés (a) — dans le format long (l).

Nous pouvons référencer des variables dans un alias :

$ reptile=uromastyx
$ alias greet='echo Hello $reptile!'
$ greet
Hello uromastyx!

La variable peut également être affectée à l’intérieur de l’alias :

$ alias greet='reptile=tortoise; echo Hello $reptile!'
$ greet
Hello tortoise!

Nous pouvons échapper un alias avec \ :

$ alias where?='echo $PWD'
$ where?
/home/user2
$ \where?
-bash: where?: command not found

Échapper un alias est utile lorsqu’un alias porte le même nom qu’une commande normale. Dans ce cas, l’alias a la priorité sur la commande originale, qui reste toutefois accessible en échappant l’alias.

De même, nous pouvons placer un alias à l’intérieur d’un autre alias :

$ where?
/home/user2
$ alias my_home=where?
$ my_home
/home/user2

Par ailleurs, nous pouvons également placer une fonction à l’intérieur d’un alias, comme vous allez le voir ci-dessous.

Expansion et interprétation des guillemets dans les alias

Pour les variables d’environnement, les guillemets simples rendent l’expansion dynamique :

$ alias where?='echo $PWD'
$ where?
/home/user2
$ cd Music
$ where?
/home/user2/Music

En revanche, l’expansion s’effectue de manière statique avec les guillemets doubles :

$ alias where?="echo $PWD"
$ where?
/home/user2
$ cd Music
$ where?
/home/user2

Persistance des alias : scripts de démarrage

Tout comme pour les variables, les alias doivent être rangés dans des scripts d’initialisation sourcés au démarrage pour les rendre persistants. Comme nous l’avons vu, un fichier approprié pour ranger les alias des utilisateurs et ~/.bashrc. Vous y trouverez probablement déjà quelques alias prédéfinis (la plupart d’entre eux sont commentés et prêts à l’emploi dès que vous supprimez le # initial) :

$ grep alias .bashrc
# enable color support of ls and also add handy aliases
    alias ls='ls --color=auto'
    #alias dir='dir --color=
    #alias vdir='vdir --color=
    #alias grep='grep --color=
    #alias fgrep='fgrep --color'
    #alias egrep='egrep --color=
# some more ls aliases
#ll='ls -al'
#alias la='ls -A'
#alias l='ls -CF'
# ~/.bash_aliases, instead of adding them here directly.
if [ -f ~/.bash_aliases ]; then
   . ~/.bash_aliases

Comme vous pouvez le voir dans les trois dernières lignes, on nous offre la possibilité d’avoir notre propre fichier dédié aux alias — ~/.bash_aliases — et de le faire sourcer par .bashrc à chaque démarrage du système. Nous allons choisir cette option et éditer ce fichier :

###########
# .bash_aliases:
# a file to be populated by the user's personal aliases (and sourced by ~/.bashrc).
###########
alias git_info='which git;git --version'
alias greet='echo Hello world!'
alias ll='ls -al'
alias where?='echo $PWD'

Créer des fonctions

A la différence des alias, les fonctions sont plus programmatiques et plus flexibles, en particulier lorsqu’il s’agit d’exploiter tout le potentiel des variables spéciales de Bash et des paramètres positionnels. Elles sont également idéales pour travailler avec des structures de contrôle de flux telles que les boucles ou les tests conditionnels. Nous pouvons considérer une fonction comme une commande qui inclut de la logique à travers des blocs ou un ensemble d’autres commandes.

Deux syntaxes pour créer une fonction

Il existe deux syntaxes valables pour définir une fonction.

En utilisant le mot clé function

D’une part, on peut utiliser le mot-clé fonction suivi du nom de la fonction et des commandes entre accolades :

function function_name {
command #1
command #2
command #3
.
.
.
command #n
}
En utilisant ()

D’autre part, nous pouvons omettre le mot-clé fonction et le remplacer par deux parenthèses juste après le nom de la fonction :

function_name() {
command #1
command #2
command #3
.
.
.
command #n
}

Il est courant de mettre les fonctions dans des fichiers ou des scripts. Elles peuvent également être écrites directement dans l’invite du shell, avec chaque commande sur une ligne différente — notez PS2(>) qui indique une nouvelle ligne après un retour à la ligne :

$ greet() {
> greeting="Hello world!"
> echo $greeting
> }

Quoi qu’il en soit, et quelle que soit la syntaxe choisie, si l’on décide de ne pas faire de retour à la ligne et d’écrire une fonction en une seule ligne, les commandes doivent être séparées par des points-virgules (notez également le point-virgule après la dernière commande) :

$ greet() { greeting="Hello world!"; echo $greeting; }

bash ne s’est pas manifesté lorsque nous avons appuyé sur Entrée, notre fonction est donc prête à être invoquée. Pour invoquer une fonction, nous pouvons taper son nom dans le terminal :

$ greet
Hello world!

Tout comme pour les variables et les alias, si nous voulons que les fonctions soient persistantes après un redémarrage du système, nous devons les placer dans des scripts d’initialisation du shell tels que /etc/bash.bashrc (global) ou ~/.bashrc (local).

Warning

Une fois que vous avez ajouté des alias ou des fonctions à un script de démarrage, vous devez sourcer ces fichiers avec . ou source pour que les changements prennent effet si vous voulez éviter de vous déconnecter et de vous reconnecter ou de redémarrer le système.

Variables spéciales intégrées à Bash

Le shell Bourne comporte un ensemble de variables spéciales qui s’avèrent très utiles pour les fonctions et les scripts. Elles sont spéciales parce qu’elles peuvent seulement être référencées — mais pas affectées. Voici la liste des variables spéciales les plus importantes :

$?

La référence de cette variable renvoie vers le résultat de la dernière commande exécutée. Une valeur de 0 équivaut à un succès :

$ ps aux | grep bash
user2      420  0.0  0.4  21156  5012 pts/0    Ss   17:10   0:00 -bash
user2      640  0.0  0.0  12784   936 pts/0    S+   18:04   0:00 grep bash
$ echo $?
0

Une valeur différente de 0 correspond à une erreur :

user1@debian:~$ ps aux |rep bash
-bash: rep: command not found
user1@debian:~$ echo $?
127
$$

Correspond au PID (identifiant du processus ou process ID) du shell :

$ ps aux | grep bash
user2      420  0.0  0.4  21156  5012 pts/0    Ss   17:10   0:00 -bash
user2      640  0.0  0.0  12784   936 pts/0    S+   18:04   0:00 grep bash
$ echo $$
420
$!

Correspond au PID de la dernière tâche exécutée en arrière-plan :

$ ps aux | grep bash &
[1] 663
$ user2      420  0.0  0.4  21156  5012 pts/0    Ss+  17:10   0:00 -bash
user2      663  0.0  0.0  12784   972 pts/0    S    18:08   0:00 grep bash
^C
[1]+  Done                   ps aux | grep bash
$ echo $!
663
Note

Rappelez-vous que l’esperluette (&) est utilisée pour lancer des processus en arrière-plan.
Paramètres positionnels $0 à $9

Ils renvoient les paramètres et les arguments passés à la fonction (alias ou script) — $0 correspond au nom du script ou du shell.

Nous allons créer une fonction pour faire une démonstration des paramètres positionnels — notez PS2 (>) qui indique les nouvelles lignes après un retour à la ligne :

$ special_vars() {
> echo $0
> echo $1
> echo $2
> echo $3
}

Nous allons maintenant appeler la fonction (special_vars) en lui passant trois paramètres (debian, ubuntu, zorin) :

$ special_vars debian ubuntu zorin
-bash
debian
ubuntu
zorin

Ça a marché comme prévu.

Warning

Même s’il est techniquement possible de passer des paramètres positionnels aux alias, ce n’est pas très pratique étant donné qu’avec les alias, les paramètres positionnels sont toujours passés à la fin :

$ alias great_editor='echo $1 is a great text editor'
$ great_editor emacs
is a great text editor emacs

Voici d’autres variables spéciales intégrées à Bash :

$#

Correspond au nombre d’arguments passés à la commande.

$@, $*

Correspond aux arguments passés à la commande.

$_

Correspond au dernier paramètre ou au nom du script (entre autres choses ; voir man bash pour en savoir plus !):

Les variables dans les fonctions

Bien évidemment, les variables peuvent être utilisées à l’intérieur des fonctions.

Pour le prouver, nous allons créer un nouveau fichier appelé funed avec la fonction suivante :

editors() {

editor=emacs

echo "My editor is: $editor. $editor is a fun text editor."
}

Comme vous l’avez peut-être deviné, nous devons d’abord sourcer le fichier avant de pouvoir invoquer la fonction :

$ . funed

Et maintenant, nous pouvons le tester :

$ editors
My editor is emacs. emacs is a fun text editor.

Comme vous pouvez le deviner, la variable editor doit d’abord être définie pour que la fonction editors fonctionne correctement. La portée de cette variable est locale au shell en cours et nous pouvons la référencer tout au long de la session :

$ echo $editor
emacs

Parallèlement aux variables locales, nous pouvons également utiliser des variables d’environnement dans notre fonction :

editors() {

editor=emacs

echo "The text editor of $USER is: $editor."
}

editors

Notez que cette fois-ci, nous avons décidé d’appeler la fonction depuis le fichier lui-même (editors à la dernière ligne). Ainsi, lorsque nous sourçons le fichier, la fonction est appelée d’une traite :

$ . funed
The text editor of user2 is: emacs.

Les paramètres positionnels dans les fonctions

C’est un peu le même principe pour les paramètres positionnels.

Nous pouvons les passer à des fonctions à l’intérieur du fichier ou du script (notez la dernière ligne : editors tortoise) :

editors() {

editor=emacs

echo "The text editor of $USER is: $editor."
echo "Bash is not a $1 shell."
}

editors tortoise

Nous sourçons le fichier et nous voyons qu’il fonctionne :

$ . funed
The text editor of user2 is: emacs.
Bash is not a tortoise shell.

Nous pouvons également passer des paramètres positionnels aux fonctions en ligne de commande. Pour preuve, nous supprimons la dernière ligne du fichier :

editors() {

editor=emacs

echo "The text editor of $USER is: $editor."
echo "Bash is not a $1 shell."
}

Ensuite, nous devons sourcer le fichier :

$ . funed

Et enfin, nous invoquons la fonction avec tortoise comme paramètre positionnel $1 en ligne de commande :

$ editors tortoise
The text editor of user2 is: emacs.
Bash is not a tortoise shell.

Les fonctions dans les scripts

Les fonctions figurent principalement dans les scripts Bash.

La conversion de notre fichier funed en un script (que nous appellerons funed.sh) est un vrai jeu d’enfant :

#!/bin/bash

editors() {

editor=emacs

echo "The text editor of $USER is: $editor."
echo "Bash is not a $1 shell."
}

editors tortoise

Et c’est tout ! Nous avons juste ajouté deux lignes :

  • La première ligne est le shebang et définit le programme qui est censé interpréter le script : #!/bin/bash. Vous ne serez pas étonnés d’apprendre que c’est bash lui-même.

  • La dernière ligne correspond simplement à l’invocation de la fonction.

Il ne reste plus qu’une chose à faire : rendre le script exécutable :

$ chmod +x funed.sh

Et le voilà prêt à être exécuté :

$ ./funed.sh
The text editor of user2 is: emacs.
Bash is not a tortoise shell.
Note

Vous apprendrez tout sur les scripts shell dans les leçons à venir.

Une fonction au sein d’un alias

Comme nous l’avons dit plus haut, nous pouvons définir une fonction à l’intérieur d’un alias :

$ alias great_editor='gr8_ed() { echo $1 is a great text editor; unset -f gr8_ed; }; gr8_ed'

Cet alias complexe mérite une explication. Voyons ce qu’il en est :

  • Tout d’abord, il y a la fonction en elle-même : gr8_ed() { echo $1 is a great text editor; unset -f gr8_ed; }

  • La dernière commande de la fonction — unset -f gr8_ed — désactive la fonction pour qu’elle ne subsiste pas dans la session bash actuelle après l’appel de l’alias.

  • Enfin, pour que l’invocation de l’alias réussisse, nous devons d’abord invoquer la fonction en question : gr8_ed.

Nous allons invoquer l’alias et vérifier qu’il fonctionne :

$ great_editor emacs
emacs is a great text editor

Comme le montre unset -f gr8_ed ci-dessus, la commande unset n’est pas seulement utilisée pour désactiver des variables, mais aussi des fonctions. En fait, il existe des options spécifiques :

unset -v

pour les variables

unset -f

pour les fonctions

Si la commande est invoquée sans options, unset essaiera d’abord de désactiver une variable et — si l’opération échoue — elle essaiera dans un deuxième temps de désactiver une fonction.

Une fonction imbriquée dans une fonction

Imaginons maintenant que nous voulions communiquer deux choses à l’utilisatrice user2 à chaque fois qu’elle se connecte au système :

  • Dire bonjour et chanter les louanges d’un éditeur de texte.

  • Étant donné qu’elle commence à enregistrer un nombre important de fichiers vidéo Matroska dans son dossier $HOME/Video, nous voulons également lui afficher un avertissement.

Pour ce faire, nous avons implémenté les deux fonctions suivantes dans /home/user2/.bashrc :

La première fonction (check_vids) vérifie les fichiers .mkv et affiche l’avertissement :

check_vids() {
    ls -1 ~/Video/*.mkv > /dev/null 2>&1
    if [ "$?" = "0" ];then
        echo -e "Remember, you must not keep more than 5 video files in your Video folder.\nThanks."
    else
	echo -e "You do not have any videos in the Video folder. You can keep up to 5.\nThanks."
    fi
}

La fonction check_vids fait trois choses :

  • Elle établit la liste des fichiers mkv dans ~/Video en envoyant le résultat — et toutes les erreurs éventuelles — au paradis des octets (/dev/null).

  • Elle vérifie si la commande précédente a été exécutée avec succès.

  • Elle affiche l’un ou l’autre message en fonction du résultat.

La seconde fonction est une version modifiée de notre fonction editors :

editors() {

editor=emacs

echo "Hi, $USER!"
echo "$editor is more than a text editor!"

check_vids
}

editors

Notons deux choses importantes ici :

  • La dernière commande de editors invoque check_vids de sorte que les deux fonctions s’enchaînent : La salutation, l’éloge, la vérification et l’avertissement sont exécutés successivement.

  • editors est lui-même le point d’entrée de la séquence de fonctions, il est donc invoqué dans la dernière ligne (editors).

Maintenant, nous pouvons nous connecter en tant que user2 et voir si ça fonctionne :

# su - user2
Hi, user2!
emacs is more than a text editor!
Remember, you must not keep more than 5 video files in your Video folder.
Thanks.

Exercices guidés

  1. Complétez le tableau par "Oui" ou "Non" en considérant les possibilités des alias et des fonctions :

    Caractéristique Alias ? Fonctions ?

    Les variables locales peuvent être utilisées

    Les variables d’environnement peuvent être utilisées

    Peuvent être échappés avec \

    Peuvent être récursifs

    Très efficaces en conjonction avec les paramètres positionnels

  2. Tapez la commande qui affiche la liste de tous les alias de votre système :

  3. Écrivez un alias nommé logg qui affiche tous les fichiers ogg dans ~/Music — un par ligne :

  4. Invoquez l’alias pour montrer qu’il fonctionne :

  5. Maintenant, modifiez l’alias de manière à afficher l’utilisateur de la session et un deux-points avant la liste :

  6. Invoquez-le à nouveau pour monter que cette nouvelle mouture fonctionne tout aussi bien :

  7. Affichez à nouveau la liste de tous les alias et vérifiez que l’alias logg apparaît bien dans la liste :

  8. Supprimez l’alias :

  9. Examinez les colonnes “Nom de l’alias” et “Commande(s) aliasée(s)” et définissez correctement les alias en fonction des valeurs qui leur sont attribuées :

    Nom de l’alias Commande(s) aliasée(s) Définition de l’alias

    b

    bash

    bash_info

    which bash + echo "$BASH_VERSION"

    kernel_info

    uname -r

    greet

    echo Hi, $USER!

    computer

    pc=slimbook + echo My computer is a $pc

  10. En tant que root, inscrivez une fonction appelée my_fun dans /etc/bash.bashrc. La fonction doit saluer l’utilisateur et lui afficher son PATH. Invoquez-la pour que l’utilisateur voie apparaître les deux messages à chaque fois qu’il se connecte :

  11. Connectez-vous en tant que user2 pour vérifier si ça fonctionne :

  12. Écrivez la même fonction en une seule ligne :

  13. Invoquez la fonction :

  14. Désactivez la fonction :

  15. Voici une version modifiée de la fonction special_vars :

    $ special_vars2() {
> echo $#
> echo $_
> echo $1
> echo $4
> echo $6
> echo $7
> echo $_
> echo $@
> echo $?
> }

    Et voici la commande que nous utilisons pour l’appeler :

    $ special_vars2 crying cockles and mussels alive alive oh

    Devinez les résultats :

    Référence Valeur

    echo $#

    echo $_

    echo $1

    echo $4

    echo $6

    echo $7

    echo $_

    echo $@

    echo $?

  16. En vous basant sur la fonction donnée en exemple (check_vids) dans la section “Une fonction imbriquée dans une fonction”, écrivez une fonction nommée check_music à inclure dans un script de démarrage bash qui accepte les paramètres positionnels de manière à ce que nous puissions modifier facilement :

    • le type de fichier à vérifier : ogg

    • le répertoire où les fichiers sont enregistrés : ~/Music

    • le type de fichier conservé : music

    • le nombre de fichiers enregistrés : 7

Exercices d’approfondissement

  1. Les fonctions en lecture seule (readonly) sont celles dont on ne peut pas modifier le contenu. Faites une recherche sur les fonctions en lecture seule et complétez le tableau suivant :

    Nom de la fonction Basculer en lecture seule Afficher toutes les fonctions en lecture seule

    my_fun

  2. Cherchez sur le web comment modifier PS1 et tout ce qui peut être utile pour écrire une fonction appelée fyi (à placer dans un script de démarrage) qui donne les informations suivantes à l’utilisateur :

    • le nom de l’utilisateur

    • son répertoire personnel

    • le nom d’hôte

    • le type de système d’exploitation

    • le PATH pour les exécutables

    • l’emplacement des e-mails

    • la fréquence de vérification des e-mails

    • le niveau d’imbrication du shell en cours

    • l’invite (modifiez-la de manière à ce qu’elle affiche <utilisateur>@<hôte-date>)

Résumé

Voici ce que nous avons vu dans cette leçon :

  • Les alias et les fonctions sont des fonctionnalités importantes du shell qui nous permettent d’encapsuler des blocs de code récurrents.

  • Les alias sont pratiques pour avoir une version plus courte d’une commande longue ou compliquée.

  • Les fonctions sont des procédures qui implémentent la logique et qui nous permettent d’automatiser des tâches, en particulier lorsqu’elles sont utilisées dans des scripts.

  • La syntaxe pour définir des alias et des fonctions.

  • Concaténer plusieurs commandes au moyen du point-virgule (;).

  • Le bon usage des guillemets avec les alias.

  • Comment rendre les alias et les fonctions persistants.

  • Les variables spéciales intégrées à Bash : $?, $$, $!, les paramètres positionnels ($0-$9), $#, $@, $* et $_.

  • Comment utiliser les variables et les paramètres positionnels avec les fonctions.

  • Comment utiliser les fonctions dans les scripts.

  • Comment invoquer une fonction à partir d’un alias.

  • Comment invoquer une fonction à partir d’une autre fonction.

  • Les bases pour créer un script bash.

Commandes et mots-clés utilisés dans cette leçon :

alias

Créer un alias.

unalias

Supprimer un alias.

cd

Changer de répertoire.

grep

Afficher les lignes qui correspondent à un motif.

function

Mot-clé du shell pour créer une fonction.

.

Sourcer un fichier.

source

Sourcer un fichier.

ps

Afficher un aperçu des processus en cours.

echo

Afficher une ligne de texte.

chmod

Modifier les permissions d’un fichier, pour le rendre exécutable par exemple.

unset

Réinitialiser une variable ou une fonction.

su

Changer d’utilisateur ou devenir superutilisateur.

Réponses aux exercices guidés

  1. Complétez le tableau par "Oui" ou "Non" en considérant les possibilités des alias et des fonctions :

    Caractéristique Alias ? Fonctions ?

    Les variables locales peuvent être utilisées

    Oui

    Oui

    Les variables d’environnement peuvent être utilisées

    Oui

    Oui

    Peuvent être échappés avec \

    Oui

    Non

    Peuvent être récursifs

    Oui

    Oui

    Très efficaces en conjonction avec les paramètres positionnels

    Non

    Oui

  2. Tapez la commande qui affiche la liste de tous les alias de votre système :

    alias

  3. Écrivez un alias nommé logg qui affiche tous les fichiers ogg dans ~/Music — un par ligne :

    alias logg='ls -1 ~/Music/*ogg'

  4. Invoquez l’alias pour montrer qu’il fonctionne :

    logg

  5. Maintenant, modifiez l’alias de manière à afficher l’utilisateur de la session et un deux-points avant la liste :

    alias logg='echo $USER:; ls -1 ~/Music/*ogg'

  6. Invoquez-le à nouveau pour monter que cette nouvelle mouture fonctionne tout aussi bien :

    logg

  7. Affichez à nouveau la liste de tous les alias et vérifiez que l’alias logg apparaît bien dans la liste :

    alias

  8. Supprimez l’alias :

    unalias logg

  9. Examinez les colonnes “Nom de l’alias” et “Commande(s) aliasée(s)” et définissez correctement les alias en fonction des valeurs qui leur sont attribuées :

    Nom de l’alias Commande(s) aliasée(s) Définition de l’alias

    b

    bash

    alias b=bash

    bash_info

    which bash + echo "$BASH_VERSION"

    alias bash_info='which bash; echo "$BASH_VERSION"'

    kernel_info

    uname -r

    alias kernel_info='uname -r'

    greet

    echo Hi, $USER!

    alias greet='echo Hi, $USER'

    computer

    pc=slimbook + echo My computer is a $pc

    alias computer='pc=slimbook; echo My computer is a $pc'
    Note

    Les guillemets simples peuvent être remplacés par des guillemets doubles.

  10. En tant que root, inscrivez une fonction appelée my_fun dans /etc/bash.bashrc. La fonction doit saluer l’utilisateur et lui afficher son PATH. Invoquez-la pour que l’utilisateur voie apparaître les deux messages à chaque fois qu’il se connecte :

    Option A :

    my_fun() {
echo Hello, $USER!
echo Your path is: $PATH
}
my_fun

    Option B :

    function my_fun {
echo Hello, $USER!
echo Your path is: $PATH
}
my_fun

  11. Connectez-vous en tant que user2 pour vérifier si ça fonctionne :

    su - user2

  12. Écrivez la même fonction en une seule ligne :

    Option A :

    my_fun() { echo "Hello, $USER!"; echo "Your path is: $PATH"; }

    Option B :

    function my_fun { echo "Hello, $USER!"; echo "Your path is: $PATH"; }

  13. Invoquez la fonction :

    my_fun

  14. Désactivez la fonction :

    unset -f my_fun

  15. Voici une version modifiée de la fonction special_vars :

    $ special_vars2() {
> echo $#
> echo $_
> echo $1
> echo $4
> echo $6
> echo $7
> echo $_
> echo $@
> echo $?
> }

    Et voici la commande que nous utilisons pour l’appeler :

    $ special_vars2 crying cockles and mussels alive alive oh

    Devinez les résultats :

    Référence Valeur

    echo $#

    7

    echo $_

    7

    echo $1

    crying

    echo $4

    mussels

    echo $6

    alive

    echo $7

    oh

    echo $_

    oh

    echo $@

    crying cockles and mussels alive alive oh

    echo $?

    0

  16. En vous basant sur la fonction donnée en exemple (check_vids) dans la section “Une fonction imbriquée dans une fonction”, écrivez une fonction nommée check_music à inclure dans un script de démarrage bash qui accepte les paramètres positionnels de manière à ce que nous puissions modifier facilement :

    • le type de fichier à vérifier : ogg

    • le répertoire où les fichiers sont enregistrés : ~/Music

    • le type de fichier conservé : music

    • le nombre de fichiers enregistrés : 7

      check_music() {
    ls -1 ~/$1/*.$2 > ~/.mkv.log 2>&1
    if [ "$?" = "0" ];then
        echo -e "Remember, you must not keep more than $3 $4 files in your $1 folder.\nThanks."
    else
	 echo -e "You do not have any $4 files in the $1 folder. You can keep up to $3.\nThanks."
    fi
}

check_music Music ogg 7 music

Réponses aux exercices d’approfondissement

  1. Les fonctions en lecture seule (readonly) sont celles dont on ne peut pas modifier le contenu. Faites une recherche sur les fonctions en lecture seule et complétez le tableau suivant :

    Nom de la fonction

    Basculer en lecture seule

    Afficher toutes les fonctions en lecture seule

    my_fun

    readonly -f my_fun

    readonly -f

  2. Cherchez sur le web comment modifier PS1 et tout ce qui peut être utile pour écrire une fonction appelée fyi (à placer dans un script de démarrage) qui donne les informations suivantes à l’utilisateur :

    • le nom de l’utilisateur

    • son répertoire personnel

    • le nom d’hôte

    • le type de système d’exploitation

    • le PATH pour les exécutables

    • l’emplacement des e-mails

    • la fréquence de vérification des e-mails

    • le niveau d’imbrication du shell en cours

    • l’invite (modifiez-la de manière à ce qu’elle affiche <utilisateur>@<hôte-date>)

      fyi() {
    echo -e "For your Information:\n
    Username: $USER
    Home directory: $HOME
    Host: $HOSTNAME
    Operating System: $OSTYPE
    Path for executable files: $PATH
    Your mail directory is $MAIL and is searched every $MAILCHECK seconds.
    The current level of your shell is: $SHLVL"
    PS1="\u@\h-\d "
}

fyi

Linux Professional Insitute Inc. Tous droits réservés. Visitez le site web du projet _Learning_ : https://learning.lpi.org
Ce travail est sous licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Pas de Modification 4.0 International.