Prüfen, ob eine Zeichenkette eine Teilzeichenkette in Bash enthält

Question

Ich habe eine Zeichenfolge in Bash:

string="My string"

Wie kann ich prüfen, ob sie eine andere Zeichenfolge enthält?

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

Wo ?? ist mein unbekannter Operator. Verwende ich echo y grep ?

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

Das sieht ein bisschen unbeholfen aus.

Answer 1

Sie können verwenden Marcus' Antwort (* Wildcards) auch außerhalb einer Case-Anweisung, 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 needle-Zeichenkette zwischen Anführungszeichen gesetzt werden müssen, und die * Wildcards sollten draußen sein. Beachten Sie auch, dass ein einfacher Vergleichsoperator verwendet wird (d. h. == ), nicht der Regex-Operator =~ .

Answer 2

Wenn Sie die Regex-Methode bevorzugen:

string='My string';

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

Answer 3

Ich bin mir bei der Verwendung einer if-Anweisung nicht sicher, aber Sie können einen ähnlichen Effekt mit einer case-Anweisung erzielen:

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

Answer 4

stringContain Varianten (kompatibel oder fallunabhängig)

In diesen Stack Overflow-Antworten wird hauptsächlich über Bash habe ich eine Fall unabhängig Bash-Funktion ganz unten in diesem Beitrag...

Wie auch immer, hier ist mein

Kompatible Antwort

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

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

In der Praxis könnte sich dies 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 getestet, Gedankenstrich , KornShell ( ksh ) und Asche (BusyBox), 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 einer Funktion

Wie von @EeroAaltonen gewünscht, ist hier eine Version der gleichen Demo, getestet unter den gleichen 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
}

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: müssen Sie Anführungszeichen und/oder doppelte Anführungszeichen auslassen 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 Zeichenkette leer sein könnte, wie von @Sjlver hervorgehoben, würde die Funktion werden:

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

oder wie vorgeschlagen von Kommentar von Adrian Günter und vermeidet -o Schalter:

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

Letzte (einfache) Funktion:

Und die Umkehrung der Prüfungen, um sie möglicherweise schneller zu machen:

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

Mit leeren Saiten:

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

Fallunabhängig (nur Bash!)

Zum Testen von Zeichenketten ohne Berücksichtigung der Groß- und Kleinschreibung konvertieren Sie einfach jede Zeichenkette 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

Answer 5

Sie sollten bedenken, dass es sich bei Shell-Skripten weniger um eine Sprache als vielmehr um eine Sammlung von Befehlen handelt. Instinktiv denken Sie, dass diese "Sprache" von Ihnen verlangt, eine if mit einer [ oder eine [[ . 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 grep und nicht die [ Befehl.

Tun Sie es einfach:

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

Jetzt, wo Sie daran denken if als Test für den Exit-Status des darauf folgenden Befehls (mit Semikolon) zu verwenden, sollten Sie die Quelle der zu testenden Zeichenfolge überdenken.

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

El -q bewirkt, dass grep nichts ausgibt, da wir nur den Rückgabewert haben wollen. <<< bewirkt, dass die Shell das nächste Wort expandiert und als Eingabe für den Befehl verwendet, eine einzeilige Version des Befehls << hier dokumentieren (ich bin mir nicht sicher, ob dies ein Standard oder ein Bashismus ist).