fatmawati achmad zaenuri/Shutterstock.com
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. Ce sont des fichiers spéciaux représentant des éléments tels que des périphériques matériels et des 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
En 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.
By default, sed prints all text that is fed into it. Using sed -n prevents this. The only lines that are printed are matching lines. This expression will print any lines that match or contain the value of $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.
