Programmation Shell avec Bash : automatise tout comme un ninja

#!/bin/bash
# Faire une sauvegarde en 5 lignes
tar -czf backup-$(date +%Y%m%d).tar.gz /home/user/data
mv backup-*.tar.gz /mnt/backups/
find /mnt/backups -mtime +30 -delete
echo "Sauvegarde terminée: $(date)"

# Trouver les 10 plus gros fichiers
find . -type f -exec du -h {} + | sort -rh | head -n 10

# Créer le fichier
touch hello.sh

# Le rendre exécutable
chmod +x hello.sh

#!/bin/bash

# Ceci est un commentaire
echo "Hello, World!"

# Façon 1 : lancer directement
./hello.sh

# Façon 2 : utiliser bash explicitement
bash hello.sh

# Façon 3 : si tu l'as mis dans le bon endroit
hello.sh

#!/bin/bash
# Ce qu'on fait: Mon script sympa
# Qui l'a écrit: Ton nom
# Quand: 2025-12-15

# Réglages du script
readonly SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
readonly LOG_FILE="/var/log/mon-script.log"

# La fonction principale
main() {
    echo "Le script démarre"
    # Ton code ici
    echo "Le script s'arrête"
}

# Lancer le script
main "$@"

# Créer une variable (pas d'espaces autour du =)
nom="Alice"
age=25
ville="Paris"

# L'utiliser (avec $)
echo "Je m'appelle $nom"
echo "J'ai $age ans"
echo "J'habite à $ville"

# Mettre plusieurs variables ensemble
message="Bonjour $nom de $ville"
echo $message

# Avec des accolades (plus sûr)
echo "Utilisateur: ${nom}"

#!/bin/bash

# Ce qu'on a demandé au script
echo "Nom du script: $0"       # Le nom du fichier
echo "Première chose: $1"      # Ce qu'on a écrit après
echo "Deuxième chose: $2"      # Deuxième truc écrit après
echo "Tout ce qu'on a écrit: $@"  # Tout ensemble
echo "Combien de trucs: $#"    # Le nombre de trucs

# Comment c'est allé
ls /existepas
echo "Ça a marché ? $?"        # 0 = oui, autre = non

# Numéro du script qui tourne
echo "Numéro du script: $$"

# Exemple avec le script
./script.sh arg1 arg2 arg3
# Ça affiche:
# Nom du script: ./script.sh
# Première chose: arg1
# Deuxième chose: arg2
# Tout ce qu'on a écrit: arg1 arg2 arg3
# Combien de trucs: 3

# Lire des variables du système
echo "Ton dossier: $HOME"
echo "Ton utilisateur: $USER"
echo "Tous les chemins: $PATH"

# Créer une variable pour ce script et ses scripts enfants
export MA_VARIABLE="valeur"

# Vérifier si une variable existe ou est vide
if [ -z "$MA_VAR" ]; then
    echo "MA_VAR n'existe pas ou est vide"
fi

# Créer une liste
fruits=("Pomme" "Banane" "Orange")

# Prendre un élément
echo ${fruits[0]}        # Pomme
echo ${fruits[1]}        # Banane

# Tous les éléments
echo ${fruits[@]}        # Pomme Banane Orange

# Combien d'éléments
echo ${#fruits[@]}       # 3

# Ajouter un élément
fruits+=("Fraise")

# Boucler sur les éléments
for fruit in "${fruits[@]}"; do
    echo "J'aime les $fruit"
done

#!/bin/bash

# Demander quelque chose
echo "Quel est ton nom ?"
read nom
echo "Salut $nom!"

# Demander avec une étiquette
read -p "Ton âge: " age
echo "Tu as $age ans"

# Demander sans afficher (pour les mots de passe)
read -sp "Mot de passe: " password
echo  # Nouvelle ligne après
echo "C'est enregistré"

# Attendre une réponse (avec limite de temps)
if read -t 5 -p "Réponds en 5 secondes: " reponse; then
    echo "Tu as dit: $reponse"
else
    echo "Trop lent!"
fi

#!/bin/bash

# Fonction pour vérifier une adresse email
valider_email() {
    local email=$1
    if [[ $email =~ ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ ]]; then
        return 0  # C'est bon
    else
        return 1  # C'est pas bon
    fi
}

# Demander jusqu'à ce que ce soit correct
while true; do
    read -p "Email: " email
    if valider_email "$email"; then
        echo "Ok! Email correct: $email"
        break
    else
        echo "Email pas bon, réessaye"
    fi
done

if [ la_condition ]; then
    # Ce qu'on fait si c'est vrai
elif [ une_autre_condition ]; then
    # Ce qu'on fait si c'est vrai
else
    # Ce qu'on fait si tout était faux
fi

age=25

if [ $age -eq 18 ]; then
    echo "Exactement 18 ans"
fi

if [ $age -ne 18 ]; then
    echo "Pas 18 ans"
fi

if [ $age -gt 18 ]; then
    echo "Plus que 18 ans"
fi

if [ $age -ge 18 ]; then
    echo "18 ans ou plus"
fi

if [ $age -lt 18 ]; then
    echo "Moins que 18 ans"
fi

if [ $age -le 18 ]; then
    echo "18 ans ou moins"
fi

nom="Alice"

if [ "$nom" = "Alice" ]; then
    echo "C'est Alice"
fi

if [ "$nom" != "Bob" ]; then
    echo "C'est pas Bob"
fi

if [ -z "$nom" ]; then
    echo "Le nom est vide"
fi

if [ -n "$nom" ]; then
    echo "Le nom a quelque chose"
fi

fichier="data.txt"

if [ -e "$fichier" ]; then
    echo "Le fichier existe"
fi

if [ -f "$fichier" ]; then
    echo "C'est un fichier normal"
fi

if [ -d "$fichier" ]; then
    echo "C'est un dossier"
fi

if [ -r "$fichier" ]; then
    echo "On peut le lire"
fi

if [ -w "$fichier" ]; then
    echo "On peut le modifier"
fi

if [ -x "$fichier" ]; then
    echo "On peut l'exécuter"
fi

if [ -s "$fichier" ]; then
    echo "Le fichier n'est pas vide"
fi

age=25
nom="Alice"

# ET (les deux doivent être vrais)
if [ $age -ge 18 ] && [ "$nom" = "Alice" ]; then
    echo "Alice est majeure"
fi

# OU (au moins un doit être vrai)
if [ $age -lt 18 ] || [ "$nom" = "Bob" ]; then
    echo "Mineur ou c'est Bob"
fi

# NON (le contraire)
if [ ! -f "fichier.txt" ]; then
    echo "Le fichier n'existe pas"
fi

# Chercher avec des motifs
nom="Alice"
if [[ $nom =~ ^A ]]; then
    echo "Commence par A"
fi

# Chercher dans des noms de fichiers
fichier="test.txt"
if [[ $fichier == *.txt ]]; then
    echo "C'est un fichier texte"
fi

# Pas besoin de guillemets
if [[ $nom = Alice ]]; then
    echo "C'est Alice"
fi

# Boucler sur une liste
for fruit in Pomme Banane Orange; do
    echo "J'aime les $fruit"
done

# Boucler sur les fichiers
for fichier in *.txt; do
    echo "Je regarde $fichier"
    # Faire quelque chose avec le fichier
done

# Boucler avec des nombres
for i in {1..10}; do
    echo "Nombre: $i"
done

# Boucler avec des nombres pairs
for i in {0..20..2}; do
    echo "Nombre pair: $i"
done

# Style informatique
for ((i=0; i<10; i++)); do
    echo "Itération $i"
done

# Boucle simple
compteur=0
while [ $compteur -lt 5 ]; do
    echo "Compteur: $compteur"
    ((compteur++))
done

# Lire un fichier ligne par ligne
while IFS= read -r ligne; do
    echo "Ligne: $ligne"
done < fichier.txt

# Boucle infinie
while true; do
    echo "Appuie sur Ctrl+C pour arrêter"
    sleep 1
done

# Inverse de while
compteur=0
until [ $compteur -ge 5 ]; do
    echo "Compteur: $compteur"
    ((compteur++))
done

# break : arrêter la boucle
for i in {1..10}; do
    if [ $i -eq 5 ]; then
        break  # Arrête tout
    fi
    echo $i
done

# continue : passer au suivant
for i in {1..10}; do
    if [ $i -eq 5 ]; then
        continue  # Saute 5
    fi
    echo $i
done

# Créer la fonction
dire_bonjour() {
    echo "Bonjour!"
}

# L'utiliser
dire_bonjour

# Avec des infos
saluer() {
    local nom=$1      # La première information
    local age=$2      # La deuxième information
    echo "Salut $nom, tu as $age ans"
}

saluer "Alice" 25

# Avec un résultat
additionner() {
    local a=$1
    local b=$2
    echo $((a + b))
}

resultat=$(additionner 5 3)
echo "5 + 3 = $resultat"

ma_fonction() {
    local variable_locale="Juste ici"
    variable_globale="Partout"

    echo $variable_locale
}

ma_fonction
# echo $variable_locale  # Erreur : n'existe pas
echo $variable_globale   # Ça marche

verifier_fichier() {
    local fichier=$1

    if [ -f "$fichier" ]; then
        return 0  # Ça a marché
    else
        return 1  # Ça a pas marché
    fi
}

if verifier_fichier "data.txt"; then
    echo "Le fichier existe"
else
    echo "Le fichier n'existe pas"
fi

texte="Bonjour"
echo ${#texte}  # 7

texte="Bonjour le monde"

# Prendre du début
echo ${texte:0:7}    # "Bonjour"
echo ${texte:8}      # "le monde"

# Enlever depuis le début
fichier="image.jpg"
echo ${fichier#*.}   # "jpg"

# Enlever depuis la fin
chemin="/home/user/data.txt"
echo ${chemin%/*}    # "/home/user"

texte="Bonjour le monde"

# Remplacer une fois
echo ${texte/le/un}      # "Bonjour un monde"

# Remplacer partout
echo ${texte//o/O}       # "BOnnjOur le mOnde"

# Supprimer
echo ${texte//le/}       # "Bonjour  monde"

texte="Bonjour"

# Mettre en MAJUSCULES
echo ${texte^^}          # "BONJOUR"

# Mettre en minuscules
echo ${texte,,}          # "bonjour"

# Lire ligne par ligne
while IFS= read -r ligne; do
    echo "Ligne: $ligne"
done < fichier.txt

# Tout le fichier d'un coup
contenu=$(cat fichier.txt)

# Avec mapfile
mapfile -t lignes < fichier.txt
for ligne in "${lignes[@]}"; do
    echo "$ligne"
done

# Remplacer tout
echo "Contenu" > fichier.txt

# Ajouter à la fin
echo "Nouvelle ligne" >> fichier.txt

# Plusieurs lignes
cat > fichier.txt << EOF
Ligne 1
Ligne 2
Ligne 3
EOF

# Erreurs dans un fichier
commande 2> erreurs.log
# Tout dans un fichier
commande > output.log 2>&1

#!/bin/bash

# Comment utiliser
utiliser() {
    echo "Usage: $0 [-n NOM] [-a AGE] [-v]"
    echo "  -n NOM    Dire le nom"
    echo "  -a AGE    Dire l'âge"
    echo "  -v        Mode bavard"
    exit 1
}

# Les valeurs par défaut
nom=""
age=""
bavard=false

# Lire les options
while getopts "n:a:vh" opt; do
    case $opt in
        n)
            nom="$OPTARG"
            ;;
        a)
            age="$OPTARG"
            ;;
        v)
            bavard=true
            ;;
        h)
            utiliser
            ;;
        \?)
            echo "Option pas bonne: -$OPTARG"
            utiliser
            ;;
    esac
done

# Vérifier
if [ -z "$nom" ]; then
    echo "Erreur: besoin d'un nom"
    utiliser
fi

# Ton script
if [ "$bavard" = true ]; then
    echo "Nom: $nom, Âge: $age"
fi

#!/bin/bash

# Arrêter avec une erreur
if [ ! -f "fichier.txt" ]; then
    echo "Erreur: fichier.txt n'existe pas" >&2
    exit 1
fi

# Tout est ok
exit 0

#!/bin/bash
set -e  # Arrête si une commande échoue

# Arrête là si ça échoue
mkdir /dossier/qui/existe/pas

# Cette ligne ne s'exécutera pas
echo "Suite du script"

#!/bin/bash
set -u  # Erreur si tu utilises une variable qui n'existe pas

echo $VARIABLE_QUI_N_EXISTE_PAS  # Erreur !

#!/bin/bash
set -o pipefail

# Si la première commande échoue, ça arrête
cat fichier_inexistant | grep "pattern"

#!/bin/bash

# Le mode super sérieux
set -euo pipefail

#!/bin/bash

# Fonction pour nettoyer
nettoyer() {
    echo "Je nettoie..."
    rm -f /tmp/tempfile
    echo "C'est fini"
}

# Exécuter le nettoyage à la fin
trap nettoyer EXIT

# Gérer Ctrl+C
trap 'echo "Tu as arrêté!"; exit 130' INT

# Créer un fichier temporaire
touch /tmp/tempfile

# Ton code...
sleep 10

# nettoyer() s'exécutera tout seul

#!/bin/bash

#############################################
# Script pour sauvegarder des fichiers
# Ce qu'il fait: Sauvegarde et nettoie les anciennes
#############################################

set -euo pipefail

# Les réglages
readonly SOURCE="/home/user/data"
readonly DESTINATION="/mnt/backups"
readonly NOM_BACKUP="backup"
readonly JOURS_GARDE=30
readonly LOG="/var/log/backup.log"

# Les couleurs
readonly ROUGE='\033[0;31m'
readonly VERT='\033[0;32m'
readonly JAUNE='\033[1;33m'
readonly NORMAL='\033[0m'

# Fonction pour écrire un message
message() {
    local type=$1
    shift
    local texte="$@"
    local heure=$(date '+%Y-%m-%d %H:%M:%S')

    echo "[$heure] [$type] $texte" | tee -a "$LOG"
}

# Fonction pour les erreurs
erreur() {
    echo -e "${ROUGE}ERREUR: $@${NORMAL}" >&2
    message "ERROR" "$@"
    exit 1
}

# Fonction pour les bonnes nouvelles
ok() {
    echo -e "${VERT}OK: $@${NORMAL}"
    message "INFO" "$@"
}

# Fonction pour les avertissements
attention() {
    echo -e "${JAUNE}ATTENTION: $@${NORMAL}"
    message "WARN" "$@"
}

# Vérifier qu'on est administrateur
check_root() {
    if [ "$EUID" -ne 0 ]; then
        erreur "Tu dois être administrateur"
    fi
}

# Vérifier tout ce qu'il faut
verifier() {
    ok "Je vérifie tout..."

    # Source existe ?
    if [ ! -d "$SOURCE" ]; then
        erreur "Le dossier $SOURCE n'existe pas"
    fi

    # Destination existe ?
    if [ ! -d "$DESTINATION" ]; then
        attention "Je crée $DESTINATION"
        mkdir -p "$DESTINATION" || erreur "Impossible de créer $DESTINATION"
    fi

    ok "Tout est bon !"
}

# Faire la sauvegarde
faire_backup() {
    local heure=$(date +%Y%m%d_%H%M%S)
    local fichier="${DESTINATION}/${NOM_BACKUP}_${heure}.tar.gz"

    ok "Je sauvegarde : $fichier"

    # Voir la taille
    local taille=$(du -sh "$SOURCE" | cut -f1)
    ok "Taille à sauvegarder: $taille"

    # Créer l'archive
    tar -czf "$fichier" \
        -C "$(dirname "$SOURCE")" \
        "$(basename "$SOURCE")" \
        2>&1 | tee -a "$LOG" || erreur "La sauvegarde a échoué"

    # Ça a marché ?
    if [ ! -f "$fichier" ]; then
        erreur "Le fichier n'a pas été créé"
    fi

    local taille_backup=$(du -sh "$fichier" | cut -f1)
    ok "Sauvegarde ok : $taille_backup"

    # Vérifier que c'est bon
    if tar -tzf "$fichier" > /dev/null 2>&1; then
        ok "La sauvegarde est correcte"
    else
        erreur "La sauvegarde est abîmée"
    fi

    echo "$fichier"
}

# Nettoyer les anciennes sauvegardes
nettoyer() {
    ok "Je nettoie les vieilles sauvegardes (plus que $JOURS_GARDE jours)..."

    local supprime=0
    while IFS= read -r backup; do
        rm -f "$backup"
        ((supprime++))
        ok "Supprimé: $(basename "$backup")"
    done < <(find "$DESTINATION" -name "${NOM_BACKUP}_*.tar.gz" -mtime +${JOURS_GARDE})

    if [ $supprime -eq 0 ]; then
        ok "Rien à supprimer"
    else
        ok "$supprime sauvegarde(s) supprimée(s)"
    fi
}

# Nettoyer en cas de problème
nettoyer_erreur() {
    if [ $? -ne 0 ]; then
        attention "Quelque chose a échoué"
    fi
}

trap nettoyer_erreur EXIT

# La fonction principale
principal() {
    ok "=========================================="
    ok "Démarrage de la sauvegarde"
    ok "=========================================="

    local heure_debut=$(date +%s)

    # Vérifications
    check_root
    verifier

    # Faire la sauvegarde
    local fichier_backup=$(faire_backup)

    # Nettoyer
    nettoyer

    # Les statistiques
    local heure_fin=$(date +%s)
    local duree=$((heure_fin - heure_debut))
    local nombre=$(find "$DESTINATION" -name "${NOM_BACKUP}_*.tar.gz" | wc -l)

    ok "=========================================="
    ok "Sauvegarde finie !"
    ok "Durée: ${duree}s"
    ok "Fichier: $fichier_backup"
    ok "Total de sauvegardes: $nombre"
    ok "=========================================="
}

# Lancer
principal "$@"

#!/bin/bash

set -euo pipefail

# ✗ Pas bon
if [ -f $fichier ]; then

# ✓ Bien
if [ -f "$fichier" ]; then

readonly CONFIG="/etc/app/config"
readonly MAX=3

# ✗ Pas clair
f="/tmp/data"

# ✓ Clair
temp_data_file="/tmp/data"

# Vérifier si c'est l'administrateur
if [ "$EUID" -ne 0 ]; then
    erreur "Besoin d'être administrateur"
fi

if ! mkdir /tmp/dir; then
    echo "Erreur creation dossier"
    exit 1
fi

# Au lieu de répéter
traiter_fichier() {
    local fichier=$1
    # Faire quelque chose...
}

# Chercher
grep "truc" fichier.txt

# Sans respecter majuscules/minuscules
grep -i "truc" fichier.txt

# Dans tous les dossiers
grep -r "truc" /chemin/

# Avec le numéro de ligne
grep -n "truc" fichier.txt

# L'inverse (ce qui ne correspond pas)
grep -v "truc" fichier.txt

# Remplacer
sed 's/ancien/nouveau/' fichier.txt

# Remplacer partout
sed 's/ancien/nouveau/g' fichier.txt

# Modifier le fichier directement
sed -i 's/ancien/nouveau/g' fichier.txt

# Supprimer des lignes
sed '/truc/d' fichier.txt

# Afficher la première colonne
awk '{print $1}' fichier.txt

# Avec un séparateur différent
awk -F',' '{print $2}' data.csv

# Avec une condition
awk '$3 > 100 {print $1}' fichier.txt

# Additionner une colonne
awk '{sum += $1} END {print sum}' fichier.txt

# Par nom
find /chemin -name "*.txt"

# Par type
find /chemin -type f  # Fichiers
find /chemin -type d  # Dossiers

# Par taille
find /chemin -size +100M

# Modifiés récemment
find /chemin -mtime -7

# Exécuter une commande
find /chemin -name "*.log" -exec rm {} \;