# Fichier: python_cheats/cheatsheets/bash.txt
# Cheatsheet Bash - Guide Complet pour Débutants


================================================================================
[DOCS] INTRODUCTION À BASH
================================================================================

# Qu'est-ce que Bash ?
# Bash (Bourne Again Shell) est un interpréteur de commandes (shell) pour Unix/Linux
# C'est l'interface entre vous et le système d'exploitation
# Vous tapez des commandes, Bash les exécute

# Pourquoi apprendre Bash ?
# - Automatiser des tâches répétitives
# - Gérer fichiers et dossiers efficacement
# - Scripter des workflows complexes
# - Indispensable pour développement et DevOps

# Où utiliser Bash ?
# - Terminal Linux
# - Terminal macOS
# - Git Bash sur Windows
# - WSL (Windows Subsystem for Linux)

# Comment ouvrir un terminal ?
# Linux: Ctrl+Alt+T ou chercher "Terminal"
# Mac: Cmd+Space puis taper "Terminal"
# Windows: Git Bash, WSL, ou PowerShell (similaire)


================================================================================
[OK] BASES FONDAMENTALES
================================================================================

# === PREMIERS PAS ===

# Afficher du texte
echo "Hello World"
echo 'Hello World'              # Avec guillemets simples
echo Hello World                 # Sans guillemets (simple)

# Différence entre ' et "
echo "Mon nom est $USER"        # Interprète les variables
echo 'Mon nom est $USER'        # Affiche littéralement $USER

# Afficher la date
date
date +"%Y-%m-%d"                # Format personnalisé: 2025-01-15
date +"%H:%M:%S"                # Heure: 14:30:45

# Afficher le calendrier
cal                              # Mois courant
cal 2025                         # Année complète
cal 12 2025                      # Décembre 2025

# Qui suis-je ?
whoami                           # Nom d'utilisateur
id                               # ID utilisateur et groupes

# Où suis-je ?
pwd                              # Print Working Directory (dossier actuel)

# Effacer l'écran
clear                            # Ou Ctrl+L

# Historique des commandes
history                          # Toutes les commandes tapées
history 10                       # 10 dernières commandes
!123                             # Re-exécuter commande numéro 123
!!                               # Re-exécuter dernière commande
!$                               # Dernier argument de la commande précédente

# Rechercher dans l'historique
Ctrl+R                           # Mode recherche interactive
# Tapez quelques lettres, puis Enter pour exécuter


# === NAVIGATION FICHIERS/DOSSIERS ===

# Lister les fichiers
ls                               # Liste simple
ls -l                            # Liste détaillée (permissions, taille, date)
ls -a                            # Inclut fichiers cachés (.fichier)
ls -la                           # Liste détaillée + fichiers cachés
ls -lh                           # Tailles lisibles (KB, MB, GB)
ls -lt                           # Trié par date de modification
ls -ltr                          # Trié par date (plus ancien en premier)
ls -R                            # Récursif (sous-dossiers aussi)

# Exemples pratiques
ls *.txt                         # Tous les fichiers .txt
ls -l Documents/                 # Contenu d'un dossier spécifique
ls -d */                         # Seulement les dossiers

# Changer de dossier
cd Documents                     # Aller dans Documents
cd ..                            # Remonter d'un niveau (dossier parent)
cd ../..                         # Remonter de 2 niveaux
cd ~                             # Aller au dossier home (/home/user)
cd -                             # Retour au dossier précédent
cd /                             # Racine du système
cd                               # Retour au home (équivalent à cd ~)

# Chemins absolus vs relatifs
cd /home/user/Documents          # Chemin absolu (commence par /)
cd Documents/projets             # Chemin relatif (depuis dossier actuel)

# Créer dossiers
mkdir mon_dossier                # Créer un dossier
mkdir -p parent/enfant/petit     # Créer structure complète
mkdir dossier1 dossier2          # Créer plusieurs dossiers
mkdir "Mon Dossier"              # Nom avec espaces (guillemets requis)

# Créer fichiers vides
touch fichier.txt                # Créer ou mettre à jour date
touch file1.txt file2.txt        # Plusieurs fichiers

# Copier fichiers/dossiers
cp fichier.txt copie.txt         # Copier fichier
cp fichier.txt ~/Documents/      # Copier vers dossier
cp -r dossier/ copie_dossier/    # Copier dossier (-r = récursif)
cp -v fichier.txt copie.txt      # Mode verbeux (affiche ce qui se passe)
cp -i fichier.txt existe.txt     # Mode interactif (demande confirmation)

# Déplacer/Renommer
mv ancien.txt nouveau.txt        # Renommer fichier
mv fichier.txt ~/Documents/      # Déplacer fichier
mv -i fichier.txt dest.txt       # Demander confirmation si existe
mv dossier/ ~/Documents/         # Déplacer dossier

# Supprimer
rm fichier.txt                   # Supprimer fichier
rm -i fichier.txt                # Demander confirmation
rm -f fichier.txt                # Forcer (pas de confirmation)
rm -r dossier/                   # Supprimer dossier récursivement
rm -rf dossier/                  # Supprimer sans confirmation (ATTENTION!)
rm *.tmp                         # Supprimer tous les .tmp
rmdir dossier_vide/              # Supprimer dossier vide uniquement

# [ATTENTION]  ATTENTION: rm -rf est DANGEREUX et IRRÉVERSIBLE!
# Toujours vérifier avant d'exécuter


# === VOIR CONTENU DES FICHIERS ===

# Afficher tout le contenu
cat fichier.txt                  # Afficher fichier complet
cat file1.txt file2.txt          # Afficher plusieurs fichiers
cat -n fichier.txt               # Avec numéros de ligne

# Afficher par page
less fichier.txt                 # Navigation: espace (page suivante), 
                                 # b (page précédente), q (quitter)
more fichier.txt                 # Similaire mais moins de fonctionnalités

# Afficher début/fin
head fichier.txt                 # 10 premières lignes
head -n 5 fichier.txt            # 5 premières lignes
tail fichier.txt                 # 10 dernières lignes
tail -n 20 fichier.txt           # 20 dernières lignes
tail -f log.txt                  # Suivre en temps réel (logs)

# Compter lignes/mots/caractères
wc fichier.txt                   # Lignes, mots, caractères
wc -l fichier.txt                # Seulement nombre de lignes
wc -w fichier.txt                # Seulement nombre de mots
wc -c fichier.txt                # Seulement nombre d'octets


# === RECHERCHE ===

# Rechercher des fichiers
find . -name "*.txt"             # Tous les .txt dans dossier actuel
find /home -name "config.json"   # Chercher config.json dans /home
find . -type f -name "*.py"      # Seulement les fichiers .py
find . -type d -name "test"      # Seulement les dossiers nommés "test"
find . -mtime -7                 # Modifiés il y a moins de 7 jours
find . -size +10M                # Fichiers > 10 MB
find . -name "*.log" -delete     # Trouver et supprimer

# Rechercher dans les fichiers (grep)
grep "mot" fichier.txt           # Chercher "mot" dans fichier
grep -i "mot" fichier.txt        # Insensible à la casse
grep -r "TODO" .                 # Récursif dans tous les fichiers
grep -n "error" log.txt          # Avec numéros de ligne
grep -v "debug" log.txt          # Lignes qui NE contiennent PAS "debug"
grep -c "error" log.txt          # Compter occurrences
grep -l "TODO" *.py              # Juste les noms de fichiers

# Recherche avancée
grep -E "error|warning" log.txt  # Regex: error OU warning
grep -A 3 "error" log.txt        # 3 lignes Après la correspondance
grep -B 2 "error" log.txt        # 2 lignes Avant
grep -C 2 "error" log.txt        # 2 lignes Context (avant et après)


================================================================================
[OK] REDIRECTIONS ET PIPES
================================================================================

# === REDIRECTIONS ===

# Rediriger sortie vers fichier
echo "Hello" > fichier.txt       # Écrase fichier (ou crée si n'existe pas)
echo "World" >> fichier.txt      # Ajoute à la fin du fichier

# Exemples pratiques
ls -l > liste.txt                # Sauver liste de fichiers
date >> log.txt                  # Ajouter date au log
cat file1.txt > output.txt       # Copier contenu

# Rediriger erreurs
command 2> erreurs.txt           # Seulement les erreurs
command > output.txt 2>&1        # Sortie normale ET erreurs
command &> all.txt               # Raccourci pour les deux

# Ignorer sortie
command > /dev/null              # Ignorer sortie normale
command 2> /dev/null             # Ignorer erreurs
command &> /dev/null             # Ignorer tout

# Lire depuis fichier
sort < liste.txt                 # Utiliser fichier comme entrée


# === PIPES (|) ===

# Le pipe envoie la sortie d'une commande à l'entrée d'une autre
# C'est LA fonctionnalité la plus puissante de Bash!

# Exemples simples
ls -l | less                     # Voir liste de fichiers page par page
cat fichier.txt | grep "error"   # Chercher "error" dans fichier
history | tail -20               # 20 dernières commandes

# Exemples avancés
ls -l | wc -l                    # Compter nombre de fichiers
ps aux | grep python             # Trouver processus Python
cat access.log | grep "404" | wc -l    # Compter erreurs 404

# Chaîner plusieurs commandes
cat data.txt | grep "2025" | sort | uniq | wc -l
# 1. Lire data.txt
# 2. Garder lignes avec "2025"
# 3. Trier
# 4. Enlever doublons
# 5. Compter

# Trier et filtrer
ls -lh | sort -k5 -h             # Trier par taille (colonne 5)
du -h | sort -hr | head -10      # 10 plus gros fichiers

# Extraire colonnes
ls -l | awk '{print $9}'         # 9e colonne (noms fichiers)
ps aux | awk '{print $2, $11}'   # PID et commande


================================================================================
[OK] VARIABLES
================================================================================

# === DÉFINIR ET UTILISER VARIABLES ===

# Créer variable
nom="Jean"                       # PAS d'espaces autour du =
age=25
chemin="/home/user/documents"

# Utiliser variable
echo $nom                        # Affiche: Jean
echo "Bonjour $nom"              # Affiche: Bonjour Jean
echo "J'ai $age ans"             # Affiche: J'ai 25 ans

# Avec accolades (recommandé)
echo "${nom}"                    # Plus clair
echo "${nom}_backup"             # Concaténation

# Variables système importantes
echo $HOME                       # Dossier home: /home/user
echo $USER                       # Nom utilisateur
echo $SHELL                      # Shell utilisé: /bin/bash
echo $PATH                       # Chemins des programmes
echo $PWD                        # Dossier actuel
echo $OLDPWD                     # Dossier précédent
echo $HOSTNAME                   # Nom de la machine
echo $LANG                       # Langue système

# Lister toutes les variables
env                              # Variables d'environnement
set                              # Toutes les variables

# Export (rendre variable disponible aux sous-processus)
export MA_VAR="valeur"
export PATH="$PATH:/nouveau/chemin"

# Supprimer variable
unset nom


# === VARIABLES SPÉCIALES DANS SCRIPTS ===

# $0   - Nom du script
# $1   - Premier argument
# $2   - Deuxième argument
# $#   - Nombre d'arguments
# $@   - Tous les arguments
# $?   - Code retour dernière commande (0 = succès)
# $$   - PID du script


# === SUBSTITUTION DE COMMANDES ===

# Capturer sortie d'une commande
date_actuelle=$(date +%Y-%m-%d)
echo "Aujourd'hui: $date_actuelle"

nombre_fichiers=$(ls | wc -l)
echo "Il y a $nombre_fichiers fichiers"

# Ancienne syntaxe (encore valide)
date_actuelle=`date +%Y-%m-%d`


# === OPÉRATIONS ARITHMÉTIQUES ===

# Calculs simples
x=5
y=3
somme=$((x + y))                 # 8
difference=$((x - y))            # 2
produit=$((x * y))               # 15
quotient=$((x / y))              # 1 (division entière)
reste=$((x % y))                 # 2 (modulo)

# Incrémenter
compteur=0
compteur=$((compteur + 1))
((compteur++))                   # Raccourci

# Exemple
echo $((10 + 5))                 # Affiche: 15
resultat=$((100 / 3))
echo "100 divisé par 3 = $resultat"


================================================================================
[OK] CONDITIONS ET TESTS
================================================================================

# === STRUCTURE IF ===

# Syntaxe de base
if [ condition ]; then
    # commandes si vrai
fi

# If-else
if [ condition ]; then
    # si vrai
else
    # si faux
fi

# If-elif-else
if [ condition1 ]; then
    # si condition1 vraie
elif [ condition2 ]; then
    # si condition2 vraie
else
    # sinon
fi


# === TESTS DE FICHIERS ===

# Tester existence
if [ -e fichier.txt ]; then
    echo "Le fichier existe"
fi

# Tests courants
[ -f fichier ]      # Est un fichier régulier
[ -d dossier ]      # Est un dossier
[ -e fichier ]      # Existe (fichier ou dossier)
[ -r fichier ]      # Est lisible
[ -w fichier ]      # Est modifiable
[ -x fichier ]      # Est exécutable
[ -s fichier ]      # N'est pas vide
[ -L lien ]         # Est un lien symbolique

# Exemples pratiques
if [ -f "config.txt" ]; then
    echo "Config trouvée"
    cat config.txt
else
    echo "Config manquante!"
fi

if [ ! -d "backup" ]; then
    mkdir backup
    echo "Dossier backup créé"
fi


# === TESTS DE CHAÎNES ===

# Tests de base
[ -z "$var" ]           # Chaîne vide
[ -n "$var" ]           # Chaîne non vide
[ "$a" = "$b" ]         # Égales
[ "$a" != "$b" ]        # Différentes

# Exemples
nom="Jean"
if [ -n "$nom" ]; then
    echo "Nom défini: $nom"
fi

if [ "$USER" = "root" ]; then
    echo "Vous êtes admin!"
fi


# === TESTS NUMÉRIQUES ===

# Comparaisons
[ "$a" -eq "$b" ]       # Égal (equal)
[ "$a" -ne "$b" ]       # Différent (not equal)
[ "$a" -lt "$b" ]       # Plus petit (less than)
[ "$a" -le "$b" ]       # Plus petit ou égal (less or equal)
[ "$a" -gt "$b" ]       # Plus grand (greater than)
[ "$a" -ge "$b" ]       # Plus grand ou égal (greater or equal)

# Exemple
age=18
if [ $age -ge 18 ]; then
    echo "Vous êtes majeur"
else
    echo "Vous êtes mineur"
fi


# === OPÉRATEURS LOGIQUES ===

# ET logique (AND)
if [ -f "file1.txt" ] && [ -f "file2.txt" ]; then
    echo "Les deux fichiers existent"
fi

# OU logique (OR)
if [ "$USER" = "root" ] || [ "$USER" = "admin" ]; then
    echo "Vous avez les droits"
fi

# NON logique (NOT)
if [ ! -f "fichier.txt" ]; then
    echo "Fichier n'existe pas"
fi

# Syntaxe alternative avec [[ ]]
if [[ -f "file1.txt" && -f "file2.txt" ]]; then
    echo "Les deux existent"
fi


# === CASE (SWITCH) ===

# Syntaxe
case $variable in
    motif1)
        # commandes
        ;;
    motif2)
        # commandes
        ;;
    *)
        # défaut
        ;;
esac

# Exemple
fruit="pomme"
case $fruit in
    pomme)
        echo "C'est rouge"
        ;;
    banane)
        echo "C'est jaune"
        ;;
    orange)
        echo "C'est orange"
        ;;
    *)
        echo "Fruit inconnu"
        ;;
esac

# Exemple avec choix utilisateur
echo "Choisissez (1-3):"
read choix
case $choix in
    1)
        echo "Option 1"
        ;;
    2)
        echo "Option 2"
        ;;
    3)
        echo "Option 3"
        ;;
    *)
        echo "Choix invalide"
        ;;
esac


================================================================================
[OK] BOUCLES
================================================================================

# === BOUCLE FOR ===

# Itérer sur liste
for item in un deux trois; do
    echo $item
done

# Itérer sur fichiers
for fichier in *.txt; do
    echo "Traitement de $fichier"
    cat "$fichier"
done

# Itérer sur nombres
for i in 1 2 3 4 5; do
    echo "Nombre: $i"
done

# Style C
for ((i=1; i<=10; i++)); do
    echo "Compteur: $i"
done

# Avec séquence
for i in $(seq 1 10); do
    echo $i
done

# Ou plus moderne
for i in {1..10}; do
    echo $i
done

# Exemples pratiques
# Renommer tous les .txt en .bak
for fichier in *.txt; do
    mv "$fichier" "${fichier%.txt}.bak"
done

# Créer 5 dossiers
for i in {1..5}; do
    mkdir "dossier_$i"
done


# === BOUCLE WHILE ===

# Syntaxe de base
while [ condition ]; do
    # commandes
done

# Compteur
compteur=1
while [ $compteur -le 5 ]; do
    echo "Itération $compteur"
    ((compteur++))
done

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

# Boucle infinie (Ctrl+C pour arrêter)
while true; do
    echo "En cours..."
    sleep 1
done

# Attendre qu'un fichier existe
while [ ! -f "done.txt" ]; do
    echo "En attente..."
    sleep 2
done


# === BOUCLE UNTIL ===

# Continue jusqu'à ce que condition soit vraie
compteur=1
until [ $compteur -gt 5 ]; do
    echo "Compteur: $compteur"
    ((compteur++))
done


# === BREAK ET CONTINUE ===

# Break: sortir de la boucle
for i in {1..10}; do
    if [ $i -eq 5 ]; then
        break
    fi
    echo $i
done

# Continue: passer à l'itération suivante
for i in {1..10}; do
    if [ $i -eq 5 ]; then
        continue
    fi
    echo $i
done


================================================================================
[OK] FONCTIONS
================================================================================

# === DÉFINIR FONCTION ===

# Syntaxe 1
function nom_fonction {
    # commandes
}

# Syntaxe 2 (plus courante)
nom_fonction() {
    # commandes
}

# Exemple simple
saluer() {
    echo "Bonjour!"
}

# Appeler la fonction
saluer


# === FONCTIONS AVEC PARAMÈTRES ===

# Les paramètres sont $1, $2, $3, etc.
saluer() {
    echo "Bonjour $1!"
}

saluer "Jean"           # Affiche: Bonjour Jean!
saluer "Marie"          # Affiche: Bonjour Marie!

# Multiple paramètres
calculer() {
    local a=$1
    local b=$2
    local resultat=$((a + b))
    echo "La somme est: $resultat"
}

calculer 5 3            # Affiche: La somme est: 8


# === RETOURNER VALEUR ===

# return renvoie un code (0-255, 0 = succès)
est_pair() {
    local nombre=$1
    if [ $((nombre % 2)) -eq 0 ]; then
        return 0    # vrai
    else
        return 1    # faux
    fi
}

if est_pair 4; then
    echo "4 est pair"
fi

# Pour retourner autre chose, utiliser echo
additionner() {
    local a=$1
    local b=$2
    echo $((a + b))
}

resultat=$(additionner 10 5)
echo "Résultat: $resultat"      # Affiche: Résultat: 15


# === VARIABLES LOCALES ===

# local rend la variable locale à la fonction
ma_fonction() {
    local var_locale="locale"
    var_globale="globale"
    echo $var_locale
}

ma_fonction
echo $var_globale       # Accessible
echo $var_locale        # Vide (pas accessible)


# === EXEMPLES PRATIQUES ===

# Fonction de backup
backup() {
    local source=$1
    local dest=$2
    
    if [ ! -d "$dest" ]; then
        mkdir -p "$dest"
    fi
    
    cp -r "$source" "$dest"
    echo "Backup de $source vers $dest terminé"
}

backup ~/Documents ~/backups

# Fonction de log
log() {
    local message=$1
    local timestamp=$(date +"%Y-%m-%d %H:%M:%S")
    echo "[$timestamp] $message" >> app.log
}

log "Application démarrée"
log "Erreur: Fichier introuvable"

# Fonction de validation
valider_fichier() {
    local fichier=$1
    
    if [ ! -f "$fichier" ]; then
        echo "Erreur: $fichier n'existe pas"
        return 1
    fi
    
    if [ ! -r "$fichier" ]; then
        echo "Erreur: $fichier n'est pas lisible"
        return 1
    fi
    
    return 0
}

if valider_fichier "config.txt"; then
    echo "Fichier valide!"
    cat config.txt
fi


================================================================================
[OK] SCRIPTS BASH
================================================================================

# === CRÉER PREMIER SCRIPT ===

# 1. Créer fichier avec .sh
# 2. Ajouter shebang en première ligne
# 3. Écrire commandes
# 4. Rendre exécutable
# 5. Exécuter

# Exemple: mon_script.sh
#!/bin/bash
# Mon premier script

echo "Début du script"
echo "Bonjour $USER"
echo "Nous sommes le $(date)"
echo "Fin du script"

# Rendre exécutable
chmod +x mon_script.sh

# Exécuter
./mon_script.sh


# === SHEBANG ===

#!/bin/bash              # Bash standard
#!/usr/bin/env bash      # Portable (recommandé)
#!/bin/sh                # Shell POSIX (compatible)


# === ARGUMENTS DE SCRIPT ===

# Créer: salutation.sh
#!/bin/bash

echo "Nom du script: $0"
echo "Premier argument: $1"
echo "Deuxième argument: $2"
echo "Nombre d'arguments: $#"
echo "Tous les arguments: $@"

# Exécuter
./salutation.sh Jean Dupont
# Affiche:
# Nom du script: ./salutation.sh
# Premier argument: Jean
# Deuxième argument: Dupont
# Nombre d'arguments: 2
# Tous les arguments: Jean Dupont


# === LIRE ENTRÉE UTILISATEUR ===

# read
read nom
echo "Bonjour $nom"

# Avec prompt
read -p "Entrez votre nom: " nom
echo "Bonjour $nom"

# Lecture sans écho (mot de passe)
read -s -p "Mot de passe: " password
echo ""
echo "Mot de passe enregistré"

# Avec timeout
read -t 5 -p "Répondez en 5 secondes: " reponse

# Avec valeur par défaut
read -p "Nom [Jean]: " nom
nom=${nom:-Jean}
echo "Bonjour $nom"


# === GESTION D'ERREURS ===

# set -e: Arrêter si erreur
#!/bin/bash
set -e

echo "Début"
commande_inexistante  # Script s'arrête ici
echo "Fin"            # Ne s'exécute pas

# Vérifier code retour
if commande; then
    echo "Succès"
else
    echo "Échec"
fi

# Capturer code retour
commande
if [ $? -eq 0 ]; then
    echo "Succès"
else
    echo "Erreur (code $?)"
fi

# Avec trap (nettoyer avant sortie)
#!/bin/bash
trap "echo 'Nettoyage...'; rm -f temp.txt" EXIT

echo "Script en cours..."
touch temp.txt
# temp.txt sera supprimé même si erreur


# === EXEMPLE COMPLET: SCRIPT DE BACKUP ===

#!/bin/bash
# backup.sh - Script de sauvegarde

set -e  # Arrêter si erreur

# Couleurs pour messages
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# Fonction de log
log() {
    echo -e "${GREEN}[$(date +'%Y-%m-%d %H:%M:%S')]${NC} $1"
}

error() {
    echo -e "${RED}[ERREUR]${NC} $1" >&2
}

warning() {
    echo -e "${YELLOW}[ATTENTION]${NC} $1"
}

# Vérifier arguments
if [ $# -ne 2 ]; then
    error "Usage: $0 <source> <destination>"
    exit 1
fi

SOURCE=$1
DEST=$2
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_NAME="backup_${TIMESTAMP}"

# Vérifier source existe
if [ ! -d "$SOURCE" ]; then
    error "Le dossier source n'existe pas: $SOURCE"
    exit 1
fi

# Créer destination si nécessaire
if [ ! -d "$DEST" ]; then
    warning "Création du dossier de destination"
    mkdir -p "$DEST"
fi

# Effectuer backup
log "Début du backup de $SOURCE"
log "Destination: $DEST/$BACKUP_NAME"

if cp -r "$SOURCE" "$DEST/$BACKUP_NAME"; then
    log "Backup réussi!"
    
    # Statistiques
    taille=$(du -sh "$DEST/$BACKUP_NAME" | cut -f1)
    log "Taille: $taille"
    
    nb_fichiers=$(find "$DEST/$BACKUP_NAME" -type f | wc -l)
    log "Nombre de fichiers: $nb_fichiers"
else
    error "Échec du backup"
    exit 1
fi

# Nettoyer anciens backups (garder 5 derniers)
log "Nettoyage des anciens backups..."
cd "$DEST"
ls -t | grep "^backup_" | tail -n +6 | xargs -I {} rm -rf {}
log "Terminé!"


# === EXEMPLE: MENU INTERACTIF ===

#!/bin/bash
# menu.sh - Menu interactif

while true; do
    clear
    echo "================================"
    echo "     MENU PRINCIPAL"
    echo "================================"
    echo "1. Lister fichiers"
    echo "2. Afficher date"
    echo "3. Qui suis-je"
    echo "4. Espace disque"
    echo "5. Quitter"
    echo "================================"
    
    read -p "Votre choix (1-5): " choix
    
    case $choix in
        1)
            echo ""
            ls -lh
            read -p "Appuyez sur Entrée pour continuer..."
            ;;
        2)
            echo ""
            date
            read -p "Appuyez sur Entrée pour continuer..."
            ;;
        3)
            echo ""
            echo "Utilisateur: $USER"
            echo "Home: $HOME"
            echo "Shell: $SHELL"
            read -p "Appuyez sur Entrée pour continuer..."
            ;;
        4)
            echo ""
            df -h
            read -p "Appuyez sur Entrée pour continuer..."
            ;;
        5)
            echo "Au revoir!"
            exit 0
            ;;
        *)
            echo "Choix invalide!"
            sleep 2
            ;;
    esac
done


================================================================================
[OK] TRAITEMENT DE TEXTE
================================================================================

# === SED (Stream Editor) ===

# Remplacer texte
sed 's/ancien/nouveau/' fichier.txt          # Première occurrence par ligne
sed 's/ancien/nouveau/g' fichier.txt         # Toutes occurrences
sed 's/ancien/nouveau/gi' fichier.txt        # Insensible à la casse

# Modifier fichier en place
sed -i 's/ancien/nouveau/g' fichier.txt      # Linux
sed -i '' 's/ancien/nouveau/g' fichier.txt   # Mac

# Supprimer lignes
sed '3d' fichier.txt                         # Supprimer ligne 3
sed '2,5d' fichier.txt                       # Supprimer lignes 2 à 5
sed '/motif/d' fichier.txt                   # Supprimer lignes contenant "motif"

# Afficher lignes spécifiques
sed -n '10p' fichier.txt                     # Afficher ligne 10
sed -n '5,10p' fichier.txt                   # Afficher lignes 5 à 10
sed -n '/error/p' fichier.txt                # Lignes contenant "error"

# Exemples pratiques
# Remplacer dans tous les fichiers Python
sed -i 's/old_function/new_function/g' *.py

# Nettoyer espaces en fin de ligne
sed -i 's/[[:space:]]*$//' fichier.txt

# Ajouter ligne au début
sed -i '1i\# En-tête du fichier' fichier.txt


# === AWK (Traitement de colonnes) ===

# Afficher colonnes
awk '{print $1}' fichier.txt                 # 1ère colonne
awk '{print $1, $3}' fichier.txt             # 1ère et 3ème
awk '{print $NF}' fichier.txt                # Dernière colonne

# Avec délimiteur personnalisé
awk -F':' '{print $1}' /etc/passwd           # Colonnes séparées par :
awk -F',' '{print $2}' data.csv              # Fichier CSV

# Conditions
awk '$3 > 100' fichier.txt                   # Lignes où colonne 3 > 100
awk '$1 == "error"' log.txt                  # Lignes où colonne 1 = "error"
awk 'NR > 1' fichier.txt                     # Ignorer première ligne

# Calculs
awk '{sum += $2} END {print sum}' data.txt   # Somme colonne 2
awk '{print $1, $2*2}' data.txt              # Multiplier colonne 2 par 2

# Exemples pratiques
# Taille totale des fichiers
ls -l | awk '{sum += $5} END {print sum}'

# Utilisateurs système
awk -F':' '{print $1}' /etc/passwd

# CSV vers tableau
awk -F',' '{printf "%-10s %-10s %-10s\n", $1, $2, $3}' data.csv


# === CUT (Extraire colonnes) ===

# Par position de caractères
cut -c1-5 fichier.txt                        # Caractères 1 à 5
cut -c1,5,9 fichier.txt                      # Caractères 1, 5 et 9

# Par délimiteur
cut -d':' -f1 /etc/passwd                    # 1er champ (délimiteur :)
cut -d',' -f1,3 data.csv                     # Champs 1 et 3 (CSV)
cut -d' ' -f2- fichier.txt                   # Du champ 2 jusqu'à la fin


# === SORT (Trier) ===

# Tris de base
sort fichier.txt                             # Ordre alphabétique
sort -r fichier.txt                          # Ordre inverse
sort -u fichier.txt                          # Supprimer doublons
sort -n fichier.txt                          # Tri numérique

# Trier par colonne
sort -k2 fichier.txt                         # Par 2ème colonne
sort -k2 -n fichier.txt                      # Par 2ème colonne (numérique)
sort -k2,2 -k3,3 fichier.txt                 # Par 2ème puis 3ème

# Trier tailles lisibles
du -h | sort -h                              # 1K, 2M, 3G

# Exemples
ls -l | sort -k5 -n                          # Fichiers par taille
sort -t',' -k3 -n data.csv                   # CSV par 3ème colonne


# === UNIQ (Doublons) ===

# Supprimer doublons consécutifs
uniq fichier.txt

# Compter occurrences
uniq -c fichier.txt

# Seulement les doublons
uniq -d fichier.txt

# Seulement les uniques
uniq -u fichier.txt

# Exemple: mots les plus fréquents
cat texte.txt | tr ' ' '\n' | sort | uniq -c | sort -nr | head -10


# === TR (Transformer caractères) ===

# Remplacer caractères
tr 'a' 'A' < fichier.txt                     # a -> A
tr 'a-z' 'A-Z' < fichier.txt                 # Minuscules -> majuscules
tr 'A-Z' 'a-z' < fichier.txt                 # Majuscules -> minuscules

# Supprimer caractères
tr -d '0-9' < fichier.txt                    # Supprimer chiffres
tr -d ' ' < fichier.txt                      # Supprimer espaces

# Compresser caractères répétés
tr -s ' ' < fichier.txt                      # Multiples espaces -> un seul
tr -s '\n' < fichier.txt                     # Lignes vides -> une seule

# Exemples
echo "Hello World" | tr 'a-z' 'A-Z'          # HELLO WORLD
cat fichier.txt | tr '\n' ' '                # Tout sur une ligne


# === PASTE (Fusionner lignes) ===

# Fusionner deux fichiers côte à côte
paste file1.txt file2.txt

# Avec délimiteur
paste -d',' file1.txt file2.txt              # Séparés par virgule

# Fusionner lignes d'un fichier
paste -s -d',' fichier.txt                   # Une ligne avec virgules


# === JOIN (Joindre fichiers) ===

# Joindre sur première colonne commune
join file1.txt file2.txt

# Joindre sur colonnes spécifiques
join -1 2 -2 1 file1.txt file2.txt           # Col 2 de file1 = col 1 de file2


# === EXEMPLES COMBINÉS ===

# Top 10 des commandes les plus utilisées
history | awk '{print $2}' | sort | uniq -c | sort -nr | head -10

# Trouver fichiers doublons par nom
find . -type f -printf '%f\n' | sort | uniq -d

# Extraire emails d'un fichier
grep -Eo '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' fichier.txt | sort -u

# Compter lignes de code par extension
find . -name "*.py" -exec wc -l {} + | sort -n

# Analyser logs: TOP IPs
cat access.log | awk '{print $1}' | sort | uniq -c | sort -nr | head -10


================================================================================
[OK] GESTION DES PROCESSUS
================================================================================

# === VOIR PROCESSUS ===

# ps - Snapshot des processus
ps                                   # Processus du terminal actuel
ps aux                               # Tous les processus (détaillé)
ps aux | grep python                 # Trouver processus Python
ps -ef                               # Format complet
ps -u username                       # Processus d'un utilisateur

# top - Monitoring en temps réel
top                                  # Affichage dynamique
# q pour quitter
# k pour tuer un processus
# M pour trier par mémoire
# P pour trier par CPU

# htop - Version améliorée de top (si installé)
htop

# pgrep - Trouver PID par nom
pgrep python
pgrep -u username firefox


# === GÉRER PROCESSUS ===

# Lancer en arrière-plan
commande &
python script.py &

# Voir jobs en cours
jobs
jobs -l                              # Avec PID

# Ramener en avant-plan
fg                                   # Dernier job
fg %1                                # Job numéro 1

# Remettre en arrière-plan
bg
bg %1

# Suspendre processus (Ctrl+Z)
# Puis continuer en arrière-plan
bg

# Tuer processus
kill PID                             # SIGTERM (propre)
kill -9 PID                          # SIGKILL (force)
kill -15 PID                         # SIGTERM (équivalent)
killall nom_programme                # Tous les processus du nom
pkill python                         # Tuer par nom

# Tuer avec timeout
timeout 10s commande                 # Tue après 10 secondes


# === NICE (PRIORITÉ) ===

# Lancer avec priorité basse
nice -n 10 commande                  # Valeurs: -20 (haute) à 19 (basse)

# Changer priorité processus existant
renice -n 5 -p PID


# === NOHUP (CONTINUER APRÈS DÉCONNEXION) ===

# Lancer processus qui survit à la fermeture du terminal
nohup commande &
nohup python script.py > output.log 2>&1 &


# === SURVEILLER RESSOURCES ===

# Utilisation CPU/Mémoire
top
htop

# Utilisation disque
df -h                                # Espace disque par partition
du -h dossier/                       # Taille d'un dossier
du -sh *                             # Taille de chaque élément
du -h --max-depth=1                  # Un niveau seulement

# Trouver gros fichiers
find . -type f -size +100M           # Fichiers > 100MB
du -ah . | sort -rh | head -20       # 20 plus gros

# Utilisation mémoire
free -h                              # Mémoire RAM
vmstat                               # Statistiques mémoire virtuelle

# Réseau
netstat -tuln                        # Ports ouverts
ss -tuln                             # Alternative moderne
lsof -i :8000                        # Qui utilise le port 8000


# === EXEMPLES PRATIQUES ===

# Tuer tous les processus Python
pkill python

# Trouver et tuer processus bloqué
ps aux | grep "script.py"
kill -9 PID

# Lancer script en arrière-plan avec log
nohup python script.py > script.log 2>&1 &

# Surveiller utilisation CPU d'un processus
watch -n 1 'ps aux | grep python'


================================================================================
[OK] PERMISSIONS ET PROPRIÉTÉ
================================================================================

# === COMPRENDRE PERMISSIONS ===

# Afficher permissions
ls -l fichier.txt
# -rw-r--r-- 1 user group 1234 Jan 15 10:00 fichier.txt
#  │││ │││ │││
#  │││ │││ └──── Autres (other)
#  │││ └────────  Groupe (group)
#  └─────────────  Propriétaire (user)

# Premier caractère:
# - = fichier régulier
# d = dossier
# l = lien symbolique

# Permissions:
# r = read (lecture) = 4
# w = write (écriture) = 2
# x = execute (exécution) = 1
# - = pas de permission = 0


# === CHMOD (CHANGER PERMISSIONS) ===

# Mode symbolique
chmod u+x fichier.sh                 # Ajouter exécution pour user
chmod g+w fichier.txt                # Ajouter écriture pour group
chmod o-r fichier.txt                # Retirer lecture pour others
chmod a+x script.sh                  # Ajouter exécution pour all

# u = user, g = group, o = others, a = all
# + = ajouter, - = retirer, = = définir exactement

# Mode numérique (octal)
chmod 755 script.sh                  # rwxr-xr-x
chmod 644 fichier.txt                # rw-r--r--
chmod 600 secret.txt                 # rw-------
chmod 777 fichier.txt                # rwxrwxrwx (DANGEREUX!)

# Calcul:
# 7 = 4+2+1 = rwx
# 6 = 4+2   = rw-
# 5 = 4+1   = r-x
# 4 = 4     = r--
# 0 =       = ---

# Récursif
chmod -R 755 dossier/                # Appliquer à tout

# Exemples courants
chmod +x script.sh                   # Rendre exécutable
chmod 600 ~/.ssh/id_rsa              # Clé SSH privée
chmod 644 *.txt                      # Fichiers texte standards


# === CHOWN (CHANGER PROPRIÉTAIRE) ===

# Changer propriétaire
sudo chown user fichier.txt

# Changer propriétaire et groupe
sudo chown user:group fichier.txt

# Seulement groupe
sudo chown :group fichier.txt
sudo chgrp group fichier.txt         # Équivalent

# Récursif
sudo chown -R user:group dossier/

# Exemples
sudo chown www-data:www-data /var/www/
sudo chown $USER:$USER fichier.txt


# === UMASK (PERMISSIONS PAR DÉFAUT) ===

# Voir umask actuel
umask
# 0022 typiquement

# Définir umask
umask 022                            # Fichiers: 644, dossiers: 755
umask 077                            # Fichiers: 600, dossiers: 700

# Calcul:
# Fichiers: 666 - umask
# Dossiers: 777 - umask


# === SUDO (EXÉCUTER EN TANT QUE ROOT) ===

# Exécuter commande en root
sudo commande

# Devenir root temporairement
sudo -i                              # Login shell
sudo -s                              # Shell actuel

# Exécuter en tant qu'autre utilisateur
sudo -u username commande

# Éditer fichier système
sudo nano /etc/hosts
sudoedit /etc/hosts                  # Plus sûr

# Voir qui peut utiliser sudo
sudo -l


# === EXEMPLES PRATIQUES ===

# Script exécutable
chmod +x script.sh
./script.sh

# Sécuriser fichier de mots de passe
chmod 600 passwords.txt
ls -l passwords.txt
# -rw------- (seulement vous pouvez lire/écrire)

# Site web
sudo chown -R www-data:www-data /var/www/html/
sudo chmod -R 755 /var/www/html/

# Projet Python
chmod 644 *.py                       # Code source
chmod 755 venv/bin/*                 # Scripts venv
chmod 600 .env                       # Variables d'environnement


================================================================================
[OK] COMPRESSION ET ARCHIVES
================================================================================

# === TAR (ARCHIVER) ===

# Créer archive
tar -cvf archive.tar dossier/        # c=create, v=verbose, f=file
tar -cvf backup.tar file1 file2 file3

# Extraire archive
tar -xvf archive.tar                 # x=extract
tar -xvf archive.tar -C /destination/

# Lister contenu
tar -tvf archive.tar                 # t=list

# Ajouter à archive existante
tar -rvf archive.tar nouveau_fichier # r=append


# === TAR + GZIP (.tar.gz ou .tgz) ===

# Créer archive compressée
tar -czvf archive.tar.gz dossier/    # z=gzip
tar -czvf backup.tgz Documents/

# Extraire
tar -xzvf archive.tar.gz
tar -xzvf archive.tar.gz -C /destination/

# Lister
tar -tzvf archive.tar.gz


# === TAR + BZIP2 (.tar.bz2) ===

# Créer (meilleure compression, plus lent)
tar -cjvf archive.tar.bz2 dossier/   # j=bzip2

# Extraire
tar -xjvf archive.tar.bz2


# === TAR + XZ (.tar.xz) ===

# Créer (excellente compression)
tar -cJvf archive.tar.xz dossier/    # J=xz

# Extraire
tar -xJvf archive.tar.xz


# === GZIP (COMPRESSER FICHIERS) ===

# Compresser
gzip fichier.txt                     # Crée fichier.txt.gz, supprime original
gzip -k fichier.txt                  # Garde l'original (-k=keep)
gzip -9 fichier.txt                  # Compression maximale

# Décompresser
gunzip fichier.txt.gz
gzip -d fichier.txt.gz               # Équivalent

# Compresser plusieurs
gzip *.txt


# === BZIP2 ===

# Compresser
bzip2 fichier.txt                    # Crée fichier.txt.bz2

# Décompresser
bunzip2 fichier.txt.bz2


# === ZIP (Compatible Windows) ===

# Créer archive
zip archive.zip fichier.txt
zip -r archive.zip dossier/          # Récursif
zip backup.zip *.txt

# Extraire
unzip archive.zip
unzip archive.zip -d /destination/

# Lister contenu
unzip -l archive.zip

# Ajouter à archive
zip -u archive.zip nouveau.txt

# Protéger par mot de passe
zip -e secure.zip fichier.txt        # Demande mot de passe


# === 7ZIP (SI INSTALLÉ) ===

# Compresser
7z a archive.7z dossier/

# Extraire
7z x archive.7z


# === EXEMPLES PRATIQUES ===

# Backup complet d'un projet
tar -czvf projet_$(date +%Y%m%d).tar.gz ~/projet/

# Backup excluant certains fichiers
tar -czvf backup.tar.gz --exclude='*.log' --exclude='node_modules' projet/

# Extraire fichier spécifique
tar -xzvf archive.tar.gz fichier.txt

# Comparer taille
ls -lh fichier.txt
gzip fichier.txt
ls -lh fichier.txt.gz

# Pipeline de compression
cat fichier.txt | gzip > fichier.txt.gz
cat fichier.txt.gz | gunzip > fichier.txt

# Backup de base de données
mysqldump database | gzip > backup_$(date +%Y%m%d).sql.gz


================================================================================
[OK] RÉSEAU
================================================================================

# === TESTER CONNECTIVITÉ ===

# Ping
ping google.com                      # Ctrl+C pour arrêter
ping -c 4 google.com                 # 4 pings seulement

# Tracer route
traceroute google.com
tracepath google.com                 # Alternative

# Test DNS
nslookup google.com
dig google.com
host google.com


# === TÉLÉCHARGER FICHIERS ===

# wget
wget https://example.com/file.zip
wget -O nouveau_nom.zip https://example.com/file.zip
wget -c https://example.com/big.zip  # Continuer téléchargement
wget -b https://example.com/file.zip  # En arrière-plan
wget -r https://example.com/          # Récursif (site entier)

# curl
curl https://example.com
curl -O https://example.com/file.zip  # Sauvegarder fichier
curl -o nom.zip https://example.com/file.zip
curl -L https://bit.ly/shortlink      # Suivre redirections
curl -I https://example.com           # Seulement headers


# === TRANSFÉRER FICHIERS ===

# scp (SSH Copy)
scp fichier.txt user@server:/chemin/
scp user@server:/chemin/fichier.txt ./
scp -r dossier/ user@server:/chemin/  # Récursif
scp -P 2222 fichier.txt user@server:/ # Port spécifique

# rsync (Synchronisation)
rsync -avz source/ destination/       # a=archive, v=verbose, z=compress
rsync -avz --delete source/ dest/     # Supprimer fichiers en trop
rsync -avz source/ user@server:/dest/
rsync -avz --exclude='*.log' source/ dest/


# === SSH ===

# Connexion
ssh user@server
ssh user@server -p 2222               # Port personnalisé
ssh -i ~/.ssh/key.pem user@server     # Clé spécifique

# Exécuter commande à distance
ssh user@server 'ls -la'
ssh user@server 'uptime && df -h'

# Tunnel SSH (Port Forwarding)
ssh -L 8080:localhost:80 user@server  # Local forward
ssh -R 8080:localhost:80 user@server  # Remote forward


# === INFORMATIONS RÉSEAU ===

# Adresse IP
ip addr                              # Moderne
ifconfig                             # Ancien
hostname -I                          # IP simple

# Connexions actives
netstat -tuln                        # Ports en écoute
ss -tuln                             # Alternative moderne
lsof -i :8000                        # Qui utilise port 8000

# Qui est connecté
w                                    # Utilisateurs connectés
who                                  # Version simple
last                                 # Historique connexions


# === FIREWALL (UFW - Ubuntu) ===

# Status
sudo ufw status

# Activer/Désactiver
sudo ufw enable
sudo ufw disable

# Autoriser port
sudo ufw allow 22                    # SSH
sudo ufw allow 80/tcp                # HTTP
sudo ufw allow from 192.168.1.0/24   # Subnet

# Refuser
sudo ufw deny 23                     # Telnet


# === EXEMPLES PRATIQUES ===

# Tester si port ouvert
nc -zv google.com 80
telnet google.com 80

# Vitesse internet
curl -s https://raw.githubusercontent.com/sivel/speedtest-cli/master/speedtest.py | python -

# Synchroniser deux dossiers
rsync -avz --progress source/ backup/

# Télécharger page web
wget --mirror --convert-links --page-requisites https://example.com

# API REST
curl -X POST https://api.example.com/data \
  -H "Content-Type: application/json" \
  -d '{"key": "value"}'


================================================================================
[OK] ASTUCES ET RACCOURCIS
================================================================================

# === RACCOURCIS CLAVIER ===

# Navigation
Ctrl+A              # Début de ligne
Ctrl+E              # Fin de ligne
Ctrl+U              # Effacer jusqu'au début
Ctrl+K              # Effacer jusqu'à la fin
Ctrl+W              # Effacer mot précédent
Alt+B               # Mot précédent
Alt+F               # Mot suivant

# Historique
Ctrl+R              # Recherche dans historique
Ctrl+P              # Commande précédente (^)
Ctrl+N              # Commande suivante (v)

# Contrôle processus
Ctrl+C              # Interrompre (SIGINT)
Ctrl+Z              # Suspendre
Ctrl+D              # EOF / Déconnexion
Ctrl+L              # Effacer écran

# Copier-coller (terminal)
Ctrl+Shift+C        # Copier
Ctrl+Shift+V        # Coller


# === ALIAS (RACCOURCIS PERSONNALISÉS) ===

# Définir alias temporaire
alias ll='ls -lah'
alias gs='git status'
alias python=python3

# Alias permanent (~/.bashrc ou ~/.bash_aliases)
echo "alias ll='ls -lah'" >> ~/.bashrc
source ~/.bashrc                     # Recharger

# Exemples utiles
alias ..='cd ..'
alias ...='cd ../..'
alias mkdir='mkdir -pv'
alias rm='rm -i'
alias cp='cp -i'
alias mv='mv -i'
alias df='df -h'
alias du='du -h'
alias free='free -h'
alias grep='grep --color=auto'

# Voir tous les alias
alias

# Supprimer alias
unalias ll


# === EXPANSION DE COMMANDES ===

# Accolades
echo {A,B,C}        # A B C
echo {1..10}        # 1 2 3 4 5 6 7 8 9 10
echo {a..z}         # a b c ... z
mkdir dir{1..5}     # Crée dir1, dir2, ..., dir5
touch file{1..3}.txt

# Combinaisons
echo {A,B}{1,2}     # A1 A2 B1 B2

# Variables
echo {$HOME,$PWD}


# === ASTUCES DE PRODUCTIVITÉ ===

# Ré-exécuter avec sudo
sudo !!                              # Dernière commande avec sudo

# Dernier argument
mkdir /long/chemin/vers/dossier
cd !$                                # cd /long/chemin/vers/dossier

# Tous les arguments sauf la commande
cp file1.txt file2.txt /destination/
ls !*                                # ls file1.txt file2.txt /destination/

# Commande précédente
!!                                   # Re-exécute
!-2                                  # Commande d'il y a 2
!ping                                # Dernière commande commençant par ping

# Substitution rapide
^ancien^nouveau                      # Remplace dans dernière commande
# Exemple:
# $ cat fihcier.txt (faute de frappe)
# $ ^ih^hi
# $ cat fichier.txt (corrigé)