Guide avancé d'écriture des scripts Bash:
Précédent		Suivant

Chapitre 5. Guillemets

Encadrer une chaîne de caractères avec des guillemets a pour effet de protéger les caractères spéciaux et d'empêcher leur réinterprétation ou expansion par le shell ou par un script shell. Un caractère est << spécial >> si son interprétation a une autre signification que la chaîne elle-même, comme par exemple le caractère joker *.

bash$ ls -l [Vv]* -rw-rw-r-- 1 bozo bozo 324 Apr 2 15:05 VIEWDATA.BAT -rw-rw-r-- 1 bozo bozo 507 May 4 14:25 vartrace.sh -rw-rw-r-- 1 bozo bozo 539 Apr 14 17:11 viewdata.sh bash$ ls -l '[Vv]*' ls: [Vv]*: No such file or directory

Certains programmes et utilitaires peuvent toujours réinterpréter ou étendre les caractères spéciaux placés dans une chaîne de caractères entre guillemets. Les guillemets permettent donc en particulier de protéger du shell les paramètres dans une ligne de commande, tout en laissant au programme appelé la possibilité de les étendre et réinterpréter.

bash$ grep '[Pp]remière' *.txt fichier1.txt:C'est la première ligne de fichier1.txt. fichier2.txt:C'est la Première ligne de fichier2.txt.

Notez que la version sans guillemets grep [Ff]irst *.txt fonctionne avec le shell Bash, mais pas sous tcsh.

Il est généralement conseillé de placer une chaîne de caractères entre guillemets doubles (" ") lorsqu'elle doit contenir une variable. Ça préserve tous les caractères spéciaux à l'intérieur du nom de variable, sauf $, ` (guillemet inversé), et \ (échappement). Comme $ reste interprété comme un caractère spécial, cela permet de référencer une variable entre guillemets ("$variable"), c'est-à-dire de remplacer la variable par sa valeur (voir plus haut Exemple 4-1).

Vous pouvez utiliser les guillemets doubles pour éviter la séparation de mots. [1] Un argument compris entre guillemets doubles se présente comme un seul mot, même s'il contient des espaces blancs.
variable1="une variable contenant cinq mots" COMMANDE Ceci est $variable1 # Exécute COMMANDE avec 7 arguments: # "Ceci" "est" "une" "variable" "contenant" "cinq" "mots" COMMANDE "Ceci est $variable1" # Exécute COMMANDE avec 1 argument: # "Ceci est une variable contenant cinq mots" variable2="" # Vide. COMMANDE $variable2 $variable2 $variable2 # Exécute COMMANDE sans arguments. COMMANDE "$variable2" "$variable2" "$variable2" # Exécute COMMANDE avec 3 arguments vides. COMMANDE "$variable2 $variable2 $variable2" # Exécute COMMANDE avec 1 argument (2 espaces). # Merci, S.C.

Mettre les arguments d'une instruction echo entre doubles guillemets est seulement nécessaire lorsque la séparation de mots pose problème.

Exemple 5-1. Afficher des variables bizarres

#!/bin/bash
# weirdvars.sh: Affiche des variables bizarres.

var="'(]\\{}\$\""
echo $var        # '(]\{}$"
echo "$var"      # '(]\{}$"     Ne fait pas de différence.

echo

IFS='\'
echo $var        # '(] {}$"     \ convertit en espace.
echo "$var"      # '(]\{}$"

# Exemples ci-dessus donnés par S.C.

exit 0

Les guillemets simples (' ') opèrent de manière similaire aux guillemets doubles, mais ne permettent pas de référencer des variables, car la signification spéciale de $ est désactivée. A l'intérieur des guillemets simples, tous les caractères spéciaux autres que ' sont interprétés littéralement. Vous pouvez considérer que les guillemets simples (<< citation totale >>) sont une façon plus stricte de placer entre guillemets que les guillemets doubles (<< citation partielle >>).

Comme même le caractère d'échappement (\) obtient une interprétation littérale avec les guillemets simples, essayer d'entourer un guillemet simple avec des guillemets simples ne produira pas le résultat attendu.
echo "Pourquoi ne puis-je pas écrire le caractère ' avec des guillemets simples" echo echo 'Pourquoi ne puis-je pas écrire le caractère '\'' avec des guillemets simples' # |--------------------------------------------| |----------------------------| # Une chaîne avec des guillemets simples, et contenant des simples guillemets. # Exemple de Stéphane Chazelas.

Échapper est une méthode pour mettre entre guillemets un caractère seul. L'échappement (\) précédant un caractère dit au shell d'interpréter le caractère littéralement.

Avec certaines commandes et utilitaires, tels que echo et sed, échapper un caractère peut avoir l'effet inverse - cela peut activer un comportement particulier pour ce caractère.

Significations spéciales des caractères échappés

utilisé avec echo et sed

\n

passe à la ligne

\r

renvoie le curseur en début de ligne

\t

tabulation

\v

tabulation verticale

\b

retour en arrière

\a

<< alerte >> (sonore ou visuelle)

\0xx

le caractère dont le code ASCII en octal est 0xx

Exemple 5-2. Caractères d'échappement

#!/bin/bash
# escaped.sh: caractères d'échappement

echo; echo

echo "\v\v\v\v"      # Affiche \v\v\v\v litérallement.
# Utilisez l'option -e avec 'echo' pour afficher les caractèrs d'échappement.
echo "======================"
echo "TABULATIONS VERTICALES"
echo -e "\v\v\v\v"   # Affiche 4 tabulations verticales.
echo "======================="

echo "GUILLEMET DOUBLE"
echo -e "\042"       # Affiche " (guillaume, caractère octal ASCII 42).
echo "======================="

# La construction $'\X' rend l'option -e inutile.
echo; echo "RETOUR CHARIOT ET SON"
echo $'\n'           # Retour chariot.
echo $'\a'           # Alerte (son).

echo "======================="
echo "GUILLEMETS"
#  La version 2 et ultérieures de Bash permettent l'utilisation de la
#+ construction $'\nnn'.
# Notez que dans ce cas, '\nnn' est une valeur octale.
echo $'\t \042 \t'   # Guillemet (") entouré par des tabulations.

#  Cela fonctionne aussi avec des valeurs hexadécimales, dans une construction
#+ du type $'\xhhh'.
echo $'\t \x22 \t'  # Guillemet (") entouré par des tabulations.
# Merci, Greg Keraunen, pour nous l'avoir indiqué.
# Les versions précédentes de Bash permettent '\x022'.
echo "======================="
echo


# Affecter des caraactères ASCII à une variable.
# ----------------------------------------------
guillemet=$'\042'        # " affecté à une variable.
echo "$guillemet Ceci est un chaîne de caractères mise entre guillemets, $guillemet et ceci reste en dehors des guillemets."

echo

# Concaténer des caractères ASCII dans une variable.
trois_soulignes=$'\137\137\137'  # 137 est le code octal ASCII pour '_'.
echo "$trois_soulignes SOULIGNE $trois_soulignes"

echo

ABC=$'\101\102\103\010'  # 101, 102, 103 sont les codes octals de A, B, C.
echo $ABC

echo; echo

echappe=$'\033'                    # 033 est le code octal pour l'échappement.
echo "\"echappe\" s'affiche comme $echappe"
#                                   pas de sortie visible.

echo; echo

exit 0

Voir Exemple 35-1 pour d'autres exemples d'extensions de chaînes de caractères avec la structure $' '.

\"

donne au guillemet sa signification littérale

echo "Bonjour" # Bonjour echo "\"Bonjour\", a-t-il dit." # "Bonjour", a-t-il dit.

\$

donne au dollar sa signification littérale (un nom de variable suivant un \$ ne sera pas référencé)

echo "\$variable01" # donne $variable01

\\

donne à l'anti-slash sa signification littérale

echo "\\" # donne \

Le comportement de \ est dicté par son "auto-échappement", sa mise entre guillemets ou son apparition dans une substitution de commandes ou dans un document en ligne.
# Simple échappement et mise entre guillemets echo \z # z echo \\z # \z echo '\z' # \z echo '\\z' # \\z echo "\z" # \z echo "\\z" # \z # Substitution de commandes echo `echo \z` # z echo `echo \\z` # z echo `echo \\\z` # \z echo `echo \\\\z` # \z echo `echo \\\\\\z` # \z echo `echo \\\\\\\z` # \\z echo `echo "\z"` # \z echo `echo "\\z"` # \z # Document en ligne cat <<EOF \z EOF # \z cat <<EOF \\z EOF # \z # Ces exemples ont été donnés par Stéphane Chazelas.

Les élements d'une chaîne de caractères affectée à une variable peuvent être échappés, mais le caractère d'échappement seul ne peut être affecté à une variable.
variable=\ echo "$variable" # Ne fonctionne pas et donne le message d'erreur : # test.sh: : command not found # Un échappement seul ne peut être affecté correctement à une variable. # # Ce qui arrive ici est que "\" échappe le saut de ligne et #+ l'effet est variable=echo "$variable" #+ affectation invalide de variable variable=\ 23skidoo echo "$variable" # 23skidoo # Ça fonctionne car la deuxième ligne est une affectation #+ valide de variable. variable=\ # \^ échappement suivi d'un espace echo "$variable" # espace variable=\\ echo "$variable" # \ variable=\\\ echo "$variable" # Ne fonctionnera pas et donne le message d'erreur : # test.sh: \: command not found # # La première séquence d'échappement échappe la deuxième, mais la troisième est laissée #+ seule avec le même résultat que dans le premier exemple ci-dessus. variable=\\\\ echo "$variable" # \\ # Deuxième et quatrième séquences d'échappement # Ça marche.

Échapper un espace peut empêcher la séparation de mots dans une liste d'arguments pour une commande.
liste_fichiers="/bin/cat /bin/gzip /bin/more /usr/bin/less /usr/bin/emacs-20.7" # Liste de fichiers comme argument(s) d'une commande. # On demande de et tout lister, avec deux fichiers en plus. ls -l /usr/X11R6/bin/xsetroot /sbin/dump $file_list echo "-------------------------------------------------------------------------" # Qu'arrive-t'il si nous échappons un ensemble d'espaces ? ls -l /usr/X11R6/bin/xsetroot\ /sbin/dump\ $file_list # Erreur: les trois premiers fichiers sont concaténés en un seul argument pour 'ls -l' # parce que les deux espaces échappés empêchent la séparation des arguments (mots).

L'échappement permet également d'écrire une commande sur plusieurs lignes. Normalement, chaque ligne séparée constitue une commande différente, mais un échappement à la fin d'une ligne échappe le caractère de saut de ligne, et la séquence de la commande continue sur la ligne suivante.

(cd /source/repertoire && tar cf - . ) | \ (cd /dest/repertoire && tar xpvf -) # Répétant la commande de copie de répertoires d'Alan Cox, mais séparée en deux lignes # pour accroître la lisibilité. # Comme alternative : tar cf - -C /source/directory . | tar xpvf - -C /dest/directory # Voir note ci-dessous. # (Merci, Stéphane Chazelas.)

Si la ligne d'un script termine avec un |, un caractère tube, alors il n'est pas absolument nécessaire de mettre un échappement \. Il est néanmoins considéré comme une bonne pratique de programmation de toujours échapper une ligne de code qui continue sur la ligne suivante.

echo "foo bar" #foo #bar echo echo 'foo bar' # Pas encore de différences. #foo #bar echo echo foo\ bar # Saut de ligne échappé. #foobar echo echo "foo\ bar" # Pareil ici, car \ toujours interpreté comme un échappement à l'intérieur de #+ guillemets faibles. #foobar echo echo 'foo\ bar' # Le caractère d'échappement \ est pris littéralement à cause des guillemets forts. #foor\ #bar # Exemples suggérés par Stéphane Chazelas.

Notes

Paramètres de position

$0, $1, $2, etc.

paramètres de positions, passés à partir de la ligne de commande à un script, passés à une fonction, ou initialisés (set) à une variable (voir Exemple 4-5 et Exemple 11-13)

$#

nombre d'arguments sur la ligne de commande [2] ou de paramètres de position (voir Exemple 34-2)

$*

Tous les paramètres de position, vus comme un seul mot

$@

Identique à $*, mais chaque paramètre est une chaîne entre guillemets, c'est-à-dire que les paramètres sont passés de manière intacte, sans interprétation ou expansion. Ceci signifie, entre autres choses, que chaque paramètre dans la liste d'arguments est vu comme un mot séparé.

Exemple 9-6. arglist: Affichage des arguments avec $* et $@

#!/bin/bash
# Appelez ce script avec plusieurs arguments, tels que "un deux trois".

E_BADARGS=65

if [ ! -n "$1" ]
then
  echo "Usage: `basename $0` argument1 argument2 etc."
  exit $E_BADARGS
fi  

echo

index=1

echo "Liste des arguments avec \"\$*\":"
for arg in "$*"  # Ne fonctionne pas correctement si "$*" n'est pas entre guillemets.
do
  echo "Arg #$index = $arg"
  let "index+=1"
done             # $* voit tous les arguments comme un mot entier. 
echo "Liste entière des arguments vue comme un seul mot."

echo

index=1

echo "Liste des arguments avec \"\$@\":"
for arg in "$@"
do
  echo "Arg #$index = $arg"
  let "index+=1"
done             # $@ voit les arguments comme des mots séparés. 
echo "Liste des arguments vue comme des mots séparés."

echo

exit 0

Suite à un shift, $@ contient le reste des paramètres de la ligne de commande, sans le précédent $1, qui a été perdu.
#!/bin/bash # Appelé avec ./script 1 2 3 4 5 echo "$@" # 1 2 3 4 5 shift echo "$@" # 2 3 4 5 shift echo "$@" # 3 4 5 # Chaque "shift" perd le paramètre $1. # "$@" contient alors le reste des paramètres.

Le paramètre spécial $@ trouve son utilité comme outil pour filtrer l'entrée des scripts shell. La construction cat "$@" accepte l'entrée dans un script soit à partir de stdin soit à partir de fichiers donnés en paramètre du script. Voir Exemple 12-17 et Exemple 12-18.

Les paramètres $* et $@ affichent quelque fois un comportement inconsistent et bizarre, suivant la configuration de $IFS.

Exemple 9-7. Comportement de $* et $@ inconsistent

#!/bin/bash

#  Comportement non prédictible des variables internes Bash "$*" et "$@",
#+ suivant qu'elles soient ou non entre guillemets.
#  Gestion inconsistente de la séparation de mots et des retours chariot.


set -- "Premier un" "second" "troisième:un" "" "Cinquième: :un"
# Initialise les arguments du script, $1, $2, etc.

echo

echo 'IFS inchangée, utilisant "$*"'
c=0
for i in "$*"               # entre guillemets
do echo "$((c+=1)): [$i]"   # Cette ligne reste identique à chaque instance.
                            # Arguments de echo.
done
echo ---

echo 'IFS inchangée, utilisant $*'
c=0
for i in $*                 # entre guillemets
do echo "$((c+=1)): [$i]"
done
echo ---

echo 'IFS inchangée, utilisant "$@"'
c=0
for i in "$@"
do echo "$((c+=1)): [$i]"
done
echo ---

echo 'IFS inchangée, utilisant $@'
c=0
for i in $@
do echo "$((c+=1)): [$i]"
done
echo ---

IFS=:
echo 'IFS=":", utilisant "$*"'
c=0
for i in "$*"
do echo "$((c+=1)): [$i]"
done
echo ---

echo 'IFS=":", utilisant $*'
c=0
for i in $*
do echo "$((c+=1)): [$i]"
done
echo ---

var=$*
echo 'IFS=":", utilisant "$var" (var=$*)'
c=0
for i in "$var"
do echo "$((c+=1)): [$i]"
done
echo ---

echo 'IFS=":", utilisant $var (var=$*)'
c=0
for i in $var
do echo "$((c+=1)): [$i]"
done
echo ---

var="$*"
echo 'IFS=":", utilisant $var (var="$*")'
c=0
for i in $var
do echo "$((c+=1)): [$i]"
done
echo ---

echo 'IFS=":", utilisant "$var" (var="$*")'
c=0
for i in "$var"
do echo "$((c+=1)): [$i]"
done
echo ---

echo 'IFS=":", utilisant "$@"'
c=0
for i in "$@"
do echo "$((c+=1)): [$i]"
done
echo ---

echo 'IFS=":", utilisant $@'
c=0
for i in $@
do echo "$((c+=1)): [$i]"
done
echo ---

var=$@
echo 'IFS=":", utilisant $var (var=$@)'
c=0
for i in $var
do echo "$((c+=1)): [$i]"
done
echo ---

echo 'IFS=":", utilisant "$var" (var=$@)'
c=0
for i in "$var"
do echo "$((c+=1)): [$i]"
done
echo ---

var="$@"
echo 'IFS=":", utilisant "$var" (var="$@")'
c=0
for i in "$var"
do echo "$((c+=1)): [$i]"
done
echo ---

echo 'IFS=":", utilisant $var (var="$@")'
c=0
for i in $var
do echo "$((c+=1)): [$i]"
done

echo

# Essayez ce script avec ksh ou zsh -y.

exit 0

# Ce script exemple par Stephane Chazelas,
# et légèrement modifié par l'auteur de ce document.

Les paramètres $@ et $* diffèrent seulement lorsqu'ils sont entre des guillemets doubles.

Exemple 9-8. $* et $@ lorsque $IFS est vide

#!/bin/bash

# Si $IFS est initialisé, mais vide,
# alors "$*" et "$@" n'affiche pas les paramètres de position comme on pourrait
# s'y attendre.

mecho ()       # Affiche les paramètres de position.
{
echo "$1,$2,$3";
}


IFS=""         # Initialisé, mais vide.
set a b c      # Paramètres de position.

mecho "$*"     # abc,,
mecho $*       # a,b,c

mecho $@       # a,b,c
mecho "$@"     # a,b,c

# Le comportement de $* et $@ quand $IFS est vide dépend de la version de
# Bash ou sh.
# Personne ne peux donc conseiller d'utiliser cette "fonctionnalité" dans un
# script.


# Merci, S.C.

exit 0

Notes

Un exec sert aussi à réaffecter les descripteurs de fichiers.exec <fichier-zzz remplace stdin par le fichier fichier-zzz (voir Exemple 16-1).

Précédent	Sommaire	Suivant
Types spéciaux de variables	Niveau supérieur	Sortie et code de sortie (ou d'état)

Précédent	Sommaire	Suivant
Manipuler les chaînes de caractères	Niveau supérieur	Typer des variables: declare ou typeset

Précédent	Sommaire	Suivant
Les variables revisitées	Niveau supérieur	Manipuler les chaînes de caractères

Précédent	Sommaire	Suivant
Tests et branchements	Niveau supérieur	Commandes de contrôle des jobs

[1]	Le pid du script en cours est `$$`, bien sûr.
[2]	Les mots << argument >> et << paramètre >> sont souvent utilisés sans distinction. Dans le contexte de ce document, ils ont exactement la même signification, celle d'une variable passée à un script ou à une fonction.

[1]	Une exception à ceci est la commande time, listée dans la documentation Bash officielle en tant que mot clé.
[2]	Une option est un argument agissant comme un indicateur, changeant les comportements du script de façon binaire. L'argument associé avec une option particulière indique le comportement que l'option active ou désactive.