Bash bir dize var:

string="My string"

Başka bir dize içerip içermediğini nasıl test edebilirim?

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

??Bilinmeyen operatörüm nerede . Yankı ve grepmı kullanırım ?

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

Biraz sakar görünüyor.

Çift parantez kullanıyorsanız Marcus yanıtını (* joker karakterlerini) bir vaka ifadesinin dışında da kullanabilirsiniz:

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

İğne dizesindeki boşlukların çift tırnak arasına *alınması ve joker karakterlerin dışarıda olması gerektiğini unutmayın. Ayrıca ==regex operatörünün değil, basit bir karşılaştırma operatörünün kullanıldığını (yani ) unutmayın =~.

Normal ifade yaklaşımını tercih ediyorsanız:

string='My string';

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

Bir if ifadesi kullanma konusunda emin değilim, ancak bir case ifadesiyle benzer bir etki elde edebilirsiniz:

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

stringContain varyantlar (uyumlu veya büyük / küçük harf bağımsız)

Bu Stack Overflow cevapları çoğunlukla Bash hakkında söylediği gibi, bu yazının en altında bir vakadan bağımsız Bash işlevi yayınladım ...

Her neyse, işte benim

Uyumlu cevap

Bash'e özgü özellikleri kullanan birçok yanıt olduğundan, BusyBox gibi daha kötü özellikli kabuklarda çalışmanın bir yolu var :

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

Uygulamada, bu aşağıdakileri verebilir:

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

Bu Bash, Dash , KornShell ( ksh) ve ash (BusyBox) ve sonuç her zaman:

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

Bir işleve

@EeroAaltonen tarafından sorulduğu gibi, aynı demonun aynı kabuklar altında test edilmiş bir versiyonu:

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
}

Sonra:

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

Farkına varmak: Tırnaklardan ve / veya çift tırnaklardan kaçmak veya çift tırnak içine almak zorundasınız:

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

Basit fonksiyon

Bu BusyBox, Dash ve elbette Bash altında test edildi:

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

Öyleyse şimdi:

$ 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

... Veya gönderilen dize @Sjlver tarafından belirtildiği gibi boş olsaydı, işlev şöyle olur:

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

ya da Adrian Günter'in yorumunda önerildiği gibi , -oanahtarlardan kaçınarak :

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

Son (basit) fonksiyon:

Ve potansiyel olarak daha hızlı hale getirmek için testleri tersine çevirmek:

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

Boş dizelerle:

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

Büyük / küçük harf bağımsız (yalnızca Bash!)

Dizeleri büyük / küçük harf olmadan test etmek için, her dizeyi küçük harfe dönüştürmeniz yeterlidir:

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

Kontrol:

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

Kabuk betiklemenin bir dilden daha az ve daha çok komutlar topluluğu olduğunu hatırlamanız gerekir. İçgüdüsel olarak, bu "dil" ifin a [veya a ile takip etmenizi gerektirdiğini düşünüyorsunuz [[. Her ikisi de sadece başarı veya başarısızlık gösteren bir çıkış durumu döndüren komutlardır (diğer tüm komutlarda olduğu gibi). Bu nedenle grep,[ komuta.

Sadece yap:

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

Şimdi ifonu izleyen komutun çıkış durumunu (yarı kolon ile tamamlanmış) test etmeyi düşündüğünüze göre , neden test ettiğiniz dizenin kaynağını yeniden düşünmüyorsunuz?

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

Bu -qseçenek, yalnızca dönüş kodunu istediğimizden, grep'in hiçbir şey çıkarmamasını sağlar. <<<Kabuğun bir sonraki sözcüğü genişletmesini ve komutun girdisi olarak kullanmasını sağlar, <<burada belgenin tek satırlık bir sürümü (bunun standart mı yoksa Bashizm mi olduğundan emin değilim).

Kabul edilen cevap en iyisidir, ancak bunu yapmanın birden fazla yolu olduğundan, işte başka bir çözüm:

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

${var/search/replace}olduğu $varilk örneği ile searchyerine replaceo bulunursa, (o değişmez $var). fooHiçbir şeyle değiştirmeyi denerseniz ve dize değiştiyse, açıkçası foobulundu.

Yani soruya birçok yararlı çözüm var - ama hangisi en hızlı / en az kaynağı kullanıyor?

Bu çerçeveyi kullanarak tekrarlanan testler:

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

Her seferinde TEST'in değiştirilmesi:

[[ $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 F. Houri'nin cevabındaydı)

Ve kıkırdamalar için:

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

Böylece basit ikame seçeneği, genişletilmiş bir testte veya bir vakada tahmin edilebilir şekilde kazanır. Kasa taşınabilir.

100000 açığa çıkan boruları tahmin etmek acı verici! Harici yardımcı programların ihtiyaç duyulmadan kullanılmasına ilişkin eski kural geçerlidir.

Bu ayrıca işe yarar:

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

Ve negatif test:

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

Bu tarzın biraz daha klasik olduğunu düşünüyorum - Bash kabuğunun özelliklerine daha az bağımlı.

--Argüman gibi seçenekler, benzer girdi dizeleri karşı korunan kullanılan saf POSIX paranoya vardır --abcya -a.

Not: Sıkı bir döngüde, bu kod dahili Bash kabuğu özelliklerini kullanmaktan çok daha yavaş olacaktır , çünkü borularla bir (veya iki) ayrı işlem oluşturulacak ve bağlanacaktır.

Bash 4+ örnekleri. Not: tırnak işareti kullanılmaması kelimeler boşluk vb. İçerdiğinde sorunlara neden olur. Her zaman Bash, IMO'da alıntı yapın.

İşte bazı örnekler Bash 4+:

Örnek 1, dizede 'evet' olup olmadığını kontrol edin (büyük / küçük harf duyarsız):

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

Örnek 2, dizede 'evet' olup olmadığını kontrol edin (büyük / küçük harf duyarsız):

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

Örnek 3, dizede 'evet' olup olmadığını kontrol edin (büyük / küçük harfe duyarlı):

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

Örnek 4, dizede 'evet' olup olmadığını kontrol edin (büyük / küçük harfe duyarlı):

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

Örnek 5, tam eşleme (büyük / küçük harfe duyarlı):

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

Örnek 6, tam eşleme (büyük / küçük harf duyarlı):

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

Örnek 7, tam eşleme:

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

Örnek 8, joker karakter eşleşmesi .ext (büyük / küçük harf duyarlı):

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

Zevk almak.

Buna ne dersin:

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

As Paul söz onun performansı karşılaştırıldığında:

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

Bu, Marcus tarafından verilen cevaptaki 'case "$ string" gibi POSIX uyumludur , ancak vaka bildirimi yanıtından okumak biraz daha kolaydır. Bunun bir vaka ifadesi kullanmaktan çok daha yavaş olacağını da unutmayın. Paul'un işaret ettiği gibi, onu bir döngü içinde kullanmayın.

Bu Yığın Taşması yanıtı , boşluk ve tire karakterlerini yakalayan tek yanıttı :

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

Biri:

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

Sed'i severim.

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

Düzenle, Mantık:

• Dizeden alt dize örneğini kaldırmak için sed kullanın

• Yeni dize eski dizeden farklıysa, alt dize vardır

grep -q bu amaç için yararlıdır.

Aynı kullanarak awk:

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

Çıktı:

Bulunamadı

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

Çıktı:

Bulundu

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

Bu işlevselliğe oldukça sık ihtiyacım var, bu yüzden evimde bir kabuk işlevi kullanıyorum, bu .bashrcşekilde hatırlamam kolay bir adla ihtiyacım olduğu kadar sık ​​kullanmamı sağlıyor:

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

Test için eğer $string1(diyelim, abc ) bulunan $string2(mesela 123abcABC Sadece çalıştırmak gerekir) stringinstring "$string1" "$string2", örneğin ve dönüş değeri denetlemek

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

Benim .bash_profile dosyası ve ben grep nasıl kullandığını:

PATH ortam değişkeni iki bindizinimi içeriyorsa , onları eklemeyin,

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

Yanıtlanan sorunun uzantısı burada bir dizenin POSIX sh içinde başka bir dize olup olmadığını nasıl anlarsınız? :

Bu çözüm özel karakterlerle çalışır:

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

Yana POSIX / BusyBox soru doğru cevabı (IMHO) sağlamadan kapalıdır, burada bir yanıt göndeririz.

Mümkün olan en kısa cevap:

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

veya

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

Not çift karma olan zorunlu bazı kabuklu ( ash). Yukarıdaki [ stringvalue ], alt dize bulunmadığında değerlendirilecektir . Hiçbir hata döndürmez. Alt dize bulunduğunda sonuç boştur ve değerlendirir [ ]. Bu, dize tamamen değiştirildiği için hata kodu 1'i atar (nedeniyle* ) .

En kısa ve daha yaygın sözdizimi:

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

veya

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

Bir diğeri:

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

veya

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

Tek eşit işareti not edin !

Tam kelime eşleme:

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

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

Oobash'ı deneyin.

Bash 4 için OO tarzı bir dize kitaplığıdır. Bash ile yazılmıştır.

Birçok fonksiyonları mevcuttur: -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, ve -zfill.

Bak içeren örnek:

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

oobash Sourceforge.net adresinde mevcuttur .

Bu işlevi kullanıyorum (bir bağımlılık dahil değil açıktır). Aşağıda gösterilen testleri geçer. İşlev> 0 değerini döndürürse, dize bulundu. Bunun yerine kolayca 1 veya 0 döndürebilirsiniz.

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

Bu, https://stackoverflow.com/a/229585/11267590 ile aynı cevaptır . Ama basit stil ve ayrıca POSIX Uyumlu.

msg="message"

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

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

check

Bu a veya b veya c

Genel iğne samanlığı örneği değişkenlerle birlikte verilmektedir

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