Expansion de la ligne de commande

Mise à jour : Debian 11.2 - Bullseye

• Ce document décrit le processus d'interprétation de la ligne de commande par le shell avant de lancer l'exécution d'une commande
  

Référence :

• http://www.tldp.org/LDP/Bash-Beginners-Guide/html/sect_03_04.html
• https://apprize.best/linux/bash/4.html
• bash_shell_brace_parameter_expansion
• https://www.gnu.org/software/bash/manual
  

1 - Principe

• L'interprétation de la ligne de commande suit les phases suivantes

• Interprétation des métacaractères "Espace, Tabulation, Fin de ligne, Échappement, Apostrophe, Guillemets", découpage en "mots" de la ligne de commande
  

• Expansion des accolages {}
  

• Expansion du tilde ~
  

• Expansion des paramètres du shell $(<variable>)
  

• Expansion arithmétique $((<expression arithmétique>))
• Substitution de commande $(commande) (de gauche à droite)
  

• Découpe en mots des résultats des expansions réalisées précédemment
  

• Expansion des noms de fichier - Caractères * ? et [
  
• Redirections d'entrée et de sortie >, >>, < et <<
• Suppression des apostrophes et guillemets
• Ces phases se déroulent les unes après les autres à l'exception des phases de Redirection > et < qui s'effectuent en parallèle avec les 7 phases précédentes
• Une fois l'expansion terminée, l'exécution de la commande est lancée
• Les métacaractères suivants ne sont pas considérés ici
  

#    Commentaire
|        Filtre
;     Séquences de commande
||     Ou conditionnel
&&   Et conditionnel
&        Exécution en arrière-plan

2 - Séparation en mots

Cette première phase consiste à déterminer, avant les expansions éventuelles, les mots constituant la commande

2.1 - Définitions

• Un mot est défini comme une chaîne de caractère qui ne comprend pas de caractère d'espacement. Les caractères d'espacement sont l'espace, la tabulations et le caractère "nouvelle ligne"

• Toutefois, des caractères d'espacement peuvent être inclus dans un mot en utilisant des caractères d'échappement (backsplash, guillemets et apostrophes) qui font perdre aux caractères d'espacement leur propriété de séparateur. Dans ce cas,
  
• les séparateurs sont inclus dans les mots
• les caractères d'échappement ne sont pas inclus dans les mots
  
• Des règles particulières permettent d'inclure des caractères d'échappement dans des mots

2.2 - Cas d'une chaîne de caractère simple

• Une chaîne de caractère qui ne comprend pas de séparateur (espaces, ou tabulations, ou nouvelles lignes) constitue un mot

• La commande ci-dessous comprend 4 mots

$ echo un deux trois

• Dans ce qui suit, on utilise un script pour afficher le résultat de la décomposition en mots effectuée par le shell. Note : On suppose que la chaîne ne contient pas de motifs expansibles, sinon l'expansion aura lieu, et sera prise en compte dans le résultat affiché
  
• Contenu du script
  

#!/usr/bin/env bash
# Affichage des mots de la ligne de commande

echo "Nombre de mots passés en argument : $#"


# Affichage des arguments
i=1
while (($i<=$#));do

        echo "Mot $i ###${!i}###"
        i=$((++i))
done

• Utilisation

$ ./mots un     deux        trois
Nombre de mots passés en argument : 3
Mot 1 ###un###
Mot 2 ###deux###
Mot 3 ###trois###

Note : Le nom du script n'est pas pris en compte dans le décompte et l'affichage des mots

2.3 - Inclusion de séparateurs dans un mot

• L'utilisation de caractères d'échappement permet d'inclure des séparateurs (espaces, tabulations, nouvelles lignes) dans un mot
• Les caractères d'échappement sont au nombre de 3 :
  
• l'antislash \ : le métacaractère qui suit l'antislash "\" perd sa signification
• le guillemet (guillemet double) " : tous les métacaractères qui suivent perdent leur signification sauf le dollar $, l'antislash \, l'apostrophe '
• l'apostrophe (guillemet simple) ' : tous les métacaractères qui suivent perdent leur signification

2.3.1 Utilisation de l'antislash

• Insérer un antislash devant chaque caractère à échapper : espace, tabulation ou nouvelle linge. Dans l'exemple ci-dessous,

• les espaces entre un et deux, deux et trois sont échappés par le backslash

• le résultat est un seul mot comprenant des espaces, mais pas les antislashs
  

$ ./mots un\ deux\ trois
Nombre de mots passés en argument : 1
Mot 1 ###un deux trois###

2.3.2 Utilisation des guillemets et des apostrophes

• Les guillemets s'utilisent par paire, et tous les séparateurs et caractères inclus entre les guillemets seront inclus constituerons un mot unique. Les guillemets ne feront pas partie du mot. Dans l'exemple ci-dessous,
  
• les espaces entre un trois sont entre guillemets et sont donc échappés; un deux et trois et les espaces inclus sont donc le mot
  
• l'espace entre trois et quatre n'est pas échappé, quatre est donc un mot séparé
  

./mots "un   deux trois" quatre
Nombre de mots passés en argument : 2
Mot 1 ###un   deux trois###
Mot 2 ###quatre###

• Les apostrophes s'utilisent également par paire et tous les séparateurs et caractères inclus entre les apostrophes constituerons un mot unique. Les apostrophes ne feront pas partie du mot.
  

$ ./mots 'un   deux trois' quatre
Nombre de mots passés en argument : 2
Mot 1 ###un   deux trois###
Mot 2 ###quatre###

2.3.3 Séparateurs en début ou fin de mot

Un mot peut commencer ou finir par un ou plusieurs séparateurs, ou ne comprendre que des séparateurs

$ ./mots " ce mot commence et finit par deux espaces  "
Nombre de mots passés en argument : 1
Mot 1 ### ce mot commence et finit par deux espaces  ###

$ ./mots "le mot qui suit comprend deux espaces" "  "
Nombre de mots passés en argument : 2
Mot 1 ###le mot qui suit comprend deux espaces###
Mot 2 ###  ###  

2.3.4 Mots vides

• Mots vides : Une paire de guillemets ou d'apostrophes comprenant 0 caractères est reconnu comme mot vide

$ ./mots "Un mot vide" "" "Entre deux mots"
Nombre de mots passés en argument : 3
Mot 1 ###Un mot vide###
Mot 2 ######
Mot 3 ###Entre deux mots###

2.4 - Inclusion de caractères d'échappement

La solution varie selon que le caractère d'échappement à inclure est dans un mot "échappé" ou non avec des apostrophes ou guillemets

2.4.1 Inclusion d'un antislash

• Dans un mot "non échappé", doubler l'antislash
  

$ echo anti\\slash
anti\slash

• Dans un mot "échappé" par des guillemets ou des apostrophes, utiliser l'antislash seul
  

$ echo "anti\slash" 'anti\slash'
anti\slash anti\slash

2.4.2 Inclusion d'une apostrophe

• Dans un mot "non échappé, utiliser l'antislash pour échapper l'apostrophe
  

$ echo l\'apostrophe
l'apostrophe

• Dans un mot échappé avec des guillemets, utiliser l'apostrophe seule

$ echo "l'apostrophe"
l'apostrophe

• Dans un mot échappé avec des apostrophes, insérer le motif '\''

$ echo 'l'\''apostrophe'
l'apostrophe

2.4.3 Insertion d'un guillemet

• Dans un mot "non échappé", utiliser l'antislash pour échapper le guillemet

$ echo un\"guillemet
un"guillemet

• Dans un mot échappé avec des guillemets, utiliser également l'antislash pour échapper le guillemet

$ echo "un\"guillemet"
un"guillemet

• Dans un mot échappé avec des apostrophes, utiliser le guillemet seul
  

$ echo 'un"guillemet'
un"guillemet

3 - Accolades {} : Énumérations

• Utilisation d'une liste, séparation par des virgules ; ,

$ echo pre-{un,deux,trois}-post
pre-un-post pre-deux-post pre-trois-post

• De premier chiffre à dernier chiffre, séparation par deux points ; ..

$ echo pre-{10..13}-post
pre-10-post pre-11-post pre-12-post pre-13-post

• De premier caractère à dernier caractère, séparation par deux points : ..

$ echo pre-{r..v}-post
pre-r-post pre-s-post pre-t-post pre-u-post pre-v-post

• Combinaisons d'énumération

$ echo {p,q,z}xxx{1..3}
pxxx1 pxxx2 pxxx3 qxxx1 qxxx2 qxxx3 zxxx1 zxxx2 zxxx3

• Exception : { n'est pas expansé après $

4 - Tilde ~ : Répertoires

~ : Répertoire de login ($HOME)

~+ : Répertoire courant ($PWD)

~- : Répertoire précédent ($OLDPWD)

$ cd ~/Téléchargement
$ cd ~/Bureau

$ echo ~               # ~ est le répertoire de login
/home/user

$ echo ~+           # ~+ est le répertoire courant
/home/user/Bureau     

$ echo ~-               # ~- est le répertoire précédent
/home/user/Téléchargement

5 - Dollard $ : Expansion de paramètre

5.1 - Expansions directe et indirecte

• $var ou ${var} : le contenu d'une variable

$ exemple='Ceci est une chaîne de caractères'

$ echo $exemple
ceci est une chaîne de caractères

• ${!var} : expansion indirecte, le contenu de la variable est expansé

$ i="HOME"

$ echo $i
HOME

$ echo ${!i}
/home/philippe

• $n ou ${n} : la valeur du paramètre spécial n (compris entre 1 et 9) (nième argument de la dernière commande set, script ou fonction)

• $# et $@ : la valeur des paramètres spéciaux # et @ : nombre de paramètres et liste des paramètres

$ set un deux trois quatre

$ echo le nombre de paramètres est $#
le nombre de paramètres est 4

$ echo le paramètre 1 est $1
le paramètre 1 est un

$ echo le paramètre 4 est $4
le paramètre 4 est quatre

$ echo les paramètres sont $@
les paramètres sont un deux trois quatre

• $$ et $? : la valeur des paramètres spéciaux $ et ? : le pid du dernier processus en avant-plan et le code de sortie de la dernière commande

$ date
dimanche 13 août 2017, 22:59:26 (UTC+0200)

$ echo le pid de la dernière commande est $$
le pid de la dernière commande est 2167

$ echo le code de sortie de la dernière commande est $?
le code de sortie de la dernière commande est 0

5.2 - Conversion

On prend pour exemple la variable

$ var=abcde1234ABCDE

• Passage minuscule vers majuscule : accent circonflexe "^"

• premier caractère devient majuscule

$ echo ${var^}
Abcde1234ABCDE

• tous les caractères deviennent majuscule

$ echo ${var^^}
ABCDE1234ABCDE

• seuls certains caractères deviennent majuscules

$ echo ${var^^[bc]}
aBCde1234ABCDE

• Passage majuscule vers minuscule : virgule ", "
  

• premier caractère devient minuscule
  

$ echo ${var,}
abcde1234ABCDE

• tous les caractères deviennent minuscules

$ echo ${var,,}
abcde1234abcde

• seuls certains caractères deviennent minuscules

$ echo ${var,,[BC]}
abcde1234AbcDE

5.3 - Suppression d'une partie du motif

• Suppression d'un motif à partir du début : dièse ""
  

• Suppression d'un motif situé au début
  

$ echo ${var#123}
4ABCD1234

• Suppression depuis le début jusqu'au premier motif (utilisation du joker *)

$ echo ${var#*23}
4ABCD1234

• Suppression depuis le début jusqu'au dernier motif

$ echo ${var##*23}
4

• Suppression d'un motif à partir de la fin : pourcentage "%"
  

• Suppression d'un motif situé en fin de valeur de paramètre

$ echo ${var%34}
1234ABCD12

• Suppression depuis la fin jusqu'à un premier motif (utlisation du joker *)

$ echo ${var%23*}1234ABCD1

• Suppression depuis la fin jusqu'à la dernière occurrence du motif

$ echo ${var%%23*}1

5.4 - Remplacement de motif

$ i=1234ABCD1234

• Remplacement 23 par --bonjour-- , première occurrence

$ echo ${var/23/--bonjour--}
1--bonjour--4ABCD1234

• Remplacement 23 par --bonjour-- , toutes les occurrences

$ echo ${var//23/--bonjour--}
1--bonjour--4ABCD1--bonjour--4

5.5 - Expansion sous-chaîne

• Supprimer les 4 premiers caractères et garder tous les autres

$ echo ${var:4}
e1234ABCDE

• Supprimer les 4 premiers caractères et garder les 3 caractères suivants

$ echo ${var:4:3}
e12

• Supprimer les 4 premiers caractères et supprimer les 3 derniers

$ echo ${var: 4: -3}e1234AB

• Conserver les 4 derniers caractères et garder tous les caractères

$ echo ${var: -4}
BCDE

• Conserver les 4 derniers caractères et garder les 3 premiers caractères

$ echo ${var: -4:3}
BCD

• Conserver les 8 derniers caractères et supprimer les 3 derniers

$ echo ${var: -8: -3}
234AB

5.6 - Conversion de codes

• Convertir les codes ascii hexa \xnn

$ echo $'\x63\x6f\x6e\x76\x65\x72\x73\x69\x6f\x6e'
conversion

• Convertir les unicodes \xnnn

$ echo $'\x269\x370'
&970

• Convertir les codes d'échappement \t (tabulation) \n (nouvelle ligne) .....

$ echo -n $'\t\n' |hexdump
00000000  09 0a         

6 - Dollard $ : Expansion arithmétique

$((calcul)) : Le calcul arithmétique est effectué

• Opérations de base : # Addition, soustraction, multiplication, division, exponentielle : + - * / **
  

$ echo $((1+2))
3

$ echo $((1+2**3))
9 

$ echo $((((1+2**3))/7))
1

# Reste de la division
echo $((10%3))
1

• Incrémentation / décrémentation de variable :

• Pré-incrémentation / pré-décrémentation : ++var --var
  

$ for i in {1,2,3}; do echo $((++i)); done
2
3
4

• Post-incrémentation - post-décrémentation : var++ var--
  

$ for i in {1,2,3}; do echo $((i++)); done
1
2
3

• Opérateur unitaire

• Changement de signe : "-"

$ var=10

$ echo $((- $var))
-10

• Conservation de signe : "+"
  

$ var=-10

$echo $(( + $var ))
-10

• Comparaison : égaux, différents, plus grand, plus grand ou égal, plus petit, plus petit ou égal : == != > >= < <=, résultat de l'opération est 1 si vrai, 0 si faux

# Comparaison var1 et var2 : 

$ echo $(( 10 == 10 ))
1                     # x est égal à y : vrai

$ echo $(( 10 != 10 ))
0                      # x est différent de y : faux

$ echo $(( 10 >= 10 ))
1                     # 10 est supérieur ou égal à 10 : vrai

$ echo $(( 10 > 10 ))
0                     # 10 est supérieur à 10 : faux

7 - Dollard $ : Substitution de commande

• $(commande) : La commande est exécutée. Exemples d'utilisation
  
• Affichage du résultat de la commande
  

$ echo "Nous sommes le $(date)"
Nous sommes le ven. 21 janv. 2022 12:27:53 CET

• Affectation du résultat de la commande à une variable
  

$ version=$(uname -r)

$ echo $version
5.15.0-0.bpo.2-amd64

8 - Découpe des mots

Références :

• https://tldp.org/LDP/Bash-Beginners-Guide/html/sect_03_04.html

• Read - Tutoriel commande linux

8.1 - Principe

• Les résultats des expansions de paramètre, des expansions arithmétiques, des substitutions de commande sont découpés en mots s'ils ne sont pas protégés par des guillemets

• Exemple : Affichage de la date
• Avec apostrophe, l'expansion n'a pas lieu

$ ./mots '$(date)'
Nombre de mots passés en argument : 1
Mot 1 ###$(date)###

• Avec guillemets, la date n'est pas découpée
  

$ ./mots "$(date)"
Nombre de mots passés en argument : 1
Mot 1 ###lun. 24 janv. 2022 17:04:31 CET###

• Sans protection, la date est découpée en 6 mots
  

$ ./mots $(date)
Nombre de mots passés en argument : 6
Mot 1 ###lun.###
Mot 2 ###24###
Mot 3 ###janv.###
Mot 4 ###2022###
Mot 5 ###17:02:14###
Mot 6 ###CET###

8.2 - Caractères séparateurs

8.2.1 Caractères par défaut

• Par défaut, les caractères séparateur de mots (IFS) sont l'espace, la tabulation et la nouvelle ligne
  

$ echo -n "$IFS" |hexdump -C
00000000  20 09 0a                                          | ..|

• Avec les valeurs par défaut de IFS, des séquences de séparateurs successifs sont lues comme a séparateur unique
  

$ var="La variable contient       plusieurs espaces"

$ ./mots $var
Nombre de mots passés en argument : 5
Mot 1 ###La###
Mot 2 ###variable###
Mot 3 ###contient###
Mot 4 ###plusieurs###
Mot 5 ###espaces###

8.2.2 Caractères personnalisés

• Il est possible de modifier les caractères standards de l'IFS, par exemple, ajout du caractère "deux points" comme séparateur

$ IFS="$IFS:"

$ echo -n "$IFS" |hexdump -C
00000000  20 09 0a 3a                                       | ..:|

• Utilisation d'un séparateur personnalisé
• Entre deux mots sans espace
  

$ var="colonne1:colonne2:colonne3"

$ ./mots $var
Nombre de mots passés en argument : 3
Mot 1 ###colonne1###
Mot 2 ###colonne2###
Mot 3 ###colonne3###

• Entre deux mots avec des espaces
  

$ var="colonne1 :   colonne2 :   colonne3"

$ ./mots $var
Nombre de mots passés en argument : 3
Mot 1 ###colonne1###
Mot 2 ###colonne2###
Mot 3 ###colonne3###

• Utilisation d'une séquence de plusieurs caractères personnalisés, création de mots vides
  

$ var="colonne1::colonne2 :: colonne3"

$ ./mots $var
Nombre de mots passés en argument : 5
Mot 1 ###colonne1###
Mot 2 ######
Mot 3 ###colonne2###
Mot 4 ######
Mot 5 ###colonne3###

9 - Caractères spéciaux (wildcards) dans les noms de fichier : *,?, [ ]

$ touch photo1 photo2 photo3 photoa photob photoc

9.1 - Remplacement de n'importe quel caractère

• * : remplace n'importe quelle chaîne de caractères

$ ls p*cphotoc

• ? : remplace n'importe quel caractère

$ ls ph?tocphotoc

9.2 - Remplacement par tout caractère d'une classe de caractère

• [[:classe:]] : remplace n'importe quel caractère dans une liste définie par une classe alphanumérique, alphabétique, numérique, minuscule, majuscule, ....

[[:alnum:]]  [[:alpha:]]     [[:digit:]]     [[:xdigit:]]

[[:lower:]] [[:upper:]]

[[:blank:]]  [[:space:]]

[[:punct:]]  [[:graph:]]     [[:print:]]

• [![:classe:]] : remplace n'importe quel caractère n'appartenant pas à un classe

[![:blank:]]

9.3 - Remplacement par tout caractère d'une liste de caractères

• [liste] : remplace n'importe quel caractère d'une liste définie par
• une énumération [xyz]

$ ls photo[1ac]
photo1  photoa  photoc

• un premier et un dernier caractère [x-z]

$ ls photo[1-3]
photo1  photo2  photo3

$ ls photo[a-c]
photoa  photob  photoc

• n'appartenant pas à une liste : [^xyz]

$ ls photo[^1ac]
photo2  photo3  photob

10 - Substitution de process

Les caractères > et < - Substitution de process : Voir Redirections & enchaînements