Scripting bash

Une affectation s'écrit sans espaces autour du =. Pour lire la valeur on préfixe par $, et pour les cas ambigus (concaténation avec du texte) on entoure le nom d'accolades.

Syntaxe

nom=valeur                    # affectation simple
nom="texte avec espaces"      # toujours quoter si espaces ou caracteres speciaux
echo "$nom"                   # lecture
echo "${nom}_suffixe"         # accolades obligatoires pour deslimiter le nom

export NOM=valeur             # variable d'environnement (heritee par les enfants)
local nom=valeur              # portee limitee a la fonction
readonly nom=valeur           # interdit toute modification ulterieure

$ nom="Alice"
echo "Bonjour $nom"

Bonjour Alice

$ base=/var/log
echo "${base}_archive"

/var/log_archive

$ export PATH="$HOME/bin:$PATH"

Voir aussi : ${VAR:-def} $(cmd)

Les accolades autour d'un nom de variable acceptent des modificateurs très puissants : valeur par défaut si vide, longueur, sous-chaîne, suppression de préfixe ou suffixe, remplacement.

Valeur par défaut et obligatoire

Longueur, sous-chaîne, manipulation

$ port=${PORT:-8080}
echo "Ecoute sur $port"

Ecoute sur 8080

$ fichier=/var/log/syslog.gz
echo "${fichier##*/}"
echo "${fichier%.gz}"

syslog.gz
/var/log/syslog

$ chemin="src/main/app.js"
echo "${chemin//\//.}"

src.main.app.js

Voir aussi : $VAR grep

$(cmd) remplace la substitution par la sortie standard de la commande en retirant tous les sauts de ligne finaux. Quoter l’expansion préserve les espaces et sauts de ligne internes. Les backticks sont une ancienne syntaxe, moins pratique à imbriquer.

Syntaxe

resultat=$(commande arg1 arg2)
echo "Maintenant : $(date +%H:%M)"
fichiers=$(ls *.log)            # eviter — utiliser un tableau plutot
imbric=$(echo $(uname -r))      # parfaitement lisible

$ aujourdhui=$(date +%Y-%m-%d)
mkdir "backup-$aujourdhui"

$ nb_lignes=$(wc -l < access.log)
echo "Total : $nb_lignes lignes"

Voir aussi : $((expr)) $VAR

Calcul entier sans expr ni bc. Les variables sont utilisables sans $ à l'intérieur. Ne gère que des entiers ; pour des décimales, utiliser bc -l ou awk.

Opérateurs

$ a=7
b=3
echo "$((a + b))  $((a * b))  $((a / b))  $((a % b))"

10  21  2  1

$ i=0
while (( i < 5 )); do echo $i; i=$((i + 1)); done

Voir aussi : $(cmd) [[ ]]

[ est généralement un builtin du shell ; un exécutable externe existe aussi. Il reprend les tests de test mais exige un argument final ]. Il renvoie 0 si le test est vrai, 1 sinon et un autre statut en cas d’erreur de syntaxe. Les espaces séparant les arguments sont obligatoires.

Conditions sur les fichiers

Comparaisons de chaînes et d'entiers

$ if [ -f "$config" ]; then
    . "$config"
fi

$ [ -z "$nom" ] && nom="anonyme"

Voir aussi : [[ ]] if

Construction Bash, plus sûre que [ ] : pas de découpage de mots, pas de globbing intempestif, et opérateurs supplémentaires pour le pattern matching et les regex.

Opérateurs en plus de [ ]

$ if [[ "$nom" == *.log ]]; then echo "fichier log"; fi

$ if [[ "$ip" =~ ^([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+)$ ]]; then
    echo "premier octet : ${BASH_REMATCH[1]}"
fi

Voir aussi : [ ] if

if teste une commande (souvent [[ ]] ou [ ]) et s'exécute selon son code de retour : 0 = succès = vrai, ≠ 0 = faux. Le bloc se ferme par fi.

Syntaxe

if condition; then
    instructions
elif autre_condition; then
    instructions
else
    instructions
fi

$ if [[ -f "$fichier" ]]; then
    echo "fichier present"
elif [[ -d "$fichier" ]]; then
    echo "c'est un repertoire"
else
    echo "rien a cet endroit"
fi

$ command -v docker >/dev/null && echo "docker installe" || echo "docker absent"

Voir aussi : [[ ]] case

Itère sur les éléments d'une liste (mots séparés par espaces, fichiers issus d'un glob, lignes d'une commande, plage numérique). Bash propose aussi une forme C-like avec trois expressions.

Syntaxe

for var in liste; do
    instructions
done

for ((i=0; i<10; i++)); do      # forme C
    instructions
done

$ for f in *.log; do
    [ -f "$f" ] || continue
    gzip -- "$f"
done

$ for i in {1..5}; do echo "tentative $i"; done

$ while IFS= read -r ligne || [ -n "$ligne" ]; do
    printf 'lu : %s
' "$ligne"
done < fichier.txt

Voir aussi : while xargs

while cond; do ...; done exécute le bloc tant que cond renvoie 0. until est l'inverse : tant qu'elle renvoie ≠ 0. Couplé à read, c'est l'idiome pour lire un flux ligne par ligne.

$ i=0
while (( i < 3 )); do
    echo "$i"
    i=$((i + 1))
done

0
1
2

$ while IFS=: read -r user _ uid _ _ home _; do
    [ "$uid" -ge 1000 ] && echo "$user -> $home"
done < /etc/passwd

$ until ping -c1 -W1 host >/dev/null 2>&1; do
    sleep 2
done

Voir aussi : for $((expr))

L'équivalent de switch dans d'autres langages, en plus puissant car les branches sont des motifs glob (*, ?, [abc]) et peuvent être combinées avec |. Plus lisible qu'une cascade d'elif quand on teste la même variable.

Syntaxe

case "$var" in
    motif1)        instructions ;;
    motif2|motif3) instructions ;;
    *)             instructions_par_defaut ;;
esac

$ case "${1:-}" in
    start)   echo "demarrage" ;;
    stop)    echo "arret" ;;
    restart) echo "redemarrage" ;;
    *)       echo "Usage: $0 {start|stop|restart}" >&2; exit 1 ;;
esac

$ case "$fichier" in
    *.tar.gz|*.tgz) tar xzf "$fichier" ;;
    *.tar.bz2)      tar xjf "$fichier" ;;
    *.zip)          unzip "$fichier" ;;
    *)              echo "format inconnu" >&2; exit 1 ;;
esac

Voir aussi : if [[ ]]

La déclaration nom() { ...; } est POSIX. Le mot-clé function et la commande local sont des extensions prises en charge par Bash, pas des garanties POSIX. "$@" préserve les arguments séparés ; $# donne leur nombre. return N termine la fonction avec un statut, pas une valeur arbitraire.

Syntaxe

nom() {
    local var=valeur            # local : reste dans la fonction
    echo "premier arg : $1"
    echo "tous : $@"
    echo "nombre : $#"
    return 0                    # code de sortie (defaut : celui de la derniere instruction)
}

# Appel
nom arg1 arg2 "arg trois"

Variables positionnelles

$ log() {
    local niveau=$1; shift
    echo "[$(date +%H:%M:%S)] [$niveau] $*"
}
log INFO "demarrage"
log ERROR "echec lecture" "$fichier"

$ max() {
    (( $1 > $2 )) && echo "$1" || echo "$2"
}
max 10 7

10

Voir aussi : $VAR trap

Active errexit : provoque la sortie sur certaines erreurs non testées. Ses exceptions dépendent du contexte (conditions, listes logiques, fonctions appelées dans ces contextes, pipelines). Il ne remplace pas une gestion explicite des erreurs ; vérifier le comportement attendu avant de l’activer dans un script existant.

$ #!/usr/bin/env bash
set -e
cd /tmp/build
./configure
make
sudo make install

Voir aussi : set -u pipefail

Active nounset : référencer une variable jamais affectée provoque une erreur et termine un shell non interactif, même sans set -e. Évite les bugs liés aux fautes de frappe ou aux variables d'environnement absentes.

$ set -u
echo "$NON_DEFINIE"

bash: NON_DEFINIE: unbound variable

Voir aussi : set -e ${VAR:-def}

Par défaut, cmd1 | cmd2 retourne le code de cmd2. Si cmd1 échoue mais cmd2 réussit, le pipe passe pour un succès. Avec pipefail, le statut du pipeline est celui de la commande la plus à droite dont le code est non nul, ou zéro si toutes réussissent. Par exemple, (exit 7) | (exit 3) renvoie 3. Le tableau Bash PIPESTATUS contient les statuts individuels ; le lire immédiatement après le pipeline.

$ set -o pipefail
curl -fsS http://example.test/data | jq .users

Voir aussi : set -e set -u |

trap associe une action à un signal ou à un événement du shell. EXIT s’exécute lors de la sortie normale du shell et des erreurs qui le font sortir. Ne pas supposer qu’il couvre tous les signaux : installer aussi les gestionnaires INT, TERM et HUP nécessaires. SIGKILL et SIGSTOP ne peuvent pas être interceptés.

Syntaxe

trap 'instruction' SIGNAL [SIGNAL...]
trap -        SIGNAL    # restaurer le comportement par defaut
trap ''       SIGNAL    # ignorer le signal

$ tmp=$(mktemp -d) || exit 1
trap 'rm -rf -- "$tmp"' EXIT
trap 'exit 130' INT
trap 'exit 143' TERM
trap 'exit 129' HUP
# ... le script utilise $tmp ...

$ trap 'echo "interrompu" >&2; exit 130' INT
trap 'echo "termine" >&2; exit 143' TERM

Voir aussi : kill set -e

Suit tous les liens symboliques et renvoie le chemin absolu réel. Idiome essentiel quand un script doit connaître son propre emplacement, par exemple pour charger un fichier de config voisin.

$ readlink -f /usr/bin/sh

/usr/bin/dash

$ #!/usr/bin/env bash
SCRIPT_DIR=$(cd "$(dirname "$(readlink -f "$0")")" && pwd)
source "$SCRIPT_DIR/config.sh"

Voir aussi : ln basename / dirname

Builtin shell, toujours à utiliser avec -r (sinon les backslashes sont interprétés). Coupe sur $IFS par défaut (espaces/tabs/\n) : passer IFS= pour préserver les espaces.

Options

$ read -rp "Continuer ? [o/N] " rep
[[ "$rep" =~ ^[oOyY]$ ]] || exit 0

$ read -rsp "Mot de passe : " pass
echo
echo "Mot de passe saisi : ${#pass} caractères"

$ while IFS=: read -r user _ uid _ _ home _; do
    [ "$uid" -ge 1000 ] && echo "$user $home"
done < /etc/passwd

$ if read -rt 5 -p "Démarrer ? " rep; then
    echo "Réponse : $rep"
else
    echo "Timeout — démarrage par défaut"
fi

Voir aussi : printf getopts while

Plus prévisible et plus portable qu'echo : pas d'arguments interprétés différemment selon l'OS, contrôle exact des largeurs, des alignements et des conversions. À privilégier dès qu'on dépasse echo "$x".

Spécificateurs courants

$ printf '%-15s %s\n' "Nom :" "Alice"
printf '%-15s %s\n' "Email :" "alice@example.test"

Nom :           Alice
Email :         alice@example.test

$ printf '%(%Y-%m-%dT%H:%M:%S%z)T\n' -1

2026-05-07T14:32:11+0200

$ printf 'cd %q && ./run.sh\n' "$dossier"

$ printf '%s\n' ligne1 ligne2 ligne3

ligne1
ligne2
ligne3

Voir aussi : read echo date

Builtin POSIX (à ne pas confondre avec getopt, qui est un binaire externe et accepte les options longues). Conçu pour les flags de type -v, -h, -f FILE. Le format de la chaîne d'options est : une lettre = un flag sans argument, une lettre suivie de : = flag avec argument obligatoire.

Variables peuplées par getopts

$ #!/usr/bin/env bash
verbose=0
output=""
while getopts ":vho:" opt; do
    case "$opt" in
        v) verbose=1 ;;
        h) echo "Usage: $(basename "$0") [-v] [-h] [-o FICHIER] args..."; exit 0 ;;
        o) output="$OPTARG" ;;
        \?) echo "Option inconnue : -$OPTARG" >&2; exit 1 ;;
        :) echo "Option -$OPTARG demande un argument" >&2; exit 1 ;;
    esac
done
shift $((OPTIND-1))
echo "verbose=$verbose output=$output args restants : $*"

Voir aussi : function ($1, $@, shift) case