Comment savoir si une chaîne Bash contient une sous-chaîne sous Linux

Parfois, dans les scripts Linux, vous souhaitez savoir si une chaîne de texte contient une chaîne spécifique plus petite. Il existe de nombreuses façons de procéder. Nous vous montrons quelques techniques simples et fiables.

Pourquoi est-ce utile ?

La recherche d’une chaîne pour une sous-chaîne plus petite est une exigence courante. Un exemple serait de lire du texte à partir d’un fichier ou d’une entrée humaine et de rechercher dans la chaîne une sous-chaîne spécifique afin que votre script puisse décider quoi faire ensuite. Il peut s’agir de rechercher une étiquette ou un nom de périphérique dans un fichier de configuration ou une chaîne de commande dans une ligne d’entrée d’un utilisateur.

Les utilisateurs de Linux ont la chance de disposer d’un certain nombre d’utilitaires pour manipuler du texte. Certains sont intégrés au shell Bash, d’autres sont fournis en tant qu’utilitaires ou applications autonomes. Il y a une raison pour laquelle les systèmes d’exploitation dérivés d’Unix sont richement servis avec des capacités de manipulation de chaînes.

Certaines choses qui semblent être des fichiers ne sont pas de simples fichiers. Ils sont fichiers spéciaux représentant des éléments tels que les périphériques matériels et les sources d’informations système. L’abstraction effectuée par le système d’exploitation leur donne l’apparence et les caractéristiques des fichiers. Vous pouvez y lire des informations – sous forme de texte, naturellement – et dans certains cas y écrire, mais ce ne sont pas des fichiers ordinaires.

Le texte est également utilisé comme entrée et sortie pour les commandes dans une fenêtre de terminal. Cela permet la redirection et la canalisation de l’entrée et de la sortie. Cette fonctionnalité sous-tend la possibilité d’enchaîner des séquences de commandes Linux, en transmettant la sortie d’une commande comme entrée à la suivante.

Indépendamment de ses origines, la recherche dans le texte que nous recevons d’un mot significatif, d’une commande, d’une étiquette ou d’un autre indicateur fait partie intégrante du traitement des données textuelles. Voici une collection de techniques simples que vous pouvez inclure dans vos propres scripts.

Trouver des sous-chaînes avec Bash Builtins

Les doubles parenthèses « [[...]]” le test de comparaison de chaînes peut être utilisé dans if instructions pour déterminer si une chaîne contient une autre chaîne.

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

#!/bin/bash

if [[ "monkey" = *"key"* ]]; then
  echo "key is in monkey"
else
  echo "key is not in monkey"
fi

Vous devrez rendre le script exécutable avec le chmod commande. Il s’agit d’une étape toujours nécessaire pour rendre un script exécutable. Vous devrez le faire chaque fois que vous créerez un fichier de script. Remplacez le nom du script approprié dans chaque cas.

chmod +x double.sh

Exécutons le script.

./double.sh

Cela fonctionne parce que l’astérisque ” * ” représente n’importe quelle séquence de caractères, y compris aucun caractère. Si la sous-chaîne « clé » se trouve dans la chaîne cible, avec ou sans caractères devant ou derrière, le test renverra vrai.

Dans notre exemple, il y a des caractères devant la sous-chaîne. Ceux-ci sont accompagnés du premier astérisque. Il n’y a pas de lettres derrière la sous-chaîne mais, comme un astérisque ne correspond pas non plus à aucun caractère, le test réussit quand même.

Pour plus de flexibilité, nous pouvons modifier notre script pour gérer des variables au lieu de chaînes littérales. Il s’agit du script « double2.sh ».

#!/bin/bash

string="Monkey"
substring="key"

if [[ $string = *$substring* ]]; then
  echo "$substring was found in $string"
else
  echo "$substring was not found in $string"
fi

Voyons comment cela fonctionne.

./double2.sh

Cela fonctionne de la même manière, avec l’avantage que nous pouvons utiliser des noms de variables au lieu de chaînes littérales. Transformer notre petite solution en une fonction offrira le plus de flexibilité.

Il s’agit du script « double3.sh ».

#!/bin/bash

shopt -s nocasematch

string="Monkey"
substring="Key"
capital="London"

check_substring ()
{
if [[ $1 = *$2* ]]; then
  echo "$2 was found in $1"
else
  echo "$2 was not found in $1"
fi
}

check_substring "Monkey" "key" 
check_substring $string $substring
check_substring $string "banana"
check_substring "Wales" $capital

Nous appelons notre check_substring fonction utilisant un mélange de variables et de chaînes littérales. Nous avons utilisé shopt avec son -s (définir) option pour définir nocasematchpour rendre les correspondances insensibles à la casse.

Voici comment ça marche.

./double3.sh

Nous pouvons utiliser l’astuce consistant à envelopper la sous-chaîne d’astérisques dans case déclarations aussi. Il s’agit de « case.sh ».

#!/bin/bash

shopt -s nocasematch

string="Wallaby"
substring="Wall"

case $string in

  *$substring*)
    echo "$substring was found in $string"
    ;;

  *)
    echo "Nothing matched: $string"
    ;;
esac

Utilisant case déclarations au lieu de très longues if Les instructions peuvent faciliter la lecture et le débogage des scripts. Si vous deviez vérifier si une chaîne contenait l’une des nombreuses sous-chaînes possibles, le case déclaration serait le meilleur choix.

./case.sh

La sous-chaîne est trouvée.

Trouver des sous-chaînes avec grep

Au-delà des fonctions intégrées de Bash, le premier outil de recherche de texte que vous atteindrez probablement est grep. On peut utiliser grepla capacité innée de rechercher une chaîne dans une chaîne pour rechercher nos sous-chaînes.

Ce script s’appelle « subgrep.sh ».

#!/bin/bash

string="porridge pot"
substring="ridge"

if $(echo $string | grep -q $substring); then
  echo "$substring was found in $string"
else
  echo "$substring was not found in $string"
fi

Le script utilise echo pour envoyer la chaîne dans grep, qui recherche la sous-chaîne. Nous utilisons le -q option (silencieuse) pour arrêter grep écrire quoi que ce soit sur la sortie standard.

Si le résultat des commandes entre parenthèses « (...)” est égal à zéro, cela signifie qu’une correspondance a été trouvée. Parce que zéro équivaut à true dans Bash, le if déclaration est satisfaite et le then clause est exécutée.

Voyons quelle est sa sortie.

./subgrep.sh

Trouver des sous-chaînes avec sed

On peut utiliser sed pour trouver une sous-chaîne, aussi.

Par défaut, sed imprime tout le texte qui y est introduit. Utilisant sed -n empêche cela. Les seules lignes imprimées sont les lignes correspondantes. Cette expression imprimera toutes les lignes qui correspondent ou contiennent la valeur de $substring.

"/$substring/p"

Nous alimentons la valeur de $string dans sed en utilisant une redirection ici, <<<. Ceci est utilisé pour rediriger les valeurs dans une commande dans le shell actuel. Il n’invoque pas un sous-shell comme le ferait un tube.

La première -n est l’épreuve. Il reviendra true si la sortie du sed la commande est différente de zéro. La seule façon dont la sortie de sed peut être différent de zéro si une ligne correspondante a été trouvée. Si c’est le cas, $substring doit avoir été trouvé dans $string.

Il s’agit de « subsed.sh ».

#!/bin/bash

string="Sweden"
substring="eden"

if [ -n "$(sed -n "/$substring/p" <<< $string)" ]; then
  echo "$substring was found in $string"
else
  echo "$substring was not found in $string"
fi

Nous obtenons la réponse attendue lorsque nous exécutons le script.

./subsed.sh

Nous pouvons tester la logique du script en éditant la valeur de $substring de sorte que la comparaison échoue.

./subsed.sh

Arrêtez de chercher, trouvez-le

D’autres outils peuvent trouver des sous-chaînes, telles que awk et Perl mais un cas d’utilisation simple comme la recherche d’une sous-chaîne ne garantit pas leur fonctionnalité supplémentaire ni la complexité supplémentaire. En particulier, l’utilisation des commandes intégrées de Bash pour rechercher des sous-chaînes est rapide, simple et ne nécessite pas d’outils externes.