Alias et fonctions Bash

Les alias et les fonctions sont des outils essentiels pour personnaliser votre environnement Bash. Ils vous permettent de créer vos propres commandes, de raccourcir des commandes longues, et d'automatiser des tâches répétitives.

Les alias

Un alias est un raccourci qui remplace une commande ou une série de commandes. C'est la méthode la plus simple pour personnaliser votre terminal.

Créer un alias

Syntaxe de base

alias nom='commande'

Exemples simples

alias ll='ls -la'

Maintenant, taper ll équivaut à taper ls -la.

alias update='sudo apt update && sudo apt upgrade -y'

Crée une commande update qui met à jour le système automatiquement.

alias gs='git status'

Raccourci pour git status.

Lister et supprimer les alias

Voir tous les alias

alias

Affiche tous les alias actuellement définis.

Supprimer un alias

unalias nom_alias

Supprimer tous les alias

unalias -a

Alias avec arguments (limites)

Les alias ne peuvent pas gérer d'arguments directement. Si vous écrivez :

alias gp='git pull origin'

Et que vous tapez gp main, le main sera appendu après la commande complète. Cela fonctionne dans ce cas, mais pour des cas plus complexes, mieux vaut utiliser une fonction.

Les fonctions Bash

Les fonctions sont plus puissantes que les alias. Elles peuvent accepter des paramètres, utiliser des conditions, des boucles, et返回值.

Syntaxe des fonctions

nom_fonction() {
    # commandes
}

Ou avec le mot-clé function (optionnel) :

function nom_fonction {
    # commandes
}

Exemples concrets

Fonction avec paramètres

function backup() {
    cp "$1" "$1.bak-$(date +%Y%m%d)"
}

Utilisation : backup monfichier.txt crée une copie备份 avec la date dans le nom.

Fonction avec plusieurs paramètres

function copier_suite() {
    cp "$1" "$2"
    echo "Copié $1 vers $2"
}

Fonction avec valeur de retour

function taille_fichier() {
    du -h "$1" | cut -f1
}

Appel : taille_fichier document.pdf

Structure conditionnelle dans les fonctions

function est_fichier() {
    if [ -f "$1" ]; then
        echo "$1 est un fichier"
    else
        echo "$1 n'est pas un fichier"
    fi
}

Opérateurs de test courants

Test	Description
`-f`	Vérifie si c'est un fichier
`-d`	Vérifie si c'est un répertoire
`-e`	Vérifie si l'élément existe
`-z`	Vérifie si la chaîne est vide
`-n`	Vérifie si la chaîne n'est pas vide
`-eq`	Vérifie l'égalité numérique

Fonctions avec valeur de retour (return)

function verification() {
    if [ -f "$1" ]; then
        return 0  # Succès
    else
        return 1  # Échec
    fi
}

Utilisation :

verification monfichier.txt
if [ $? -eq 0 ]; then
    echo "Le fichier existe"
fi

Variables dans les fonctions

Variables locales

function calculer() {
    local resultat=$(( $1 + $2 ))
    echo $resultat
}

Le mot-clé local limite la variable à la fonction. Sans cela, la variable serait globale.

Variables spéciales

Variable	Description
`$1, $2, ...`	Paramètres positionnels
`$#`	Nombre de paramètres
`$@`	Tous les paramètres
`$?`	Code de retour de la dernière commande

Exemples pratiques

Créer un répertoire et s'y déplacer

function mkcd() {
    mkdir -p "$1"
    cd "$1"
}

Utilisation : mkcd mon_projet

Sauvegarde avec horodatage

function bak() {
    if [ -f "$1" ]; then
        cp "$1" "$1.$(date +%Y%m%d-%H%M%S).bak"
        echo "Backup créé : $1.$(date +%Y%m%d-%H%M%S).bak"
    else
        echo "Erreur : $1 n'est pas un fichier"
    fi
}

Extraction intelligente

function extraire() {
    if [ -f "$1" ]; then
        case "$1" in
            *.tar.bz2) tar xjf "$1" ;;
            *.tar.gz)  tar xzf "$1" ;;
            *.bz2)     bunzip2 "$1" ;;
            *.gz)      gunzip "$1" ;;
            *.tar)     tar xf "$1" ;;
            *.tbz2)    tar xjf "$1" ;;
            *.tgz)     tar xzf "$1" ;;
            *.zip)     unzip "$1" ;;
            *.7z)      7z x "$1" ;;
            *)         echo "Format non supporté : $1" ;;
        esac
    else
        echo "Erreur : $1 n'existe pas"
    fi
}

Recherche dans l'historique

function hc() {
    history | grep "$1"
}

Utilisation : hc git cherche les commandes git dans l'historique.

Rendre les alias et fonctions permanents

Par défaut, les alias et fonctions définis dans le terminal sont temporaires. Pour les rendre permanents, ajoutez-les dans un fichier de configuration.

Fichier ~/.bashrc

nano ~/.bashrc

Ajoutez vos alias et fonctions à la fin du fichier.

Appliquer les changements

source ~/.bashrc

Ou plus court :

. ~/.bashrc

~/.bash_aliases (recommandé)

Sur certaines distributions, on peut créer un fichier séparé :

# Dans ~/.bashrc, ajoutez :
if [ -f ~/.bash_aliases ]; then
    . ~/.bash_aliases
fi

Puis créez ~/.bash_aliases avec vos alias et fonctions.

Alias système (pour tous les utilisateurs)

Pour des alias visibles par tous les utilisateurs du système, ajoutez-les dans :

# /etc/bash.bashrc (Ubuntu/Debian)
# /etc/bashrc (Red Hat/CentOS)

Ou dans /etc/profile.d/ pour une organisation plus propre.

Alias vs Fonctions : quand utiliser chacun ?

Critère	Alias	Fonctions
Simplicité	Bonne pour les commandes simples	Mieux pour les commandes complexes
Paramètres	Limité (pas de logique)	Support complet
Conditions	Non supportées	Supportées (if, case, etc.)
Valeur de retour	Non supportée	Supportée
Performance	Plus rapide	Légèrement plus lent

Liste de alias utiles

# Navigation
alias ..='cd ..'
alias ...='cd ../..'
alias ....='cd ../../..'

# Sécurité
alias rm='rm -i'      # Confirmation avant suppression
alias cp='cp -i'      # Confirmation avant copie
alias mv='mv -i'      # Confirmation avant déplacement

# Git
alias gs='git status'
alias ga='git add .'
alias gc='git commit -m'
alias gp='git push'
alias gl='git log --oneline --graph --all'
alias gd='git diff'

# Système
alias df='df -h'
alias du='du -h'
alias天气='curl wttr.in/Tavannes'

# Maintenance
alias清理='sudo apt autoremove && sudo apt clean'
alias更新='sudo apt update && sudo apt upgrade -y'

Liste de fonctions utiles

# Créer un projet et s'y déplacer
mproj() { mkdir -p "$1" && cd "$1"; }

# Rechercher et tuer un processus
killp() { ps aux | grep "$1" | grep -v grep | awk '{print $2}' | xargs kill -9; }

# Compter les fichiers par type
count_ext() { find . -type f -name "*.$1" | wc -l; }

# Afficher l'adresse IP publique
monip() { curl ifconfig.me; }

# Créer un point de montage et monter
mountimg() { sudo mount -o loop "$1" /mnt/tmp; }

# Exporter une variable PATH personnalisée
addpath() { export PATH="$PATH:$1"; }

Debugging des fonctions

Pour déboguer une fonction, utilisez set -x :

function teste() {
    set -x
    local resultat=$(( $1 * 2 ))
    echo "Résultat : $resultat"
    set +x
}

Les commandes seront affichées avant leur exécution.

Résumé

Les alias et fonctions transforment votre terminal en outil personnalisé :

alias nom='commande' — crée un raccourci simple
unalias nom — supprime un alias
nom_fonction() { ... } — crée une fonction complexe
Utilisez local pour les variables locales
Placez vos alias/fonctions dans ~/.bashrc pour les rendre permanents
Séparez dans ~/.bash_aliases pour une meilleure organisation