Part 3. Après les bases

Longueur de variables / Suppression d'un sous-ensemble d'une suite de caractères

${#var}

Longueur de la suite de caractères (ou nombre de caractères dans $var). Pour un tableau, ${#tableau} est la longueur du premier élément dans le tableau.

Exceptions: ${#*} et ${#@} donnent le nombre de paramètres de position. Pour un tableau, ${#tableau[*]} et ${#tableau[@]} donnent le nombre d'éléments dans le tableau.

Exemple 9-15. Longueur d'une variable

#!/bin/bash # length.sh E_SANS_ARGS=65 if [ $# -eq 0 ] # Doit avoir des arguments en ligne de commande. then echo "Appeler ce script avec un ou plusieurs argument(s) en ligne de commande." exit $E_SANS_ARGS fi var01=abcdEFGH28ij echo "var01 = ${var01}" echo "Longueur de var01 = ${#var01}" echo "Nombre d'arguments en ligne de commande passés au script = ${#@}" echo "Nombre d'arguments en ligne de commande passés au script = ${#*}" exit 0

${var#Modele}, ${var##Modele}

Supprimez à partir de $var la plus courte/longue partie de $Modele qui correspond au début de $var.

Un exemple d'usage à partir de Exemple A-8:

# Fonction provenant de l'exemple "days-between.sh" # Supprimer les zéros du début à partir de l'argument donné. supprimer_les_zeros_du_debut () # Il est mieux de supprimer les zéros éventuels { # en début du jour et/ou du mois val=${1#0} # car sinon Bash les interprétera comme une valeur octale return $val # (POSIX.2, sect 2.9.2.1). }

Un autre exemple d'usage:

echo `basename $PWD` # Base du nom du répertoire courant. echo "${PWD##*/}" # Base du nom du répertoire actuel. echo echo `basename $0` # Nom du script. echo $0 # Nom du script. echo "${0##*/}" # Nom du script. echo filename=test.data echo "${filename##*.}" # données # Extension du fichier.

${var%Modele}, ${var%%Modele}

Supprimez à partir de $var la partie la plus courte/longue de $Modele qui correspond à la fin de $var.

Expansion de variables / Remplacement de sous-chaînes

Ces constructions proviennent de ksh.

${var:pos}

La variable var étendue, commençant à la position pos.

${var:pos:len}

Augmentation d'un maximum de len caractères de la variable var, à partir de la position pos. Voir Exemple A-15 pour un exemple d'utilisation particulièrement intéressante de cet opérateur.

${var/Modele/Remplacement}

Première occurrence de Modele, à l'intérieur de var remplacé par Remplacement.

Si Remplacement est omis, alors la première occurrence de Modele n'est remplacé par rien, c'est-à-dire qu'il est supprimé.

${var//Modele/Remplacement}

Remplacement global. Toutes les occurrences de Modele, à l'intérieur de var remplacées par Remplacement.

Comme ci-dessus, si Remplacement est omis, alors toutes les occurrences de Modele ne sont remplacées par rien, c'est-à-dire supprimées.

Exemple 9-18. Utiliser la recherche de modèles pour analyser des chaînes de caractères diverses

#!/bin/bash var1=abcd-1234-defg echo "var1 = $var1" t=${var1#*-*} echo "var1 (avec tout, jusqu'au et incluant le premier - supprimé) = $t" # t=${var1#*-} fonctionne de la même façon, #+ car # correspond à la plus petite chaîne de caractères, #+ et * correspond à tout ce qui précède, incluant la chaîne vide. # (Merci, S. C. pour l'avoir indiqué.) t=${var1##*-*} echo "Si var1 contient un \"-\", renvoie un chaîne vide... var1 = $t" t=${var1%*-*} echo "var1 (avec tout à partir de la fin - supprimée) = $t" echo # ------------------------------------------- nom_chemin=/home/bozo/idees/pensees.pour.aujourdhui # ------------------------------------------- echo "nom_chemin = $nom_chemin" t=${nom_chemin##/*/} echo "nom_chemin, sans les préfixes = $t" # Même effet que t=`basename $nom_chemin` dans ce cas particulier. # t=${nom_chemin%/}; t=${t##*/} est une solution lpus générale, #+ mais elle échoue quelques fois. # Si $nom_chemin finit avec un retour chariot, alors `basename $nom_chemin` #+ ne fonctionnera pas mais l'expression ci-dessus le fera. # (Merci, S.C.) t=${nom_chemin%/*.*} # Même effet que t=`dirname $nom_chemin` echo "nom_chemin, sans les suffixes = $t" # Ceci va échouer dans certains cas, comme "../", "/foo////", # "foo/", "/". # Supprimer les suffixes, spécialement quand le nom de base n'en a pas, mais #+ que le nom du répertoire en a un, complique aussi le problème. # (Merci, S.C.) echo t=${nom_chemin:11} echo "$nom_chemin, avec les 11 premiers caractères supprimés = $t" t=${nom_chemin:11:5} echo "$nom_chemin, avec les 11 premiers caractères supprimés, longueur 5 = $t" echo t=${nom_chemin/bozo/clown} echo "$nom_chemin avec \"bozo\" remplacé par \"clown\" = $t" t=${nom_chemin/today/} echo "$nom_chemin avec \"today\" supprimé = $t" t=${nom_chemin//o/O} echo "$nom_chemin avec tous les o en majuscule = $t" t=${nom_chemin//o/} echo "$nom_chemin avec tous les o supprimés = $t" exit 0

${var/#Modele/Remplacement}

Si le préfixe de var correspond à Modele, alors Remplacement remplace Modele.

${var/%Modele/Remplacement}

Si le suffixe de var correspond à Modele, alors Remplacement remplace Modele.

Exemple 9-19. Modèles correspondant au préfixe ou au suffixe d'une chaîne de caractères

#!/bin/bash # Remplacement de modèle sur le préfixe / suffixe d'une chaîne de caractères. v0=abc1234zip1234abc # Variable original. echo "v0 = $v0" # abc1234zip1234abc echo # Correspond au préfixe (début) d'une chaîne de caractères. v1=${v0/#abc/ABCDEF} # abc1234zip1234abc # |-| echo "v1 = $v1" # ABCDE1234zip1234abc # |---| # Correspond au suffixe (fin) d'une chaîne de caractères. v2=${v0/%abc/ABCDEF} # abc1234zip123abc # |-| echo "v2 = $v2" # abc1234zip1234ABCDEF # |----| echo # ---------------------------------------------------- # Doit correspondre au début / fin d'une chaîne de caractères. #+ sinon aucun remplacement ne se fera. # ---------------------------------------------------- v3=${v0/#123/000} # Correspond, mais pas au début. echo "v3 = $v3" # abc1234zip1234abc # PAS DE REMPLACEMENT. v4=${v0/%123/000} # Correspond, mais pas à la fin. echo "v4 = $v4" # abc1234zip1234abc # PAS DE REMPLACEMENT. exit 0

${!varprefixe*}, ${!varprefixe@}

Correspond à toutes les variables déjà déclarées commençant par varprefixe.

xyz23=quoiquecesoit xyz24= a=${!xyz*} # Se développe en les noms des variables précédemment déclarées # commençant par "xyz". echo "a = $a" # a = xyz23 xyz24 a=${!xyz@} # Même chose que ci-dessus. echo "a = $a" # a = xyz23 xyz24 # Bash, version 2.04, ajoute cette fonctionnalité.

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

Autres paramètres spéciaux

$-

Les options passées au script (en utilisant set). Voir Exemple 11-13.

Ceci était originellement une construction de ksh adoptée dans Bash, et malheureusement elle ne semble pas fonctionner de façon fiable dans les scripts Bash. Une utilité possible pour ceci est d'avoir un script testant lui-même s'il est interactif.

$!

PID (identifiant du processus) du dernier job ayant fonctionné en tâche de fond

$_

Variable spéciale initialisée au dernier argument de la dernièr commande exécutée.

Exemple 9-9. variable tiret bas

#!/bin/bash echo $_ # /bin/bash # Simple appel de /bin/bash pour lancer ce script. du >/dev/null # Donc pas de sortie des commandes echo $_ # du ls -al >/dev/null # Donc pas de sortie des commandes echo $_ # -al (dernier argument) : echo $_ # :

$?

Code de sortie d'une commande, fonction, ou du script lui-même (voir Exemple 23-3)

$$

Identifiant du processus du script lui-même. La variable $$ trouve fréquemment son utilité dans les scripts pour construire des noms de fichiers temporaires << uniques >> (voir Exemple A-14, Exemple 30-6, Exemple 12-23 et Exemple 11-23). Ceci est généralement plus simple que d'appeler mktemp.

Commandes

true

Une commande qui renvoie un succès (zéro) comme état de sortie, mais ne fait rien d'autre.

# Boucle sans fin while true # alias pour ":" do operation-1 operation-2 ... operation-n # A besoin d'un moyen pour sortir de la boucle. done

false

Une commande qui renvoit un état de sortie correspondant à un échec, mais ne fait rien d'autre.

# Fausse boucle while false do # Le code suivant ne sera pas exécuté. operation-1 operation-2 ... operation-n # Rien ne se passe! done

type [cmd]

Identique à la commande externe which, type cmd donne le chemin complet vers << cmd >>. Contrairement à which, type est une commande intégrée à Bash. L'option -a est très utile pour que type identifie des mots clés et des commandes internes, et localise aussi les commandes système de nom identiques.

bash$ type '[' [ is a shell builtin bash$ type -a '[' [ is a shell builtin [ is /usr/bin/[

hash [cmds]

Enregistre le chemin des commandes spécifiées (dans une table de hachage du shell), donc le shell ou le script n'aura pas besoin de chercher le $PATH sur les appels futurs à ces commandes. Quand hash est appelé sans arguments, il liste simplement les commandes qui ont été hachées. L'option -r réinitialise la table de hachage.

help

help COMMANDE cherche un petit résumé sur l'utilisation de la commande COMMANDE intégrée au shell. C'est l'équivalent de whatis, pour les commandes intégrées.

bash$ help exit exit: exit [n] Exit the shell with a status of N. If N is omitted, the exit status is that of the last command executed.