Comment utiliser les instructions de cas dans les scripts Bash

Les déclarations de cas Bash sont puissantes mais faciles à écrire. Lorsque vous revisitez un ancien script Linux, vous serez heureux d’avoir utilisé un case déclaration au lieu d’un long if-then-else déclaration.

L’affaire Déclaration

La plupart des langages de programmation ont leur version d’un switch ou case déclaration. Ceux-ci dirigent le flux d’exécution du programme en fonction de la valeur d’une variable. Typiquement, il y a une branche d’exécution définie pour chacune des valeurs possibles attendues de la variable et un fourre-tout ou défaut branche pour toutes les autres valeurs.

La fonctionnalité logique est similaire à une longue séquence de if-then déclarations avec un else déclaration attrapant tout ce qui n’a pas été précédemment géré par l’un des if déclarations.

La mise en œuvre de Bash case essaie de faire correspondre un expression avec l’une des clauses. Il le fait en examinant chaque clause, à tour de rôle, en essayant de trouver une correspondance modèle. Les modèles dans les clauses sont des chaînes, mais, contre-intuitivement, cela ne signifie pas que nous ne pouvons pas utiliser de valeurs numériques comme expression.

Le cas générique

La forme générique du case l’énoncé est celui-ci :

case expression in 

  pattern-1)
    statement 
    ;;

  pattern-2) 
    statement
    ;;
    .
    .
    .

  pattern-N) 
    statement 
    ;;

  *) 
    statement 
    ;; 
esac

• UNE case l’instruction doit commencer par le case mot-clé et terminer par le esac mot-clé.
• L’expression est évaluée et comparée aux modèles dans chaque clause jusqu’à ce qu’une correspondance soit trouvée.
• L’instruction ou les instructions de la clause de correspondance sont exécutées.
• Un double point-virgule « ;;” est utilisé pour terminer une clause.
• Si un modèle correspond et que les instructions de cette clause sont exécutées, tous les autres modèles sont ignorés.
• Il n’y a pas de limite au nombre de clauses.
• Un astérisque « *” désigne le modèle par défaut. Si une expression ne correspond à aucun des autres modèles de la case instruction la clause par défaut est exécutée.

Un exemple simple

Ce script nous indique les heures d’ouverture d’une boutique imaginaire. Il utilise le date commande avec le +"%a" chaîne de format pour obtenir le nom du jour abrégé. Celui-ci est stocké dans le DayName variable.

#!/bin/bash

DayName=$(date +"%a")

echo "Opening hours for $DayName"

case $DayName in

  Mon)
    echo "09:00 - 17:30"
    ;;

  Tue)
    echo "09:00 - 17:30"
    ;;

  Wed)
    echo "09:00 - 12:30"
    ;;

  Thu)
    echo "09:00 - 17:30"
    ;;

  Fri)
    echo "09:00 - 16:00"
    ;;

  Sat)
    echo "09:30 - 16:00"
    ;;

  Sun)
    echo "Closed all day"
    ;;

  *)
    ;;
esac

Copiez ce texte dans un éditeur et enregistrez-le dans un fichier appelé « open.sh ».

Nous devrons utiliser le chmod commande pour le rendre exécutable. Vous devrez le faire pour tous les scripts que vous créez pendant que vous travaillez sur cet article.

chmod +x open.sh

Nous pouvons maintenant exécuter notre script.

./open.sh

Le jour où la capture d’écran a été prise se trouve être un vendredi. Cela signifie que le DayName La variable contient la chaîne « Ven ». Cela correspond au modèle « Fri » de la clause « Fri) ».

Notez que les modèles dans les clauses n’ont pas besoin d’être entourés de guillemets doubles, mais cela ne fait aucun mal s’ils le sont. Cependant, vous doit utilisez des guillemets doubles si le motif contient des espaces.

La clause par défaut a été laissée vide. Tout ce qui ne correspond pas à l’une des clauses précédentes est ignoré.

Ce script fonctionne et il est facile à lire, mais il est long et répétitif. Nous pouvons raccourcir ce type de case déclaration assez facilement.

EN RELATION: Comment utiliser la commande chmod sous Linux

Utilisation de plusieurs modèles dans une clause

Une caractéristique vraiment intéressante de case instructions est que vous pouvez utiliser plusieurs modèles dans chaque clause. Si l’expression correspond à l’un de ces modèles, les instructions de cette clause sont exécutées.

Voici un script qui vous indique combien de jours il y a dans un mois. Il ne peut y avoir que trois réponses : 30 jours, 31 jours ou 28 ou 29 jours pour février. Ainsi, bien qu’il y ait 12 mois, nous n’avons besoin que de trois clauses.

Dans ce script, l’utilisateur est invité à saisir le nom d’un mois. Pour rendre la correspondance de motif insensible à la casse, nous utilisons le shopt commande avec le -s nocasematch option. Peu importe que l’entrée contienne des majuscules, des minuscules ou un mélange des deux.

#!/bin/bash

shopt -s nocasematch

echo "Enter name of a month"
read month

case $month in

  February)
    echo "28/29 days in $month"
    ;;

  April | June | September | November)
    echo "30 days in $month"
    ;;

  January | March | May | July | August | October | December)
    echo "31 days in $month"
    ;;

  *)
    echo "Unknown month: $month"
    ;;
esac

Février a une clause à lui tout seul, et tous les autres mois partagent deux clauses selon qu’ils ont 30 ou 31 jours. Les clauses multi-modèles utilisent le symbole pipe « | » comme séparateur. La casse par défaut capture les mois mal orthographiés.

Nous l’avons enregistré dans un fichier appelé « month.sh » et l’avons rendu exécutable.

chmod +x month.sh

Nous exécuterons le script plusieurs fois et montrerons que peu importe que nous utilisions des majuscules ou des minuscules.

./month.sh

Parce que nous avons dit au script d’ignorer les différences entre les majuscules et les minuscules, tout nom de mois correctement orthographié est géré par l’une des trois clauses principales. Les mois mal orthographiés sont visés par la clause par défaut.

Utilisation de chiffres dans les instructions case

Nous pouvons également utiliser des chiffres ou des variables numériques comme expression. Ce script demande à l’utilisateur d’entrer un nombre dans la plage 1..3. Pour indiquer clairement que les modèles de chaque clause sont des chaînes, ils ont été entourés de guillemets doubles. Malgré cela, le script fait toujours correspondre l’entrée de l’utilisateur à la clause appropriée.

#!/bin/bash

echo "Enter 1, 2, or 3: "
read Number

case $Number in

  "1")
    echo "Clause 1 matched"
    ;;

  "2")
    echo "Clause 2 matched"
    ;;

  "3")
    echo "Clause 3 matched"
    ;;

  *)
    echo "Default clause matched"
    ;;
esac

Enregistrez-le dans un fichier appelé « number.sh », rendez-le exécutable, puis exécutez-le :

./number.sh

Utilisation des instructions case dans les boucles for

UNE case L’instruction essaie de rechercher une correspondance avec une seule expression. Si vous avez beaucoup d’expressions à traiter, vous pouvez mettre le case déclaration à l’intérieur d’un for boucle.

Ce script exécute le ls commande pour obtenir une liste de fichiers. Dans le for boucle, la globalisation de fichiers, similaire mais différente des expressions régulières, est appliquée à chaque fichier à tour de rôle pour extraire l’extension de fichier. Celui-ci est stocké dans le Extension variable de chaîne.

Les case l’instruction utilise le Extension variable comme l’expression qu’elle essaie de faire correspondre à une clause.

#!/bin/bash

for File in $(ls)

do
  # extract the file extension
  Extension=${File##*.}

  case "$Extension" in

    sh)
      echo " Shell script: $File"
      ;;

    md)
      echo " Markdown file: $File"
      ;;

    png)
      echo "PNG image file: $File"
      ;;

    *)
      echo "Unknown: $File"
      ;;
  esac
done

Enregistrez ce texte dans un fichier appelé « filetype.sh », rendez-le exécutable, puis exécutez-le en utilisant :

./filetype.sh

Notre script d’identification de type de fichier minimaliste fonctionne.

EN RELATION: Comment utiliser « Here Documents » dans Bash sous Linux

Gestion des codes de sortie avec les instructions case

Un programme bien élevé enverra un code de sortie au shell lorsqu’il se terminera. Le schéma conventionnel utilise une valeur de code de sortie de zéro pour indiquer une exécution sans problème, et des valeurs d’un ou plusieurs pour indiquer différents types d’erreur.

De nombreux programmes n’utilisent que zéro et un. Le regroupement de toutes les conditions d’erreur dans un seul code de sortie rend l’identification des problèmes plus difficile, mais c’est une pratique courante.

Nous avons créé un petit programme appelé « go-geek » qui renverrait au hasard des codes de sortie de zéro ou un. Ce prochain script appelle go-geek. Il acquiert le code de sortie à l’aide du $? variable shell et l’utilise comme expression pour la case déclaration.

Un script du monde réel effectuerait le traitement approprié en fonction du succès ou de l’échec de la commande qui a généré le code de sortie.

#!/bin/bash

go-geek

case $? in

  "0")
    echo "Response was: Success"
    echo "Do appropriate processing in here"
    ;;

  "1")
    echo "Response was: Error"
    echo "Do appropriate error handling in here"
    ;;

  *)
    echo "Unrecognised response: $?"
    ;;
esac

Enregistrez-le dans un script appelé « return-code.sh » et rendez-le exécutable. Vous devrez substituer une autre commande à notre go-geek commander. Tu pourrais essayer de cd dans un répertoire qui n’existe pas pour obtenir un code de sortie d’un, puis modifiez votre script pour cd dans un répertoire accessible pour obtenir un code de sortie de zéro.

L’exécution du script plusieurs fois montre que les différents codes de sortie sont correctement identifiés par le case déclaration.

./return-code.sh

La lisibilité aide à la maintenabilité

Revenir aux anciens scripts Bash et déterminer comment ils font ce qu’ils font, surtout s’ils ont été écrits par quelqu’un d’autre, est un défi. Modifier la fonctionnalité des anciens scripts est encore plus difficile.

Les case L’instruction vous donne une logique de branchement avec une syntaxe claire et simple. C’est un gagnant-gagnant.

EN RELATION: Comment installer et utiliser Linux Bash Shell sur Windows 10