Variables

Créer une variable

Une variable est une donnée nommée et stockée temporairement en mémoire.
Le type d’une variable n’est pas déclaré, on affecte simplement à une valeur et son type est interprété selon le contexte (opération arithmétique, affichage texte, etc).
Il existe deux types de variables utilisateur:
- les variables d'environnement, aussi appelée variables globales
  Sont communes à tous les processus et accessibles partout.
  Les variables PATH, HOME et HISTSIZE sont des exemples de variables d’environnement.
  Par convention, leur nom est en majuscule.
```
export NOM_VARIABLE=value

VAR1="value1"
VAR2="value2"
export VAR1 VAR2
```
  Notons que les processus enfant peuvent modifier les variables exportées, mais le changement ne se propage pas au shell parent: les variables exportées ne sont pas partagées mais seulement copiées.
- les variables locales
  Sont définies uniquement pour le shell courant, les processus enfants n’en héritent pas.
  Par convention, leur nom est en minuscule
```
nom_variable=value
```

Il y a différentes manières d’affecter la valeur d’une variable.
Dans tous les cas, ne jamais mettre d’espaces autour du égal — ils sont invalides à cet endroit

Texte

var=test	Affecte la valeur "test" à la variable var. Si la valeur contient des caractères spéciaux, comme "$", alors il faut les échapper. Si la valeur contient des espaces, alors il est nécessaire d'utiliser des quotes.
var="hello world"	Affecte la valeur "hello world" à la variable var. Les caractères spéciaux, comme "$", doivent être échappés.
var=$'1\n2'	Affecte la chaîne de caractère à la variable var en interprétant les caractères spéciaux. `var=$'1\n2' echo "$var"`
var=$"Text"	Affecte la traduction de "Text" à la variable var, selon la locale en cours. `# cd /usr/share/locale/fr/LC_MESSAGES # ls # msgunfmt apt.mo TEXTDOMAIN=apt msg=$"Write error" echo $msg # Erreur d'écriture`
var=$(cat <<HEREDOC Hello $name, Tu as $n nouveaux messages! HEREDOC )	Affecte une valeur sur plusieurs lignes à la variable var. Les caractères spéciaux, comme "$", doivent être échappés. Le délimiteur de fin doit être seul sur la ligne
var=$(cat <<'NOWDOC' Get the full ebook for only 9.99$ NOWDOC )	Affecte une valeur sur plusieurs lignes à la variable var. Les caractères spéciaux ne sont pas interprétés.
Subtitution de commande
var=`pwd`	Affecte le résultat de la commande "pwd" à la variable var. Il n'est pas possible d'imbriquer les backticks user=`whoami` echo "Salut ${user}!"
var=$(basename $(pwd))	Donne le résultat de la commande "pwd" à la commande "basename" et affectue ce résultat à la variable var. Possibilité d'imbriquer les commandes avec cette syntaxe `dir=$(basename $(pwd)) echo "Dossier: $dir"` `echo "Hello World" var=$(!!) echo $var # Hello World`
Opérations mathématiques
var=$(($var + 1))	`$(( ... ))` permet d'effectuer des opérations arithmétiques `$ var=1 $ var=$(($var + 1)) $ echo $var 2` `$ operation="$var + 1" $ echo operation 2 + 1 $ echo $((operation)) 3` Accepte une base différente de 10: `hexa=AF echo $(( 16#$hexa )) # 175` RANDOM est une variable d'environnement spéciale: elle contient un nombre aléatoire `$ echo $RANDOM 4386 $ echo $RANDOM 21621 $ echo $((RANDOM%=200)) # nombre aléatoire entre 0 et 200 155 $ echo $((1+($RANDOM%100))) # nombre aléatoire entre 1 et 100`
let var=var+1	Le mot-clé `let` permet d'assigner la valeur d'une variable avec une évaluation arithmétique. `$ var=1 $ let var++ $ echo $var 2 $ let var=var+10 $ echo $var 12` Accepte la notation octale et hexadécimale: `let "dec = 32" let "oct = 032" let "hex = 0x32" echo $dec # 32 echo $oct # 26 echo $hex # 50`
bc <<< $var/2	Bash ne supporte que les opérations mathématiques sur les entiers, `bc` permet d'utiliser des réels `$ t=23850.96 $ echo $(bc <<< $t/3600):$(bc <<< $t%3600/60) 6:37`

Variables spéciales

Chaque script a des variables spéciales, créées automatiquement par le shell:

Variable	Description
0,1,2,3,…	Paramètres utilisés pour lancer le script en cours. 0 contient le nom de la commande (telle qu’elle a été appelée, peut être un path absolu ou relatif ou même un lien symbolique), 1 et plus contiennent le reste des paramètre
#	Nombre de paramètres passés au script
@	Liste des paramètres passés au script (à partir de 1)
?	Statut de la dernière commande (code numérique). 0 si OK, différent de 0 en cas d’erreur
$	PID du shell exécutant le script

#!/bin/bash
if [ $# = 0 ]; then
  echo 'Usage: chr NUM'
  exit 1
fi
python -c "print(chr($1))"

if [ "$1" == "-h" ]; then
  display_help
  exit 0
fi

Afficher la valeur

Pour afficher la valeur d’une variable, on précède son nom par $.

$ username="bob"
$ echo $username
bob

Exemple avec variables spéciales

  $ cat exemple.sh

  # Variable d'environnement
  echo Shell: $SHELL

  # Variable locale
  mavariable=test
  echo Variable: $mavariable

  # Variables spéciales
  echo PID: $$
  echo Nombre de paramètres: $#
  echo 0: $0
  echo 1: $1
  echo 2: $2
  echo 3: $3

  for i in $@; do
    echo - $i
  done
  

  $ bash exemple.sh -H hello world !
  Shell: /bin/bash
  Variable: test
  PID: 15206
  Nombre de paramètres: 4
  0: exemple
  1: -H
  2: hello
  3: world
  - -H
  - hello
  - world
  - !
  

Suivant la manière dont on veut afficher les caractères spéciaux, on peut utiliser des variantes:


echo $var	Écrit la valeur de la variable `var`. Le dollar s'applique au mot qui le suit (un mot est une suite de lettres, chiffres ou underscore) `var=test echo $var # test`
echo "$var"	Écrit la valeur de la variable `var` en empêchant l'interprétation des caractères spéciaux par le shell. Permet d'afficher les caractères spéciaux, qui ne seraient pas visibles autrement puisqu'interceptés par le shell. `$ var=$'1\n2' $ echo $var 1 2 $ echo "$var" 1 2`
print "%q\n" "$var"	Écrit la valeur de la variable `var` en ANSI C Quoting = remplace les caractères spéciaux par les séquences de caractères qui correspondent. `$ var=$'1\n2' $ echo "$var" 1 2 printf "%q\n" "$var" $'1\n2'`
echo -e $var	Écrit la valeur de la variable `var` en remplaçant les séquences de caractère spécial par le caractère désigné `$ var='1\t2' $ echo $var 1\t2 $ echo -e $var 1 2`
echo ${var}	Écrit la valeur de la variable `var`. La syntaxe ${} permet de délimiter la variable ainsi que de lui appliquer des filtres. `$ var=test $ echo $varok $ echo $var"ok" testok $ echo $var\ok testok $ echo $var ok testok $ echo "$var"ok testok $ echo ${var}ok testok`

Lister les variables

Pour lister les variables d’environnement définies, on peut utiliser env ou printenv
```
env
printenv
printenv PATH
```
Variables d’environnement du Shell
Pour afficher toutes les variables définies (globales et locales): $ <tab> <tab>

Supprimer une variable

Pour supprimer une variable, locale ou d’environnement, utiliser unset
```
unset var
```

Interpolation de variable

Une fois une variable créée, il est possible de récupérer la valeur en lui faisant subir des modifications — qui ne seront pas enregistrées dans la variable.


${!ref}	Retourne la valeur de la variable désignée par ref `prix=ttc ht=1 ttc=1.20 echo ${!prix} # 1.20`
${#var}	Retourne le nombre de caractère de la valeur de var Ou le nombre d'éléments si var est un tableau `var=abc echo ${#var} # 3`
${!var@}	Retourne la liste des variables qui commençent par var `${!var*}` marche aussi `var1="A" var2="B" echo ${!var@} # var1 var2`

$ var1=A
$ var2=B

$ for varname in ${!var*}; do echo "${varname}: ${!varname}"; done
var: A
var: B

Isset


${var:-nok}	Retourne la valeur de var ou la chaîne "nok" si la valeur est vide ou que la variable n'existe pas. La valeur de var n'est pas affectée `var="" echo ${var:-NA} # NA echo $var # (rien)`
${var:+ok}	Retourne "ok" si var existe et a une valeur. La valeur de var n'est pas affectée `var="" echo ${var:+ok} # (rien) echo $var # (rien)`
${var:=nok}	Affecte var à "nok" si la valeur de var est vide ou que la variable n'existe pas puis affiche la valeur de var. `var="" echo ${var:=NA} # NA echo $var # NA`
${var:?nok}	Affiche "nok" dans stderr si la variable var n'existe pas ou que sa valeur est vide. La valeur de var n'est pas affectée `var="" echo ${var:?NA} # bash: var: NA (dans stderr) echo $var # (rien)`

Truncate


${var:3}	À partir de l'index 3 = Supprime les 3 premiers caractères de la variable var `var=123456789 echo ${var:3} # 456789`
${var:0:3}	À partir de l'index 0, 3 caractères = Retourne les 3 premiers caractères de la variable var `var=123456789 echo ${var:0:3} # 123 echo ${var:0:12} # 123456789`
${var:2:1}	À partir de l'index 2, 1 caractère = Retourne le 3ème caractère de la variable var `var=123456789 echo ${var:2:1} # 3`

${var:0:-3}	À partir de l'index 0, le nombre de caractères dans la chaîne - 3 = Supprime les 3 derniers caractères de la variable var `var=123456789 echo ${var:0:-3} # 123456`
${var: -3}	À partir de l'index -3 (3 à partir de la fin)= Retourne les 3 derniers caractères de la variable var ATTENTION, ne pas oublier l'espace avec le "-" (moins) pour un "à partir de" négatif `var=123456789 echo ${var: -3} # 789`
${var: -3:1}	À partir de -3, un caractère = Retourne le 3ème caractère à partir de la fin de la variable var `var=123456789 echo ${var: -3:1} # 7`
${var: -3:-1}	À partir de -3, -1 caractère = Retourne les 3 derniers caractères de la variable var, sauf le dernier. `var=123456789 echo ${var: -3:-1} # 78 echo ${var: -3:-4} # erreur`

Trim


${var%.*}	Supprime tout ce qu'il a APRÈS le DERNIER point `${variable%pattern}` = supprimer le match le PLUS COURT à partir de la FIN `var=a.b.c echo ${var%.*} # a.b`
${var%%.*}	Supprime tout ce qu'il a APRÈS le PREMIER point `${variable%pattern}` = supprimer le match le PLUS LONG à partir de la FIN `var=a.b.c echo ${var%%.*} # a`

${var#*.}	Supprime tout ce qu'il y a AVANT le PREMIER point `${variable#pattern}` = supprimer le match le PLUS COURT à partir du DÉBUT `var=a.b.c echo ${var#*.} # b.c`
${var##*.}	Supprime tout ce qu'il y a AVANT le DERNIER point `${variable##pattern}` = supprimer le match le PLUS LONG à partir du DÉBUT `var=a.b.c echo ${var##*.} # c`

var="...a.b.c..."

# Supprimer les points à la fin, match le plus long
$ echo ${var%%+(.)}
...a.b.c

# Supprimer les points au début, match le plus long
$ echo ${var##+(.)}
a.b.c...

var="123name"

# Supprimer les nombres au début, match le plus court
$ echo ${var#+([[:digit:]])}
23name

# Supprimer les nombres au début, match le plus long
$ echo ${var##+([[:digit:]])}
name

# Supprimer les lettres à la fin, match le plus court
$ echo ${var%+([[:alpha:]])}
123nam

# Supprimer les lettres à la fin, match le plus long
$ echo ${var%%+([[:alpha:]])}
123

Replace


${var/ /.}	Remplace le PREMIER espace par un point `${parameter/pattern/string}` où `pattern` est un wildcard (plus long match) Si `string` est vide (revient à supprimer ce qui mache pattern), le deuxième slash n'est pas nécessaire. `var="a b c d " echo ${var/ /.} # a.b c d`
${var// /.}	Remplace TOUS les espaces par un point `var="a b c d " echo ${var// /.} # a.b.c.d.` `for i in ${PATH//:/ }; do echo $i; done # Affiche les chemins ligne par ligne`
${var/# /.}	Remplace l'espace situé au DÉBUT de la chaîne par un point `var="a b c d " echo ${var/# /.} "a b c d " var=" a b c d " echo ${var/# /.} ".a b c d "`
${var/% /.}	Remplace l'espace situé à la FIN de la chaîne par un point `var="a b c d " echo ${var/% /.} "a b c d." var="a b c d" echo ${var/% /.} "a b c d"`

var="12name34"

# Remplacer la 1ère lettre par -
$ echo ${var/[[:alpha:]]/-}
12-ame34

# Remplacer toutes les lettres par -
$ echo ${var//[[:alpha:]]/-}
12----34

# Remplacer tous les chiffres par rien
$ echo ${var//[[:digit:]]/}
name

# Remplacer tous les chiffres situés au début par -
$ echo ${var/#+([[:digit:]])/-}
-name34

# Remplacer tous les chiffres situés à la fin par -
$ echo ${var/%+([[:digit:]])/-}
12name-

Case modification


${var^}	Met le PREMIER caractère en MAJUSCULE `var=abc echo ${var^} # Abc`
${var^^}	Met TOUS les caractères en MAJUSCULE `var=abc echo ${var^^} # ABC`

${var,}	Met le PREMIER caractère en MINUSCULE `var=ABC echo ${var,} # aBC`
${var,,}	Met TOUS les caractères en MINUSCULE `var=ABC echo ${var,n} # abc`

This site is open source. Improve this page.