Modularisation avec des Fonctions :

Pour des scripts plus lisibles et maintenables, utilisez des fonctions pour segmenter votre code.

Exemple :

greeting() { echo "Bonjour, $1" } greeting "Alice"

Documenter Votre Code :

  • Documentez vos fonctions en expliquant leur but et les arguments nécessaires.
  • Exemple :
# Cette fonction affiche un message de bienvenue # $1 - Le nom de la personne greeting() { echo "Bonjour, $1" }

Utilisation de Shift :

  • Utilisez shift pour gérer les arguments de manière plus flexible.
  • Exemple :
process_file() { 
local input_file="$1"; shift 
local output_file="$1"; shift 
}

Déclaration des Variables :

Déclarez les variables en précisant leur type si nécessaire.

Exemple : declare -i count=0 pour un entier.

Cotation des Variables :

Citez vos variables pour éviter des problèmes avec des espaces ou des caractères spéciaux.

Exemple : 

echo "$variable"

Usage des Tableaux :

  • Utilisez des tableaux pour stocker des collections d’éléments.
  • Exemple : arr=(item1 item2 item3)

Utilisation de $@ :

  • Préférez $@ à $* pour obtenir les arguments comme une liste séparée.
  • Exemple :
for arg in "$@"; do echo "$arg" done

Nom des Variables :

  • Utilisez des majuscules uniquement pour les variables d’environnement, et des minuscules pour les autres.

Préférence pour les Opérations Intégrées :

  • Utilisez les fonctionnalités intégrées du shell au lieu d’invoquer des programmes externes.
  • Exemple : Utilisez ${string//substring/replacement} au lieu de sed.

Optimisation des Pipes :

  • Réduisez l’usage des pipes en évitant des commandes inutiles.
  • Exemple : Utilisez awk '/pattern/{print $1}' file au lieu de grep pattern file | awk '{print $1}'.

Globbing et Valeurs Nulles :

  • Utilisez le globbing pour générer des listes de fichiers, et utilisez -print0 avec find pour gérer des noms de fichiers complexes.
  • Exemple :
find . -type f -print0 | xargs -0 rm -f

Substitution de Commandes :

  • Préférez $(command) à `command` pour une meilleure lisibilité.
  • Exemple : echo "Nous sommes le $(date)"

Substitution de Processus et Fichiers Temporaires :

  • Utilisez la substitution de processus < (command) pour éviter les fichiers temporaires.
  • Exemple :
diff <(command1) <(command2)

Usage de [[ et (( pour les Conditions :

  • Utilisez [[ ... ]] pour les tests et (( ... )) pour les comparaisons arithmétiques.
  • Exemple :
if (( number > 10 )); then echo "Le nombre est supérieur à 10." fi

Vérification des Commandes :

  • Utilisez la commande directement dans la condition de l’instruction if.
  • Exemple :bash
if grep -q "pattern" file; then echo "Pattern trouvé." fi

Utilisation de set -e :

  • Placez set -e en haut de votre script pour quitter dès qu’une instruction échoue.
  • Exemple :
set -e command1 command2 # Le script s'arrête ici si command1 échoue

Vérification des Dépendances : Assurez-vous que toutes les commandes externes nécessaires sont disponibles avant de procéder.

command -v awk >/dev/null 2>&1 || { echo "awk est requis mais n'est pas installé. Abandon."; exit 1; }

Utilisation de trap pour le Nettoyage : Utilisez la commande trap pour nettoyer les ressources avant de quitter.

trap 'rm -f "$tempfile"' EXIT tempfile=$(mktemp)

Utilisation de getopts pour Gérer les Options : Utilisez getopts pour gérer les options et les arguments de votre script de manière standard.

while getopts "hvf:" opt; do case $opt in h) echo "Usage: $0 [-h] [-v] [-f file]"; exit ;; v) verbose=true ;; f) file=$OPTARG ;; *) echo "Option invalide: -$OPTARG" >&2; exit 1 ;; esac done

Utilisation de readonly et declare -r pour les Constantes : Déclarez les constantes avec readonly ou declare -r.

readonly PI=3.14159

Vérification des Codes de Retour : Vérifiez les codes de retour des commandes importantes.

command || { echo "command a échoué"; exit 1; }

Indentation et Style Consistant : Adoptez un style d’indentation consistant pour améliorer la lisibilité.

Utilisation de Fonctions pour les Blocs Logiques : Encapsulez des blocs logiques dans des fonctions pour améliorer la modularité et la lisibilité.

Évitez l’Usage de eval : La commande eval peut être dangereuse. Évitez son utilisation ou assurez-vous de bien comprendre ses implications.

Utilisation de set -u : Utilisez set -u pour quitter le script si des variables non définies sont utilisées.

set -u echo "$undefined_variable" # Ceci déclenchera une erreur

Utilisation de Commentaires Informatifs : Commentez votre code de manière informative sans être redondant.

Nommage des Variables et des Fonctions : Utilisez des noms descriptifs pour vos variables et fonctions pour améliorer la compréhension du code.

Utilisation de set -o pipefail : Utilisez set -o pipefail pour attraper les erreurs dans les pipelines.

set -o pipefail command1 | command2 | command3

Vérification des Performances : Si le script est destiné à traiter de grands ensembles de données, prenez en compte les performances. Utilisez des outils comme time pour mesurer le temps d’exécution.

Ces bonnes pratiques rendront vos scripts shell plus robustes, lisibles, et faciles à maintenir !