J'ai une chaîne dans Bash:

string="My string"

Comment puis-je tester s'il contient une autre chaîne?

if [ $string ?? 'foo' ]; then
  echo "It's there!"
fi

Où ??est mon opérateur inconnu. Dois-je utiliser l'écho et grep?

if echo "$string" | grep 'foo'; then
  echo "It's there!"
fi

Cela semble un peu maladroit.

Vous pouvez également utiliser la réponse de Marcus (* caractères génériques) en dehors d'une déclaration de cas, si vous utilisez des crochets doubles:

string='My long string'
if [[ $string == *"My long"* ]]; then
  echo "It's there!"
fi

Notez que les espaces dans la chaîne d'aiguille doivent être placés entre guillemets doubles et les *caractères génériques doivent être à l'extérieur. Notez également qu'un opérateur de comparaison simple est utilisé (c'est-à-dire ==), et non l'opérateur regex =~.

Si vous préférez l'approche regex:

string='My string';

if [[ $string =~ "My" ]]
then
   echo "It's there!"
fi

Je ne suis pas sûr d'utiliser une instruction if, mais vous pouvez obtenir un effet similaire avec une instruction case:

case "$string" in 
  *foo*)
    # Do stuff
    ;;
esac

stringContain variantes (compatibles ou indépendantes du boîtier)

Comme ces réponses Stack Overflow parlent principalement de Bash , j'ai posté une fonction Bash indépendante de la casse tout en bas de cet article ...

Quoi qu'il en soit, il y a mon

Réponse compatible

Comme il y a déjà beaucoup de réponses en utilisant des fonctionnalités spécifiques à Bash, il existe un moyen de travailler sous des shells plus pauvres, comme BusyBox :

[ -z "${string##*$reqsubstr*}" ]

En pratique, cela pourrait donner:

string='echo "My string"'
for reqsubstr in 'o "M' 'alt' 'str';do
  if [ -z "${string##*$reqsubstr*}" ] ;then
      echo "String '$string' contain substring: '$reqsubstr'."
    else
      echo "String '$string' don't contain substring: '$reqsubstr'."
    fi
  done

Cela a été testé sous Bash, Dash , KornShell ( ksh) et ash (BusyBox), et le résultat est toujours:

String 'echo "My string"' contain substring: 'o "M'.
String 'echo "My string"' don't contain substring: 'alt'.
String 'echo "My string"' contain substring: 'str'.

En une seule fonction

Comme l'a demandé @EeroAaltonen, voici une version de la même démo, testée sous les mêmes shells:

myfunc() {
    reqsubstr="$1"
    shift
    string="$@"
    if [ -z "${string##*$reqsubstr*}" ] ;then
        echo "String '$string' contain substring: '$reqsubstr'.";
      else
        echo "String '$string' don't contain substring: '$reqsubstr'."
    fi
}

Alors:

$ myfunc 'o "M' 'echo "My String"'
String 'echo "My String"' contain substring 'o "M'.

$ myfunc 'alt' 'echo "My String"'
String 'echo "My String"' don't contain substring 'alt'.

Remarque: vous devez échapper ou insérer des guillemets doubles et / ou des guillemets doubles:

$ myfunc 'o "M' echo "My String"
String 'echo My String' don't contain substring: 'o "M'.

$ myfunc 'o "M' echo \"My String\"
String 'echo "My String"' contain substring: 'o "M'.

Fonction simple

Cela a été testé sous BusyBox, Dash et, bien sûr, Bash:

stringContain() { [ -z "${2##*$1*}" ]; }

Alors maintenant:

$ if stringContain 'o "M3' 'echo "My String"';then echo yes;else echo no;fi
no
$ if stringContain 'o "M' 'echo "My String"';then echo yes;else echo no;fi
yes

... Ou si la chaîne soumise pouvait être vide, comme l'a souligné @Sjlver, la fonction deviendrait:

stringContain() { [ -z "${2##*$1*}" ] && [ -z "$1" -o -n "$2" ]; }

ou comme suggéré par le commentaire d'Adrian Günter , en évitant les -ochangements:

stringContain() { [ -z "${2##*$1*}" ] && { [ -z "$1" ] || [ -n "$2" ];};}

Fonction finale (simple):

Et inverser les tests pour les rendre potentiellement plus rapides:

stringContain() { [ -z "$1" ] || { [ -z "${2##*$1*}" ] && [ -n "$2" ];};}

Avec des chaînes vides:

$ if stringContain '' ''; then echo yes; else echo no; fi
yes
$ if stringContain 'o "M' ''; then echo yes; else echo no; fi
no

Indépendant du cas (Bash uniquement!)

Pour tester des chaînes sans se soucier de la casse, convertissez simplement chaque chaîne en minuscules:

stringContain() {
    local _lc=${2,,}
    [ -z "$1" ] || { [ -z "${_lc##*${1,,}*}" ] && [ -n "$2" ] ;} ;}

Vérifier:

stringContain 'o "M3' 'echo "my string"' && echo yes || echo no
no
stringContain 'o "My' 'echo "my string"' && echo yes || echo no
yes
if stringContain '' ''; then echo yes; else echo no; fi
yes
if stringContain 'o "M' ''; then echo yes; else echo no; fi
no

Vous devez vous rappeler que les scripts shell sont moins un langage et plus une collection de commandes. Instinctivement, vous pensez que ce «langage» vous oblige à suivre un ifavec un [ou un [[. Ces deux sont juste des commandes qui renvoient un état de sortie indiquant le succès ou l'échec (comme toutes les autres commandes). Pour cette raison grep, j'utiliserais , et non la [commande.

Faites juste:

if grep -q foo <<<"$string"; then
    echo "It's there"
fi

Maintenant que vous envisagez de iftester l'état de sortie de la commande qui la suit (avec point-virgule), pourquoi ne pas reconsidérer la source de la chaîne que vous testez?

## Instead of this
filetype="$(file -b "$1")"
if grep -q "tar archive" <<<"$filetype"; then
#...

## Simply do this
if file -b "$1" | grep -q "tar archive"; then
#...

L' -qoption fait que grep ne produit rien, car nous voulons seulement le code retour. <<<fait que le shell développe le mot suivant et l'utilise comme entrée de la commande, une version à une ligne du <<document ici (je ne sais pas si c'est standard ou un bashisme).

La réponse acceptée est la meilleure, mais comme il existe plusieurs façons de le faire, voici une autre solution:

if [ "$string" != "${string/foo/}" ]; then
    echo "It's there!"
fi

${var/search/replace}est $varavec la première instance de searchremplacée par replace, si elle est trouvée (elle ne change pas $var). Si vous essayez de remplacer foopar rien et que la chaîne a changé, alors, évidemment, a fooété trouvé.

Il existe donc de nombreuses solutions utiles à la question - mais laquelle est la plus rapide / utilise le moins de ressources?

Tests répétés en utilisant ce cadre:

/usr/bin/time bash -c 'a=two;b=onetwothree; x=100000; while [ $x -gt 0 ]; do TEST ; x=$(($x-1)); done'

Remplacement de TEST à chaque fois:

[[ $b =~ $a ]]           2.92 user 0.06 system 0:02.99 elapsed 99% CPU

[ "${b/$a//}" = "$b" ]   3.16 user 0.07 system 0:03.25 elapsed 99% CPU

[[ $b == *$a* ]]         1.85 user 0.04 system 0:01.90 elapsed 99% CPU

case $b in *$a):;;esac   1.80 user 0.02 system 0:01.83 elapsed 99% CPU

doContain $a $b          4.27 user 0.11 system 0:04.41 elapsed 99%CPU

(doContain était dans la réponse de F. Houri)

Et pour les rires:

echo $b|grep -q $a       12.68 user 30.86 system 3:42.40 elapsed 19% CPU !ouch!

Ainsi, l'option de substitution simple l'emporte de manière prévisible que ce soit dans un test étendu ou dans un cas. L'affaire est portable.

Prévoir 100 000 greps est douloureusement prévisible! L'ancienne règle concernant l'utilisation d'utilitaires externes sans besoin est vraie.

Cela fonctionne également:

if printf -- '%s' "$haystack" | egrep -q -- "$needle"
then
  printf "Found needle in haystack"
fi

Et le test négatif est:

if ! printf -- '%s' "$haystack" | egrep -q -- "$needle"
then
  echo "Did not find needle in haystack"
fi

Je suppose que ce style est un peu plus classique - moins dépendant des fonctionnalités du shell Bash.

L' --argument est de la pure paranoïa POSIX, utilisé pour protéger contre les chaînes d'entrée similaires aux options, telles que --abcou -a.

Remarque: Dans une boucle étroite, ce code sera beaucoup plus lent que l'utilisation des fonctionnalités internes du shell Bash, car un (ou deux) processus distincts seront créés et connectés via des tuyaux.

Exemples Bash 4+. Remarque: ne pas utiliser de guillemets entraînera des problèmes lorsque les mots contiennent des espaces, etc. Toujours citer dans Bash, IMO.

Voici quelques exemples de Bash 4+:

Exemple 1, vérifiez «oui» dans la chaîne (insensible à la casse):

    if [[ "${str,,}" == *"yes"* ]] ;then

Exemple 2, vérifiez «oui» dans la chaîne (insensible à la casse):

    if [[ "$(echo "$str" | tr '[:upper:]' '[:lower:]')" == *"yes"* ]] ;then

Exemple 3, vérifiez «oui» dans la chaîne (sensible à la casse):

     if [[ "${str}" == *"yes"* ]] ;then

Exemple 4, vérifiez «oui» dans la chaîne (sensible à la casse):

     if [[ "${str}" =~ "yes" ]] ;then

Exemple 5, correspondance exacte (sensible à la casse):

     if [[ "${str}" == "yes" ]] ;then

Exemple 6, correspondance exacte (insensible à la casse):

     if [[ "${str,,}" == "yes" ]] ;then

Exemple 7, correspondance exacte:

     if [ "$a" = "$b" ] ;then

Exemple 8, caractère générique .ext (insensible à la casse):

     if echo "$a" | egrep -iq "\.(mp[3-4]|txt|css|jpg|png)" ; then

Prendre plaisir.

Que dis-tu de ça:

text="   <tag>bmnmn</tag>  "
if [[ "$text" =~ "<tag>" ]]; then
   echo "matched"
else
   echo "not matched"
fi

Comme Paul l'a mentionné dans sa comparaison de performances:

if echo "abcdefg" | grep -q "bcdef"; then
    echo "String contains is true."
else
    echo "String contains is not true."
fi

Ceci est conforme à POSIX comme le 'case "$ string" dans' la réponse fournie par Marcus , mais il est légèrement plus facile à lire que la réponse à la déclaration de cas. Notez également que cela sera beaucoup plus lent que l'utilisation d'une déclaration de cas. Comme l'a souligné Paul, ne l'utilisez pas en boucle.

Cette réponse Stack Overflow était la seule à intercepter les caractères d'espace et de tiret:

# For null cmd arguments checking   
to_check=' -t'
space_n_dash_chars=' -'
[[ $to_check == *"$space_n_dash_chars"* ]] && echo found

[[ $string == *foo* ]] && echo "It's there" || echo "Couldn't find"

L'un est:

[ $(expr $mystring : ".*${search}.*") -ne 0 ] && echo 'yes' ||  echo 'no'

J'aime sed.

substr="foo"
nonsub="$(echo "$string" | sed "s/$substr//")"
hassub=0 ; [ "$string" != "$nonsub" ] && hassub=1

Édition, logique:

• Utilisez sed pour supprimer l'instance de sous-chaîne de la chaîne

• Si la nouvelle chaîne diffère de l'ancienne chaîne, la sous-chaîne existe

grep -q est utile à cet effet.

La même chose en utilisant awk:

string="unix-bash 2389"
character="@"
printf '%s' "$string" | awk -vc="$character" '{ if (gsub(c, "")) { print "Found" } else { print "Not Found" } }'

Production:

Pas trouvé

string="unix-bash 2389"
character="-"
printf '%s' "$string" | awk -vc="$character" '{ if (gsub(c, "")) { print "Found" } else { print "Not Found" } }'

Production:

A trouvé

Source d'origine: http://unstableme.blogspot.com/2008/06/bash-search-letter-in-string-awk.html

J'ai constaté que j'avais besoin de cette fonctionnalité assez fréquemment, donc j'utilise une fonction shell faite maison dans mon .bashrccomme celle-ci qui me permet de la réutiliser aussi souvent que nécessaire, avec un nom facile à retenir:

function stringinstring()
{
    case "$2" in
       *"$1"*)
          return 0
       ;;
    esac
    return 1
}

Pour tester si $string1(par exemple, abc ) est contenu dans $string2(par exemple, 123abcABC ), il me suffit d'exécuter stringinstring "$string1" "$string2"et de vérifier la valeur de retour, par exemple

stringinstring "$str1" "$str2"  &&  echo YES  ||  echo NO

Mon .bash_profile fichier et comment j'ai utilisé grep:

Si la variable d'environnement PATH inclut mes deux binrépertoires, ne les ajoutez pas,

# .bash_profile
# Get the aliases and functions
if [ -f ~/.bashrc ]; then
    . ~/.bashrc
fi

U=~/.local.bin:~/bin

if ! echo "$PATH" | grep -q "home"; then
    export PATH=$PATH:${U}
fi

Extension de la question répondue ici Comment savoir si une chaîne contient une autre chaîne dans POSIX sh? :

Cette solution fonctionne avec des caractères spéciaux:

# contains(string, substring)
#
# Returns 0 if the specified string contains the specified substring,
# otherwise returns 1.
contains() {
    string="$1"
    substring="$2"

    if echo "$string" | $(type -p ggrep grep | head -1) -F -- "$substring" >/dev/null; then
        return 0    # $substring is in $string
    else
        return 1    # $substring is not in $string
    fi
}

contains "abcd" "e" || echo "abcd does not contain e"
contains "abcd" "ab" && echo "abcd contains ab"
contains "abcd" "bc" && echo "abcd contains bc"
contains "abcd" "cd" && echo "abcd contains cd"
contains "abcd" "abcd" && echo "abcd contains abcd"
contains "" "" && echo "empty string contains empty string"
contains "a" "" && echo "a contains empty string"
contains "" "a" || echo "empty string does not contain a"
contains "abcd efgh" "cd ef" && echo "abcd efgh contains cd ef"
contains "abcd efgh" " " && echo "abcd efgh contains a space"

contains "abcd [efg] hij" "[efg]" && echo "abcd [efg] hij contains [efg]"
contains "abcd [efg] hij" "[effg]" || echo "abcd [efg] hij does not contain [effg]"

contains "abcd *efg* hij" "*efg*" && echo "abcd *efg* hij contains *efg*"
contains "abcd *efg* hij" "d *efg* h" && echo "abcd *efg* hij contains d *efg* h"
contains "abcd *efg* hij" "*effg*" || echo "abcd *efg* hij does not contain *effg*"

Étant donné que la question POSIX / BusyBox est fermée sans fournir la bonne réponse (IMHO), je posterai une réponse ici.

La réponse la plus courte possible est:

[ ${_string_##*$_substring_*} ] || echo Substring found!

ou

[ "${_string_##*$_substring_*}" ] || echo 'Substring found!'

Notez que le double hachage est obligatoire avec certains shells (ash). Ci-dessus évaluera[ stringvalue ]quand la sous-chaîne n'est pas trouvée. Il ne renvoie aucune erreur. Lorsque la sous-chaîne est trouvée, le résultat est vide et il est évalué[ ]. Cela générera le code d'erreur 1 car la chaîne est complètement remplacée (en raison de*).

La syntaxe la plus courte et la plus courante:

[ -z "${_string_##*$_substring_*}" ] && echo 'Substring found!'

ou

[ -n "${_string_##*$_substring_*}" ] || echo 'Substring found!'

Un autre:

[ "${_string_##$_substring_}" != "$_string_" ] && echo 'Substring found!'

ou

[ "${_string_##$_substring_}" = "$_string_" ] || echo 'Substring found!'

Notez le seul signe égal!

Correspondance exacte des mots:

string='My long string'
exactSearch='long'

if grep -E -q "\b${exactSearch}\b" <<<${string} >/dev/null 2>&1
  then
    echo "It's there"
  fi

Essayez oobash.

Il s'agit d'une bibliothèque de chaînes de style OO pour Bash 4. Elle prend en charge les trémas allemands. Il est écrit en Bash.

De nombreuses fonctions sont disponibles: -base64Decode, -base64Encode, -capitalize, -center, -charAt, -concat, -contains, -count, -endsWith, -equals, -equalsIgnoreCase, -reverse, -hashCode, -indexOf, -isAlnum, -isAlpha, -isAscii, -isDigit, -isEmpty, -isHexDigit, -isLowerCase, -isSpace, -isPrintable, -isUpperCase, -isVisible, -lastIndexOf, -length, -matches, -replaceAll, -replaceFirst, -startsWith, -substring, -swapCase, -toLowerCase, -toString, -toUpperCase, -trimet-zfill .

Regardez l' exemple contient :

[Desktop]$ String a testXccc
[Desktop]$ a.contains tX
true
[Desktop]$ a.contains XtX
false

oobash est disponible sur Sourceforge.net .

J'utilise cette fonction (une dépendance non incluse mais évidente). Il passe les tests ci-dessous. Si la fonction renvoie une valeur> 0, la chaîne a été trouvée. Vous pouvez tout aussi bien retourner 1 ou 0 à la place.

function str_instr {
   # Return position of ```str``` within ```string```.
   # >>> str_instr "str" "string"
   # str: String to search for.
   # string: String to search.
   typeset str string x
   # Behavior here is not the same in bash vs ksh unless we escape special characters.
   str="$(str_escape_special_characters "${1}")"
   string="${2}"
   x="${string%%$str*}"
   if [[ "${x}" != "${string}" ]]; then
      echo "${#x} + 1" | bc -l
   else
      echo 0
   fi
}

function test_str_instr {
   str_instr "(" "'foo@host (dev,web)'" | assert_eq 11
   str_instr ")" "'foo@host (dev,web)'" | assert_eq 19
   str_instr "[" "'foo@host [dev,web]'" | assert_eq 11
   str_instr "]" "'foo@host [dev,web]'" | assert_eq 19
   str_instr "a" "abc" | assert_eq 1
   str_instr "z" "abc" | assert_eq 0
   str_instr "Eggs" "Green Eggs And Ham" | assert_eq 7
   str_instr "a" "" | assert_eq 0
   str_instr "" "" | assert_eq 0
   str_instr " " "Green Eggs" | assert_eq 6
   str_instr " " " Green "  | assert_eq 1
}

case $string in (*foo*)
  # Do stuff
esac

Il s'agit de la même réponse que https://stackoverflow.com/a/229585/11267590 . Mais un style simple et également compatible POSIX.

msg="message"

function check {
    echo $msg | egrep [abc] 1> /dev/null

    if [ $? -ne 1 ];
    then 
        echo "found" 
    else 
        echo "not found" 
    fi
}

check

Cela trouvera toute occurrence de a ou b ou c

L' exemple générique de meule de foin à aiguilles suit avec des variables

#!/bin/bash

needle="a_needle"
haystack="a_needle another_needle a_third_needle"
if [[ $haystack == *"$needle"* ]]; then
    echo "needle found"
else
    echo "needle NOT found"
fi