Wie überprüft man, ob ein String in Bash einen Teilstring enthält?

Wenn Sie lieber die regex-Ansatz:

string='My string';

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

InformationsquelleAutor der Antwort Matt Tardiff

Kompatibel beantworten

Da gibt es schon eine Menge Antworten mit Bash-spezifische Funktionen, es ist ein Weg, arbeiten unter schlechteren Funktionsumfang Muscheln, wie busybox:

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

In der Praxis geben könnte:

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

Getestet wurde dies unter bashBindestrichksh und ash (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

Als gefragt von @EeroAaltonen hier ist eine version der gleichen demo, getestet unter den gleichen Schalen:

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 haben zu entkommen oder doppelte Anführungszeichen einschließen und/oder doppelten Anführungszeichen:

$ 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

Getestet wurde dies unter busyboxBindestrich und natürlich bash:

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

That ' s all folks!

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 eingereichten string kann leer sein, wie bereits von @Sjlver, die Funktion würde:

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

oder wie vorgeschlagen von Adrian Günter Kommentardie Vermeidung -o switche:

stringContain() { [ -z "${2##*$1*}" ] && { [ -z "$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

InformationsquelleAutor der Antwort F. Hauri

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

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

${var/search/replace} ist $var mit der ersten Instanz von search ersetzt durch replacewenn es gefunden wird (es ändert sich nicht $var). Wenn Sie versuchen, zu ersetzen foo von nichts, und der string geändert hat, dann offensichtlich foo gefunden wurde.

InformationsquelleAutor der Antwort ephemient

Funktioniert das 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 ein bisschen mehr classic -- weniger abhängig von den features der Bash-shell.

Den -- argument ist Reine POSIX-paranoia, verwendet, um Schutz gegen Eingabe-strings, ähnlich wie Optionen, wie --abc oder -a.

Hinweis: In einer engen Schleife mit diesem code wird viel langsamer als mit der internen Bash-shell-Funktionen, wie eine (oder zwei) separate Prozesse erzeugt und verbunden durch Rohre.

InformationsquelleAutor der Antwort kevinarpe

Dieser Stack Overflow Antwort war der einzige, der trap-Raum und Strich chars:

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

InformationsquelleAutor der Antwort Yordan Georgiev

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

InformationsquelleAutor der Antwort Jahid

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

Dasselbe 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

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

InformationsquelleAutor der Antwort

Meine .bash_profile und wie ich grep verwendet
wenn der PFAD inklusive meiner 2 bin dirs nicht, fügen Sie diese

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

InformationsquelleAutor der Antwort Leslie Satenstein

Versuchen oobash es ist ein OO-Stil string-Bibliothek für die bash-4. Es hat Unterstützung für Deutsche Umlaute. Es ist geschrieben in bash. 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-trimund -zfill.

Blick auf die enthält Beispiel:

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

oobash ist erhältlich bei Sourceforge.net.

InformationsquelleAutor der Antwort andreas

Ich diese Funktion (eine Abhängigkeit, die nicht im Lieferumfang enthalten, aber offensichtlich). Besteht er die tests unten gezeigt. Wenn die Funktion einen Wert > 0, dann ist der string gefunden wurde. Sie könnten genauso einfach wieder 1 oder 0 statt.

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
}

InformationsquelleAutor der Antwort Ethan Post