Ich habe eine Zeichenfolge in Bash:

string="My string"

Wie kann ich testen, ob es eine andere Zeichenfolge enthält?

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

Wo ??ist mein unbekannter Betreiber? Benutze ich echo und grep?

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

Das sieht etwas ungeschickt aus.

Sie können die Antwort von Marcus (* Platzhalter) auch außerhalb einer case-Anweisung verwenden, wenn Sie doppelte Klammern verwenden:

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

Beachten Sie, dass Leerzeichen in der Nadelkette zwischen doppelten Anführungszeichen stehen müssen und die *Platzhalter außerhalb liegen sollten. Beachten Sie auch, dass ein einfacher Vergleichsoperator verwendet wird (dh ==), nicht der Regex-Operator =~.

Wenn Sie den Regex-Ansatz bevorzugen:

string='My string';

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

Ich bin mir nicht sicher, ob ich eine if-Anweisung verwenden soll, aber Sie können mit einer case-Anweisung einen ähnlichen Effekt erzielen:

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

stringContain Varianten (kompatibel oder fallunabhängig)

Da diese Stack Overflow-Antworten hauptsächlich über Bash berichten , habe ich ganz unten in diesem Beitrag eine fallunabhängige Bash-Funktion veröffentlicht ...

Wie auch immer, da ist meine

Kompatible Antwort

Da es bereits viele Antworten gibt, die Bash-spezifische Funktionen verwenden, gibt es eine Möglichkeit, unter Shells mit schlechteren Funktionen wie BusyBox zu arbeiten :

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

In der Praxis könnte dies Folgendes ergeben:

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

Dies wurde unter Bash, Dash , KornShell ( ksh) und ash (BusyBox) getestet und das Ergebnis ist immer:

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

In eine Funktion

Wie von @EeroAaltonen gefragt, ist hier eine Version derselben Demo, die unter denselben Shells getestet wurde:

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
}

Dann:

$ 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'.

Hinweis: Sie müssen Anführungszeichen und / oder doppelte Anführungszeichen maskieren oder doppelt einschließen:

$ 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'.

Einfache Funktion

Dies wurde unter BusyBox, Dash und natürlich Bash getestet:

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

Dann jetzt:

$ 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

... Oder wenn die übermittelte Zeichenfolge leer sein könnte, wie von @Sjlver hervorgehoben, würde die Funktion wie folgt lauten:

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

oder wie in Adrian Günters Kommentar vorgeschlagen , um -oSchalter zu vermeiden :

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

Letzte (einfache) Funktion:

Und die Tests umkehren, um sie möglicherweise schneller zu machen:

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

Mit leeren Zeichenfolgen:

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

Groß- und Kleinschreibung unabhängig (nur Bash!)

Um Zeichenfolgen ohne Berücksichtigung der Groß- und Kleinschreibung zu testen, konvertieren Sie einfach jede Zeichenfolge in Kleinbuchstaben:

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

Prüfen:

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

Sie sollten sich daran erinnern, dass Shell-Skripte weniger eine Sprache als eine Sammlung von Befehlen sind. Instinktiv denken Sie, dass diese "Sprache" erfordert, dass Sie einem ifmit einem [oder einem folgen [[. Beides sind nur Befehle, die einen Exit-Status zurückgeben, der Erfolg oder Misserfolg anzeigt (genau wie jeder andere Befehl). Aus diesem Grund würde ich verwenden grepund nicht den [Befehl.

Mach einfach:

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

Nachdem Sie nun ifden Exit-Status des darauf folgenden Befehls (einschließlich Semikolon) testen möchten, sollten Sie die Quelle der zu testenden Zeichenfolge erneut überprüfen.

## 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
#...

Die -qOption bewirkt, dass grep nichts ausgibt, da wir nur den Rückkehrcode wollen. <<<Lässt die Shell das nächste Wort erweitern und es als Eingabe für den Befehl verwenden, eine einzeilige Version des <<hier gezeigten Dokuments (ich bin nicht sicher, ob dies Standard oder ein Bashismus ist).

Die akzeptierte Antwort ist am besten, aber da es mehr als einen Weg gibt, ist hier eine andere Lösung:

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

${var/search/replace}wird $varmit der ersten Instanz von searchersetzt durch replace, wenn es gefunden wird (es ändert sich nicht $var). Wenn Sie versuchen, foodurch nichts zu ersetzen , und sich die Zeichenfolge geändert hat, wurde offensichtlich foogefunden.

Es gibt also viele nützliche Lösungen für die Frage - aber welche ist am schnellsten / verbraucht die wenigsten Ressourcen?

Wiederholte Tests mit diesem Rahmen:

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

TEST jedes Mal ersetzen:

[[ $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 war in der Antwort von F. Houri)

Und zum Kichern:

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

Die einfache Substitutionsoption gewinnt also vorhersehbar, ob in einem erweiterten Test oder in einem Fall. Der Fall ist tragbar.

Das Auspfeifen auf 100000 Greps ist vorhersehbar schmerzhaft! Die alte Regel über die Verwendung externer Dienstprogramme ohne Notwendigkeit gilt.

Dies funktioniert auch:

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

Und der negative Test ist:

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

Ich nehme an, dieser Stil ist etwas klassischer - weniger abhängig von den Merkmalen der Bash-Shell.

Das --Argument ist reine POSIX-Paranoia, die zum Schutz vor Eingabezeichenfolgen verwendet wird, die Optionen wie --abcoder ähneln -a.

Hinweis: In einer engen Schleife ist dieser Code viel langsamer als die Verwendung interner Bash-Shell-Funktionen, da ein (oder zwei) separate Prozesse erstellt und über Pipes verbunden werden.

Bash 4+ Beispiele. Hinweis: Wenn Sie keine Anführungszeichen verwenden, treten Probleme auf, wenn Wörter Leerzeichen usw. enthalten. Zitieren Sie immer in Bash, IMO.

Hier sind einige Beispiele für Bash 4+:

Beispiel 1: Überprüfen Sie die Zeichenfolge auf "Ja" (Groß- und Kleinschreibung wird nicht berücksichtigt):

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

Beispiel 2: Überprüfen Sie die Zeichenfolge auf "Ja" (Groß- und Kleinschreibung wird nicht berücksichtigt):

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

Beispiel 3: Überprüfen Sie die Zeichenfolge auf "Ja" (Groß- und Kleinschreibung beachten):

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

Beispiel 4: Überprüfen Sie die Zeichenfolge auf "Ja" (Groß- und Kleinschreibung beachten):

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

Beispiel 5, genaue Übereinstimmung (Groß- und Kleinschreibung beachten):

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

Beispiel 6, genaue Übereinstimmung (ohne Berücksichtigung der Groß- und Kleinschreibung):

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

Beispiel 7, genaue Übereinstimmung:

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

Beispiel 8, Platzhalterübereinstimmung .ext (Groß- und Kleinschreibung wird nicht berücksichtigt):

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

Genießen.

Wie wäre es damit:

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

Wie Paulus erwähnte in seinem Leistungsvergleich :

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

Dies ist POSIX-konform wie der 'case "$ string" in' der Antwort von Marcus , aber es ist etwas einfacher zu lesen als die Antwort auf die case-Anweisung. Beachten Sie auch, dass dies viel langsamer ist als die Verwendung einer case-Anweisung. Wie Paul betonte, verwenden Sie es nicht in einer Schleife.

Diese Stapelüberlauf-Antwort war die einzige, die Leerzeichen abfing und Zeichen strich:

# 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"

Eines ist:

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

Ich mag sed.

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

Bearbeiten, Logik:

• Verwenden Sie sed, um die Instanz des Teilstrings aus dem String zu entfernen

• Wenn sich die neue Zeichenfolge von der alten unterscheidet, ist eine Teilzeichenfolge vorhanden

grep -q ist für diesen Zweck nützlich.

Das gleiche mit awk:

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

Ausgabe:

Nicht gefunden

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

Ausgabe:

Gefunden

Ursprüngliche Quelle: http://unstableme.blogspot.com/2008/06/bash-search-letter-in-string-awk.html

Ich habe festgestellt, dass ich diese Funktionalität ziemlich häufig benötige, daher verwende ich eine hausgemachte Shell-Funktion .bashrcwie diese, mit der ich sie so oft wie nötig wiederverwenden kann, mit einem leicht zu merkenden Namen:

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

Um zu testen, ob $string1(z. B. abc ) in $string2(z. B. 123abcABC ) enthalten ist , muss ich beispielsweise nur ausführen stringinstring "$string1" "$string2"und nach dem Rückgabewert suchen

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

Meine .bash_profile- Datei und wie ich grep verwendet habe:

Wenn die Umgebungsvariable PATH meine beiden binVerzeichnisse enthält, hängen Sie sie nicht an.

# .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

Erweiterung der hier beantworteten Frage Wie können Sie feststellen, ob eine Zeichenfolge eine andere Zeichenfolge in POSIX sh enthält? ::

Diese Lösung funktioniert mit Sonderzeichen:

# 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*"

Da die POSIX / BusyBox-Frage geschlossen ist, ohne die richtige Antwort zu geben (IMHO), werde ich hier eine Antwort veröffentlichen.

Die kürzest mögliche Antwort lautet:

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

oder

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

Beachten Sie, dass der doppelte Hash bei einigen Shells obligatorisch ist ( ash). Oben wird ausgewertet, [ stringvalue ]wenn der Teilstring nicht gefunden wird. Es wird kein Fehler zurückgegeben. Wenn der Teilstring gefunden wird, ist das Ergebnis leer und wird ausgewertet [ ]. Dies löst den Fehlercode 1 aus, da die Zeichenfolge vollständig ersetzt wird (aufgrund von* ) .

Die kürzeste häufigere Syntax:

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

oder

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

Noch einer:

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

oder

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

Beachten Sie das einzelne Gleichheitszeichen!

Genaue Wortübereinstimmung:

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

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

Versuchen Sie es mit Oobash.

Es ist eine String-Bibliothek im OO-Stil für Bash 4. Sie unterstützt deutsche Umlaute. Es ist in Bash geschrieben.

Viele Funktionen stehen zur Verfügung: -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 , -trim, und -zfill.

Schauen Sie sich das enthält Beispiel:

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

oobash ist auf Sourceforge.net verfügbar .

Ich benutze diese Funktion (eine Abhängigkeit nicht enthalten, aber offensichtlich). Es besteht die unten gezeigten Tests. Wenn die Funktion einen Wert> 0 zurückgibt, wurde die Zeichenfolge gefunden. Sie können stattdessen genauso gut 1 oder 0 zurückgeben.

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

Dies ist die gleiche Antwort wie https://stackoverflow.com/a/229585/11267590 . Aber einfacher Stil und auch POSIX-konform.

msg="message"

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

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

check

Dies wird jedes Auftreten von a oder b oder c finden

Das generische Nadelheuhaufen- Beispiel folgt mit Variablen

#!/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