Comment utiliser des sous-coquilles bash à l'intérieur des instructions IF

Si vous avez déjà utilisé des sous-coquilles bash ($ (…)), vous savez à quel point les sous-coquilles peuvent être flexibles. Il ne faut que quelques personnages pour démarrer une sous-coquille pour traiter tout ce qui est nécessaire, en ligne à une autre déclaration. Le nombre de cas d'utilisation possibles est pratiquement illimité.

Nous pouvons également utiliser des sous-coquilles bash à l'intérieur si déclarations, en ligne avec la déclaration. Cela donne à l'utilisateur et au développeur beaucoup de flexibilité supplémentaire lorsqu'il s'agit d'écrire Bash si affirmations.

Si vous n'êtes pas encore familier (ou si vous souhaitez en savoir plus sur) Bash si les déclarations, veuillez consulter notre bash si les déclarations: Si ELIF ELSE, alors FI Article.

Dans ce tutoriel, vous apprendrez:

• Comment intégrer les sous-coquilles bash à l'intérieur si affirmations
• Méthodes avancées pour incorporer des sous-coquilles bash en ligne avec d'autres commandes
• Exemples démontrant l'utilisation de sous-coquilles bash si affirmations

Exigences et conventions logicielles utilisées

Exemple 1: Démarrer simple

Regardons un exemple simple pour commencer. Notez que ces instructions, bien que exécutées ici sur la ligne de commande, peuvent également être incorporées dans un script shell bash (un fichier texte brut, de préférence avec un .shot extension, et marquée comme exécutable en utilisant le chmod + x myscript.shot Commande - Où myscript.shot est un exemple de nom de fichier). Nous introduisons également une erreur pour rendre les choses plus intéressantes.

$ si ["test" == "$ (echo 'test')"]; puis écho à des matchs!';; else echo 'ne correspond pas!';; Fi correspond aux matchs! $ if ["test" == "$ (echo 'incorrect')"]; puis écho à des matchs!';; else 'ne correspond pas!';; Fi ne correspond pas!: commande non trouvée $ 

Dans la première commande, nous utilisons un test simple (si ["some_text" == "some_other_text"]; alors… ) pour vérifier l'égalité entre deux chaînes. Pour la deuxième chaîne, nous avons commencé une sous-shell bash ($ (…)) pour publier le mot test. Le résultat est que test allumettes test Et donc les commandes après le alors La clause sera exécutée, dans ce cas Écho 'Matchs!' est exécuté et Allumettes! tirages.

Dans la deuxième commande, nous modifions la commande echo en une correspondance de texte incorrecte en laissant le sous-coquille Echo / sortie Incorrect ($ (écho «incorrect»)). Nous obtenons une erreur étrange. Regardez attentivement, pouvez-vous repérer l'erreur? Comparez également la deuxième commande avec le premier.

Le problème est que dans notre deuxième commande, le autre clause (qui est exécutée lorsque la correspondance d'égalité échoue, je.e. 'quoi autre Pour faire quand la déclaration IF n'était pas vraie) manque un écho commande. Alors qu'il peut se lire couramment (si… alors écho… sinon…), la commande est incorrecte car elle nécessite un écho supplémentaire. Le résultat est que la coquille bash essaie d'exécuter Ne correspond pas! En tant que commande littérale.

Fixons ça!

$ if ["test" == "$ (echo 'incorrect')"]; puis écho à des matchs!';; else echo 'ne correspond pas!';; Fi ne correspond pas! 

Bien mieux. Et nous pouvons voir notre sous-coquille, c'est écho, Et le plein si Exécution correctement. Super, plongeons un peu plus profondément.

Exemple 2: Énoncé de sous-coquille un peu plus complexe

$ Var1 = "ABC"; si [["$ (echo" $ var1 ")" == * "b" *]]; puis écho à des matchs!';; else echo 'ne correspond pas!';; Fi correspond aux matchs! $ Var1 = "adc"; si [["$ (echo" $ var1 ")" == * "b" *]]; puis écho à des matchs!';; else echo 'ne correspond pas!';; Fi ne correspond pas! 

Ici, nous définissons une variable Var soit abc ou ADC et la prochaine sortie de cette variable, à nouveau en utilisant une sous-coquille, contre la présence de b dans la chaîne. Notez que l'astérisque d'origine (*) préfixe au "B" La clause de comparaison indique n'importe quoi avant cette chaîne et le suffixe astérisque (*) Signifie également Tout après cette chaîne. Nous pouvons voir comment b a été trouvé dans le premier abc chaîne, mais pas dans la deuxième commande / chaîne où ADC a été utilisé comme une chaîne de comparaison.

Notez également comment nous avons utilisé [[…]] supports pour le si déclaration cette fois. Ce n'est pas lié à l'utilisation des sous-coquilles, et c'est simplement une nouvelle norme d'écriture bash si déclarations qui peuvent être utilisées pour des cas d'utilisation supplémentaires ou autres puis le traditionnel […] syntaxe. Nous en avons besoin ici pour faire le spécial b correspondant que nous tenons, en utilisant l'astérisque (*) préfixe et suffixe au "B" Comparez la clause.

Dans un si déclaration avec célibataire […] supports cela échouerait:

$ si ["ABC" == * "B" *]; puis écho à des matchs!';; else echo 'ne correspond pas!';; Fi ne correspond pas! $ si [["ABC" == * "B" *]]; puis écho à des matchs!';; else echo 'ne correspond pas!';; Fi correspond aux matchs! 

Comme le si [… ] La syntaxe ne reconnaît pas l'astérisque (*) préfixe et suffixe au "B" Comparez la clause, et il faut utiliser [[…]] supports à la place.

Une autre chose à noter est que cette fois, nous avons utilisé des citations doubles (") À l'intérieur de la sous-coquille (au lieu des citations simples comme dans le premier exemple): Quand on démarre une sous-coquille, une telle utilisation de citations doubles n'est pas seulement autorisée, mais je peux fortement le recommander pour diverses cas d'utilisation. Il est pratique dans certaines situations où se déroule beaucoup d'analyse complexe et un mélange de citations simples et doubles est nécessaire. Les doubles citations ne termineront pas les citations démarrées avant et à l'extérieur de la sous-coquille.

Veuillez noter qu'avec la plupart des exemples précédents, on aurait simplement pu laisser simplement la sous-coquille et faire une comparaison simple directement avec par exemple la variable, je.e.:

$ Var1 = "ABC"; si [["$ var1" == * "B" *]]; puis écho à des matchs!';; else echo 'ne correspond pas!';; Fi correspond aux matchs! 

Nous avons cependant choisi pour introduire des sous-coquilles avec écho (Effectivement une opération nulle, i.e. effectivement le même que l'utilisation de la variable ou du texte en question) car il soulignerait que 1) les sous-coquilles fonctionnent efficacement, et 2) qu'ils peuvent être utilisés à partir de l'intérieur si affirmations.

Exemple 3: Instructions de sous-coquille avancées si

Nous n'avons pas besoin de restreindre notre utilisation de sous-coque à l'intérieur si instructions à une seule commande, ni à l'utilisation de écho seul. Faisons une petite configuration:

$ toucher un $ ls --coulor = jamais ./ a | wc -l 1 

Nous avons créé un fichier nommé un, et compté le nombre de lignes (en utilisant wc -l, un outil de comptage qui peut compter le nombre de lignes en utilisant le -l option). Nous nous sommes également assurés d'introduire le --color = jamais option de LS Pour éviter les problèmes d'analyse lorsque le codage des couleurs terminaux est utilisé.

Ensuite, travaillons ces déclarations directement dans si déclarations:

$ si [-z "$ (ls --color = jamais ./ a | wc -l) "]; puis écho" sortie du répertoire vide!"; fi $ si [" $ (ls --color = jamais ./ a | wc -l) "-eq 1]; puis écho" exactement un fichier trouvé!"; fi exactement un fichier trouvé! $ 

Ici, nous utilisons la même chose ls… wc -l code deux fois directement à partir d'un si déclaration. La première si déclaration, qui utilise -z vérifie si le texte entre les citations (la première option au -z si-instruction) est vide. Ce n'est pas comme le LS La commande produira une sortie dans ce cas, étant donné que nous avons créé le fichier un.

Dans la deuxième commande, nous testons réellement si la sortie de notre ls… wc -l La commande est égale à 1 en utilisant le -égaliseur Option de test dans le si déclaration. égaliseur représente égal à. Noter que -égaliseur (et c'est revers -ne être pas égal à) ne peut être utilisé que pour les nombres. Pour les chaînes de texte, utilisez == (égal) et != (pas égal) à la place.

La sortie de la commande (Exactement un fichier trouvé!) est correct, et notre si Déclaration avec le sous-shell multi-command incorporé fonctionne bien!

Il est également intéressant de noter qu'il est que la première valeur de comparaison dans la seconde si déclaration (i.e. $ (ls --coulor = jamais ./ a | wc -l) avec sortie 1) est numérique. Alors, pourquoi avons-nous utilisé deux doubles citations ("...") autour de la déclaration de sous-coquille? Cela n'a rien à voir avec les sous-coquilles, et tout avec comment si Fonctionne à Bash, et on ne connaît peut-être pas encore cette astuce ou ce raccourci; Veuillez considérer ceci:

$ V = "1 1" $ if [$ v -eq 0]; puis écho '0'; fi bash: [: trop d'arguments $ si ["$ v" -eq 0]; puis écho '0'; fi bash: [: 1 1: expression entière attendue $ v = 0 $ si ["$ v" -eq 0]; puis écho '0'; fi 0 

En d'autres termes, l'utilisation de Double Quotes est un moyen légèrement plus sûr de programmer Bash si déclarations, même si la condition est une condition numérique. Il protège contre les chaînes plus complexes interprétées comme des éléments individuels plutôt qu'une seule valeur, et il renvoie un message d'erreur correct (Expression entière attendue), au lieu du plus ambigu bash: [: trop d'arguments erreur.

Peu importe non plus de dénigrer que vous comparez ce qui semble être une chaîne de texte (comme indiqué par "...") avec une valeur numérique; Cela fonctionne, à condition que le nombre soit numérique. Et si ce n'est pas le cas, il fournira toujours un meilleur message d'erreur indiquant que la chaîne n'est pas numérique, comme on l'a vu. En résumé, il est préférable de toujours citer votre sous-coquille, texte ou variable avec des devis doubles, même lorsque vous comparez les éléments numériques. Pour prouver que cela fonctionne bien, considérez:

$ si ["1" -eq "1"]; puis écho «y»; fi y $ if ["1" -eq "0"]; puis écho «y»; fi $ 

Conclusion

Dans cet article, nous avons cherché à incorporer des sous-coquilles bash à l'intérieur si affirmations. Nous avons exploré plusieurs exemples, de facile à avancé, sur la façon dont nous pouvons utiliser des sous-coquilles bash à l'intérieur si affirmations. Nous avons également plongé un peu en utilisant des citations doubles en comparant, même lorsque vous comparez les champs numériques. En utilisant des sous-coquilles à l'intérieur d'autres commandes, et dans ce cas si Les déclarations sont un moyen puissant d'élargir vos compétences de script bash. Apprécier!

Tutoriels Linux connexes:

• Sous-sheells Linux avancés avec des exemples
• Sous-coquilles Linux pour les débutants avec des exemples
• Bash si déclarations: si, elif, sinon, alors, fi
• Masterring Bash Script Loops
• Tutoriel de débogage GDB pour les débutants
• Gestion de scripts et de processus de bash multithread au…
• Boucles de bash avec des exemples
• Choses à faire après l'installation d'Ubuntu 20.04 Focal Fossa Linux
• Une introduction à l'automatisation Linux, des outils et des techniques
• Variables de bash spéciaux avec des exemples