====== Variables shell ======


Voir une liste de variables d'environnement (shell, etc)
-------------------------------------------------------
env

Voir une variable particulière
------------------------------
exemple :
echo $SHELL

Supprimer une variable
----------------------
unset toto		(et non pas $toto !)

Conversions minuscules/majsucules
---------------------------------
$ a=azerty
$ echo $a |tr a-z A-Z
AZERTY

Substitution de variables
-------------------------
http://www.linuxplusvalue.be/mylpv.php?id=187
http://abs.traduc.org/abs-3.4-fr/string-manipulation.html

Affectation
-----------
$ TUTU="Le soleil brille"
$ echo $TUTU
Le soleil brille

Valeur par défaut à utiliser en cas de variable inexistante
-----------------------------------------------------------
NB : TITI est une variable inexistante
$echo TITI

$ echo ${TITI:-il pleut}
il pleut
$ echo ${TUTU:-il pleut}
Le soleil brille
$echo TITI

ce qui montre que la valeur de TITI est temporaire 

Affectation d'une valeur en cas de variable inexistante
-------------------------------------------------------
$ echo ${TITI:=coucou}
coucou
$ echo TITI
coucou

Message à renvoyer en cas de variable inexistante
-------------------------------------------------
$ unset TITI
$ echo ${TUTU:?Cette variable est vide}
Le soleil brille
$ echo ${TITI:?Cette variable est vide}
bash: TITI: Cette variable est vide

Message à renvoyer si la variable existe
----------------------------------------
$ echo ${TUTU:+Cette variable est initialisée}
Cette variable est initialisée
$ echo ${TITI:+Cette variable est initialisée}

Dans un bash utiliser plutôt un code, par exemple 0 pour TRUE
$ echo ${TUTU:+0}
0

Extraction d'une sous-chaîne
----------------------------
${variable:position:longueur}

$ echo $TUTU
Le soleil brille
$ echo ${TUTU:3:6}
soleil
$ echo ${TUTU:3}
soleil brille

La numérotation commence à 0
La longueur de la chaîne soleil est 6 caractères

Extraire un/des nombre(s)
-------------------------
$ a=azer ti128bb
$ echo ${a//[^0-9]}		#Supprime tout ce qui n'est pas un chiffre
128
$ b="azer ti128bb85ezaz032e"
$ echo ${a//[^0-9]}
12885032

=> Extraire plusieurs nombres :
$ echo "$b" | sed -e 's/[^0-9]/ /g'
       128  85    032
$ for n in $(echo $b | sed -e 's/[^0-9]/ /g'); do echo $n; done
128
85
032

Ou mieux :
$ echo ${b//[^0-9]/ }
128 85 032
$ for n in $(echo ${b//[^0-9]/ }); do echo $n; done
128
85
032

Nombre de caractères dans la variable :
-------------------------------------
$ echo ${#TUTU}
16
$ LEN=${#TUTU}
$ echo $LEN
16

Suppressions
-----------
$ echo ${TUTU/soleil}
Le brille

$ echo ${TUTU/le}
Le soil brille				# une seule suppression (1° occurence de "le"

$ echo ${TUTU//le}			# plusieurs suppressions ("le" supprimé partout)
Le soil bril

Suppressions à partir du _début de la chaîne_ :
TITI="Le soleil brille et le vent souffle"
$ echo ${TITI#Le}
soleil brille et le vent souffle

$ echo ${TITI#brille}
Le soleil brille et le vent souffle
=> Attention avec # et ## les suppressions commencent à partir du début de la chaîne !!

$ echo ${TITI#Le*brille}
et le vent souffle
ou plus simplement :
$ echo ${TITI#*brille}
et le vent souffle

Mais :
$ echo ${TITI#soleil*souffle}
Le soleil brille et le vent souffle		# ne marche pas

$ echo ${TITI#*il}	# Suppression entre le début de la chaîne et le _premier_ "il"
brille et le vent souffle
$ echo ${TITI##*il}	# Suppression entre le début de la chaîne et le _dernier_ "il"
le et le vent souffle

Suppressions à partir de la _fin de la chaîne_ :
$ echo ${TITI%souffle}
Le soleil brille et le vent
Mais :
$ echo ${TITI%vent}
Le soleil brille et le vent souffle
=> Attention avec % et %% les suppressions commencent à partir de la fin de la chaîne !!

$ echo ${TITI%brille*souffle}
Le soleil
$ echo ${TITI%brille*e}
Le soleil
$ echo ${TITI%brille*}
Le soleil

$ echo ${TITI%il*}
Le soleil br			# Suppression entre la fin de la chaîne et le il le plus proche de la fin
$ echo ${TITI%%il*}
Le sole				# Suppression entre la fin de la chaîne et le il le plus loin de la fin

Trouver le début et la fin d'une sous-chaîne (merci encore à Christophe Gaubert)
--------------------------------------------
$ schaine="soleil"
$ a=${TITI%%$schaine*}
$ debut=${#a}			# si on numérote à partir de 0
$ echo $debut
3
$ debut=$(( ${#a} +1 ))		# si on numérote à partir de 1
$ echo $debut

Ou bien, en une seule commande
$ debut=$(expr length ${TITI%%$schaine*})
ou
$ debut=$(( `expr length ${TITI%%$schaine*}` + 1 ))

$ fin=$(expr "$TITI" : .*$schaine)
$ echo $fin			# si on numérote à partir de 1 
9
$ (( fin -=1 ))		# Si on numérote à partir de 0
$ echo $fin
8

Autres suppressions : isoler des caractères numériques (par exemple)
--------------------------------------------------------------------
$ a="abcABC de128fg hi"
Enlever les caractères à gauche du nombre :
$ echo $a | sed -e "s/^[a-z ]*//"	# le "^" (attention : Alt GR 9 !) correspond à "début de la chaîne"
128fg hi
ou bien :
$ echo $a | sed -e 's/^[^0-9]*//'
128fg hi
Enlever les caractères à droite du nombre :
$ echo $a | sed -e 's/[^0-9]*$//'	# $ indique la fin de la chaîne
abc de128
Ne garder que le nombre :
$ echo $a | sed -e 's/[^0-9]*//g'	# g = répéter

Supprimer les répétitions
-------------------------
Espaces multiples:
$ a="aaa     bb   cc"
$ echo $a
aaa bb cc
$ echo "$a"
aaa     bb   cc
$ b=`echo $a | tr -s " "`
$ echo "$b"
aaa bb cc
$ b=`echo $a`			# Semble aussi marcher pour les espaces, à voir
$ echo "$b"
aaa bb cc

Remplacements
-------------
$ echo ${TUTU/soleil/miroir}
Le miroir brille

Voir également sed, ci-dessus

Remplacements multiples
-----------------------
$ TUTU="Le chien hurle. Le chien s'endort"
$ echo ${TUTU/chien/loup}
Le loup hurle. Le chien s'endort
$ echo ${TUTU//chien/loup}
Le loup hurle. Le loup s'endort

Noter que la valeur de TUTU n'a pas changé
$ echo $TUTU
Le chien hurle. Le chien s'endort

Suppression(s)
--------------
TUTU="dix sept, dix huit, dix neuf"
$ echo ${TUTU//dix}
sept, huit, neuf

Echo, expr et les caractères "espace" fantômes
----------------------------------------------
$ a="ab80cde"
$ b=${a%%"80c"*}
$ echo $b
ab
$ echo ${#b}
2
$ echo $(expr length $b)
2

Tout est OK, Maintenant :

$ a="ab 80cde"				# 1 caractère "espace" entre ab et 80cde
$ b=${a%%"80c"*}
$ echo -n $b | od -a
0000000   a   b				# le caractère espace a disparu !
0000002
$ echo ${#b}					# Tiens on dirait qu'il y est quand même !
$ echo $(expr length $b)
2						# Ah, ben non !
$ echo $(expr length "$b")
3						# Ouf il y est !

Autre essai :
$ a="ab  80cde"				# 2 caractères "espace" entre ab et 80cde
$ b=${a%%"80c"*}
$ echo -n $b | od -a
0000000   a   b				# les 2 caractères "espace" ont disparu !
0000002
$ echo ${#b}
4
$ echo $(expr length $b)
2
$ echo $(expr length "$b")
4

=> echo supprime les caractères espace !!!
=> avec expr penser toujours à entourer les variables de ""

Opérations (additions, soustractions, multiplications, divisions)
-----------------------------------------------------------------
$ r=1
$ echo $((r++))
1
$ echo $r
2
=> l'affichage se fait avant l'incrémentation

$ r=1
$ echo $((++r))
2
$ echo $r
2
=> l'affichage se fait après l'incrémentation

$ r=1
$ a=$((r +=1))
$ echo $a
2
$ echo $r
2

$ r=1
a=$((r + 1))
$ echo $a
2
$ echo $r
1

$ a=2
$ b=10

$ echo $(($b + $a))
12
$ echo $(($b * $a))
20
$ echo $(($b / $a))
5

b=11
$ echo $(($b / $a))
5
$ echo $(($b % $a))			# modulo (reste)
1

Affecter le résultat d'une commande à une variable
--------------------------------------------------
$ r=`ls /usr/X11R6`			# affectation
$ r=$(ls /usr/X11R6)			# idem
$ echo $r					# affichage du résultat
bin/ GNUstep/ include/ lib/ man/ share/

Affichage ligne à ligne de la variable r
----------------------------------------
$ for i in $r ; do echo $i; done		# ou bien echo "${r[@]}"
bin/
GNUstep/
include/
lib/
man/
share/

Tester si une sous-chaîne est contenue dans une chaîne de caractères
--------------------------------------------------------------------
$ a="C'est sûr, il neige aujourd'hui, il neigera demain"
$ b="neige"
$ c="soleil"
$ [[ $a == *$b* ]]
$ echo $?
0
[[ $a == *$c* ]]
$ echo $?
1

Trouver la position de la sous-chaîne dans la chaîne
----------------------------------------------------
$ echo $(expr $a : '.*est')
expr: syntax error		les "" sont indispensables !

$ echo $(expr "$a" : '.*est')				ou bien $ echo $(expr "$a" : .*est)
5
5 est la position dans la chaîne $a du t de est

Variante :
$ echo $(expr match "$a" .*est)
5

Autres possibilités :
$ n=$(expr "$a" : .*est)
$ m=`expr "$a" : .*est`
$ echo n=$n m=$m
n=5 m=5

$ echo $(expr "$a" : \.\*$b)
41
=> C'est le 2° neige qui est retourné :41 est la position du 2° e de neigera

Trouver la position du premier "neige"
$ echo $(expr index "$a" "$b")
3
marche pas : c'est le 1° e qui est trouvé !

$ b="rty 84bn"
$ echo $(expr "$b" : .*'[0-9]')
6
Mais :
$ echo $(expr $b : .*'[0-9]')
expr: syntax error

Comme b contient un espace, quand bash lit :
        $(expr $b : .*'[0-9]')
il va essayer d'exécuter :
        $(expr rty 84bn : .*'[0-9]')
Et là, erreur syntaxique : l'espace n'est pas protégé, rty et 84bn sont 
deux arguments, alors que expr n'en attend qu'un.
Pour éviter ce genre de déconvenue, toujours mettre des guillemets.

Tableaux : affectation, affichage
=================================

Affecter des variables à un tableau
-----------------------------------
$ t=(bleu blanc rouge)

$ echo $t
bleu
$ echo ${t[0]}
bleu
$ echo ${t[1]}
blanc
$ echo ${t[*]}			# ou echo ${t[@]}
bleu blanc rouge
$ echo ${#t[*]}			# Nombre d'éléments dans le tableau
3

$ t[1]=vert
$ echo ${t[@]}
bleu vert rouge

Copie de tableau
$ a=(${t[*]})
$ echo ${a[*]}
bleu blanc rouge

ou bien d'après certaines docs :
a="${t[@]}"
$ echo ${a[*]}
bleu blanc rouge blanc rouge		# !!!

Initialiser un tableau
----------------------
a=()
$ echo ${#a[*]}			# Nombre d'éléments dans le tableau
0

Balayer un tableau
------------------
for (( i=0 ; i<${#t[*]} ; i++ )) ; do echo "i=$i t=${t[i]}" ; done
i=0 t=bleu
i=1 t=blanc
i=2 t=rouge

Rajouter un élément
-------------------
$ t=( ${t[*]} vert )
$ echo ${t[*]}
bleu blanc rouge vert

$ v=violet
t=(${t[*]} $v)
$ echo ${t[*]}
bleu blanc rouge vert violet

Tableau résultat d'une commande
-------------------------------
t=(`ls /usr/X11R6`)
$ echo ${t[*]}
bin/ GNUstep/ include/ lib/ man/ share/
$ echo ${t[3]}
lib/

Nombre de variables dans un tableau de variables
------------------------------------------------
$ echo ${#t[*]}			# attentionn : echo ${#t} donne 4, soit la longueur de t[0]
6

Longueurs
---------
$ echo ${#t}	# ou echo ${#t[0]}
4		# nb de caractères dans le premier élément du tableau (/bin)

$ echo ${#t[2]}	# nb de caractères dans le 3° élément du tableau (/include)
5

Additions, soustractions
------------------------
t=(10 2 7)
$ echo `expr ${t[0]} + ${t[2]} - ${t[1]}`
15

Adressage indirect
------------------
$ médor=chien
$ chien=canidé
$ echo $médor
chien
$ echo $chien
canidé
$ echo ${!médor}
canidé