මට Bash හි නූලක් ඇත:

string="My string"

එහි වෙනත් නූලක් තිබේදැයි පරීක්ෂා කරන්නේ කෙසේද?

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

??මගේ නොදන්නා ක්‍රියාකරු කොහෙද? මම echo භාවිතා grepකරනවාද?

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

ඒක ටිකක් අවුල් සහගතයි.

ඔබ ද්විත්ව වරහන් භාවිතා කරන්නේ නම්, ඔබට සිද්ධි ප්‍රකාශයකින් පිටත මාකස්ගේ පිළිතුර (* ආදේශක කාඩ්පත්) භාවිතා කළ හැකිය :

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

ඉඳිකටු නූල් වල අවකාශයන් ද්විත්ව මිල ගණන් අතර තැබිය *යුතු බවත්, ආදේශක කාඩ්පත් පිටත තිබිය යුතු බවත් සලකන්න. සරල සංසන්දනාත්මක ක්‍රියාකරුවෙකු භාවිතා කරන බව සලකන්න (එනම් ==) රීජෙක්ස් ක්‍රියාකරු නොවේ =~.

ඔබ රීජෙක්ස් ප්‍රවේශයට කැමති නම්:

string='My string';

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

If ප්‍රකාශයක් භාවිතා කිරීම ගැන මට විශ්වාස නැත, නමුත් ඔබට සිද්ධි ප්‍රකාශයක් සමඟ සමාන බලපෑමක් ලබා ගත හැකිය:

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

stringContain ප්‍රභේද (අනුකූල හෝ සිද්ධි ස්වාධීන)

මෙම සිරස් පිටාර ගැලීම් පිළිතුරු බොහෝ දුරට බාෂ් ගැන පවසන පරිදි , මම මෙම පෝස්ට් එකේ පතුලේම ස්වාධීන බාෂ් ශ්‍රිතයක් පළ කර ඇත්තෙමි ...

කෙසේ හෝ වේවා, මගේ ය

අනුකූල පිළිතුර

Bash- විශේෂිත විශේෂාංග භාවිතා කරමින් දැනටමත් පිළිතුරු රාශියක් ඇති හෙයින්, BusyBox වැනි දුප්පත් විශේෂාංග සහිත ෂෙල් වෙඩි යටතේ වැඩ කිරීමේ ක්‍රමයක් තිබේ :

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

ප්රායෝගිකව, මෙය ලබා දිය හැකිය:

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

මෙය Bash, Dash , KornShell ( ksh) සහ අළු (BusyBox) යටතේ පරීක්ෂා කරන ලද අතර ප්‍රති result ලය සැමවිටම:

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

එක් ශ්‍රිතයකට

@EeroAaltonen විසින් ඇසූ පරිදි මෙහි එකම නිරූපණයේ අනුවාදයක් ඇත, එකම ෂෙල් වෙඩි යටතේ පරීක්ෂා කර ඇත:

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
}

ඉන්පසු:

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

දැනුම්දීම: ඔබට පැන යා යුතුය හෝ ද්විත්ව කොටු කිරීම් සහ / හෝ ද්විත්ව උපුටා දැක්වීම් කළ යුතුය:

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

සරල කාර්යය

මෙය කාර්යබහුල බොක්ස්, ඩෑෂ් සහ, ඇත්ත වශයෙන්ම බාෂ් යටතේ පරීක්ෂා කරන ලදී:

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

එසේනම් දැන්:

$ 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

JSjlver විසින් පෙන්වා දී ඇති පරිදි ඉදිරිපත් කරන ලද නූල හිස් විය හැකි නම්, ශ්‍රිතය මෙසේ වනු ඇත:

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

හෝ ඒඩ්‍රියන් ගුන්ටර්ගේ අදහස අනුව -oස්විචයන් වළක්වා ගැනීම :

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

අවසාන (සරල) ශ්‍රිතය:

පරීක්ෂණ ඉක්මන් කිරීමට හැකි වන පරිදි ප්‍රතිලෝම කිරීම:

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

හිස් නූල් සමඟ:

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

නඩුව ස්වාධීනයි (Bash only!)

නඩුවකින් තොරව නූල් පරීක්ෂා කිරීම සඳහා, එක් එක් නූල් කුඩා අකුරට හරවන්න:

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

චෙක් පත:

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

ෂෙල් ස්ක්‍රිප්ටින් භාෂාවට වඩා අඩු සහ විධාන එකතුවක් බව ඔබ මතක තබා ගත යුතුය. සහජයෙන්ම ඔබ සිතන්නේ මෙම “භාෂාව” ඔබට ifa [හෝ a සමඟ අනුගමනය කළ යුතු බවයි [[. මේ දෙකම සාර්ථකත්වය හෝ අසාර්ථකත්වය පෙන්නුම් කරන පිටවීමේ තත්වයක් ලබා දෙන විධානයන් පමණි (අනෙක් සෑම විධානයක් මෙන්). එම හේතුව නිසා මම භාවිතා කරන්නේ grepමිස [විධානය නොවේ .

කරන්න:

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

දැන් ඔබ සිතන්නේ ifඑය අනුගමනය කරන විධානයේ පිටවීමේ තත්ත්වය පරීක්ෂා කිරීමට (අර්ධ කොලන් සමඟ සම්පුර්ණයි), ඔබ පරීක්ෂා කරන නූලෙහි ප්‍රභවය නැවත සලකා නොබලන්නේ මන්ද?

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

මෙම -qඅපි පමණක් නැවත කේතය අවශ්ය ලෙස විකල්පය වර්ගයන් නොවේ, ප්රතිදාන දෙයක් grep. <<<කවචය ඊලඟ වචනය පුළුල් කර එය විධානයට ආදානය ලෙස භාවිතා කරයි, <<මෙහි ලේඛනයේ එක් පේළියේ අනුවාදය (මෙය සම්මත හෝ බාෂිවාදයක් දැයි මට විශ්වාස නැත).

පිළිගත් පිළිතුර හොඳම ය, නමුත් එය කිරීමට එක් ක්‍රමයකට වඩා ඇති බැවින්, මෙහි තවත් විසඳුමක් තිබේ:

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

${var/search/replace}වන $varපළමු උදාහරණයක් සමග searchප්රතිස්ථාපනය replace, එය සොයා නම් (එය වෙනස් නොවේ $var). ඔබ fooකිසිවක් වෙනුවට ආදේශ කිරීමට උත්සාහ කළහොත් සහ නූල වෙනස් වී තිබේ නම්, පැහැදිලිවම fooසොයාගත හැකි විය.

එබැවින් ප්‍රශ්නයට ප්‍රයෝජනවත් විසඳුම් රාශියක් ඇත - නමුත් වේගවත්ම / අවම සම්පත් භාවිතා කරන්නේ කුමක්ද?

මෙම රාමුව භාවිතා කරමින් නැවත නැවත පරීක්ෂණ:

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

සෑම අවස්ථාවකදීම ටෙස්ට් වෙනුවට:

[[ $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 එෆ්. හූරිගේ පිළිතුරෙහි විය)

ගිග්ල්ස් සඳහා:

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

එබැවින් සරල ආදේශන විකල්පය දීර් test පරීක්ෂණයකදී හෝ නඩුවකින් වේවා අනාවැකි කිව හැකිය. නඩුව අතේ ගෙන යා හැකි ය.

ග්‍රෙප් 100000 ක් පිටතට ගැනීම අනාවැකි කිව හැකි තරම් වේදනාකාරී ය! අවශ්‍යතාවයකින් තොරව බාහිර උපයෝගිතා භාවිතා කිරීම පිළිබඳ පැරණි රීතිය සත්‍ය වේ.

මෙයද ක්‍රියාත්මක වේ:

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

Test ණාත්මක පරීක්ෂණය නම්:

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

මෙම විලාසිතාව තව ටිකක් සම්භාව්‍ය යැයි මම සිතමි.

මෙම --තර්කය පිරිසිදු POSIX මතිභ්රමයට, වැනි විකල්ප සමාන ආදාන නූල්, ආරක්ෂා කිරීම සඳහා භාවිතා වේ --abcහෝ -a.

සටහන: තද ලූපයක මෙම කේතය අභ්‍යන්තර බෑෂ් ෂෙල් විශේෂාංග භාවිතා කිරීමට වඩා මන්දගාමී වනු ඇත , මන්ද වෙනම ක්‍රියාවලි එකක් (හෝ දෙකක්) නිර්මාණය කර පයිප්ප හරහා සම්බන්ධ වේ.

Bash 4+ උදාහරණ. සටහන: උපුටා දැක්වීම් භාවිතා නොකිරීම වචනවල අවකාශයන් ආදිය අඩංගු වන විට ගැටළු ඇති කරයි.

මෙන්න උදාහරණ කිහිපයක් Bash 4+:

උදාහරණ 1, නූල් වලින් 'ඔව්' සඳහා පරීක්ෂා කරන්න (සිද්ධි සංවේදී නොවේ):

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

උදාහරණ 2, නූල් වලින් 'ඔව්' සඳහා පරීක්ෂා කරන්න (සිද්ධි සංවේදී නොවේ):

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

උදාහරණ 3, නූල් වලින් 'ඔව්' සඳහා පරීක්ෂා කරන්න (සිද්ධි සංවේදී):

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

උදාහරණ 4, නූල් වලින් 'ඔව්' සඳහා පරීක්ෂා කරන්න (සිද්ධි සංවේදී):

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

උදාහරණ 5, නිශ්චිත ගැලපීම (සිද්ධි සංවේදී):

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

උදාහරණ 6, නිශ්චිත ගැලපීම (සිද්ධි සංවේදී නොවේ):

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

උදාහරණ 7, හරියටම ගැලපීම:

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

උදාහරණ 8, ආදේශක කාඩ් ගැලපීම .ext (සිද්ධි සංවේදී නොවේ):

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

විනෝද වන්න.

කොහොමද මේ:

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

ලෙස පාවුල් සඳහන් ඔහුගේ කාර්ය සාධන සාපේක්ෂව:

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

මෙය මාකස් විසින් සපයන ලද පිළිතුරෙහි 'නඩුව "$ string' වැනි POSIX අනුකූල වේ , නමුත් සිද්ධි ප්‍රකාශ පිළිතුරට වඩා කියවීම තරමක් පහසුය. සිද්ධි ප්‍රකාශයක් භාවිතා කිරීමට වඩා මෙය මන්දගාමී වන බව සලකන්න. පාවුල් පෙන්වා දුන් පරිදි, එය ලූපයක් ලෙස භාවිතා නොකරන්න.

මෙම සිරස් පිටාර ගැලීමේ පිළිතුර අවකාශය හසුකර ගැනීමට සහ අක්ෂර ඉරීමට ඇති එකම පිළිතුර විය:

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

එකකි:

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

මම කැමතියි sed.

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

සංස්කරණය කරන්න, තර්කනය:

• නූල් වලින් උපස්ථරයක් ඉවත් කිරීමට sed භාවිතා කරන්න

• නව නූල පැරණි නූලට වඩා වෙනස් නම්, උපස්ථරය පවතී

grep -q මෙම කාර්යය සඳහා ප්‍රයෝජනවත් වේ.

භාවිතා කිරීම එකම awk:

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

ප්‍රතිදානය:

සොයා ගත නොහැක

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

ප්‍රතිදානය:

හමු විය

මුල් ප්‍රභවය: http://unstableme.blogspot.com/2008/06/bash-search-letter-in-string-awk.html

මට මෙම ක්‍රියාකාරීත්වය නිතර නිතර අවශ්‍ය බව මට පෙනී ගියේය, එබැවින් මම මේ ආකාරයෙන් ගෙදර හැදූ ෂෙල් ශ්‍රිතයක් භාවිතා කරමි, .bashrcඑමඟින් මට අවශ්‍ය සෑම විටම නැවත භාවිතා කිරීමට ඉඩ සලසයි, පහසුවෙන් මතක තබා ගත හැකි නමක්:

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

නම් පරීක්ෂා කිරීමට $string1(කිව්වොත්, ඒබීසී ) අඩංගු වේ $string2(කිව්වොත්, 123abcABC ) මම පවත්වාගෙන යාම සඳහා අවශ්ය stringinstring "$string1" "$string2"උදාහරණයක් ලෙස, නැවත අගය කිරීම සඳහා සහ පරීක්ෂා

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

මගේ .bash_profile ගොනුව සහ මම grep භාවිතා කළ ආකාරය:

PATH පරිසර විචල්‍යයට මගේ binනාමාවලි දෙක ඇතුළත් නම් , ඒවා එකතු නොකරන්න,

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

මෙහි පිළිතුරු දී ඇති ප්‍රශ්නයේ දිගුව POSIX sh හි තවත් නූලක් තිබේදැයි ඔබ කියන්නේ කෙසේද? :

මෙම විසඳුම විශේෂ අක්ෂර සමඟ ක්‍රියා කරයි:

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

POSIX / BusyBox ප්‍රශ්නය නිවැරදි පිළිතුර (IMHO) ලබා නොදී වසා ඇති බැවින් , මම පිළිතුරක් මෙහි පළ කරමි.

හැකි කෙටිම පිළිතුර නම්:

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

හෝ

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

බව සටහන ද්විත්ව හැෂ් වේ අනිවාර්ය (සමහර කටු ash). [ stringvalue ]උපස්ථරය සොයාගත නොහැකි වූ විට ඉහත ඇගයීමට ලක් කෙරේ. එය කිසිදු දෝෂයක් ලබා නොදේ. උපස්ථරය සොයාගත් විට ප්‍රති result ලය හිස් වන අතර එය ඇගයීමට ලක් [ ]කරයි. නූල සම්පූර්ණයෙන්ම ආදේශ කර ඇති නිසා මෙය දෝෂ කේත 1 විසි කරයි (හේතුවෙන් *).

කෙටිම වඩාත් පොදු වාක්‍ය ඛණ්ඩය:

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

හෝ

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

තවත් එකක්:

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

හෝ

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

මෙම සටහන තනි සමාන ලකුණක්!

නිවැරදි වචන ගැලපීම:

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 උත්සාහ කරන්න.

එය Bash 4 සඳහා OO- විලාසිතාවේ සංගීත පුස්තකාලයකි. එයට ජර්මානු umlauts සඳහා සහය ඇත. එය Bash හි ලියා ඇත.

බොහෝ කාර්යයන් ලබා ගත හැකිය: -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, සහ -zfill.

අඩංගු උදාහරණය දෙස බලන්න :

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

oobash Sourceforge.net වෙතින් ලබා ගත හැකිය .

මම මෙම ශ්‍රිතය භාවිතා කරමි (එක් යැපීමක් ඇතුළත් කර නැති නමුත් පැහැදිලිව පෙනේ). එය පහත දැක්වෙන පරීක්ෂණ සමත් වේ. ශ්‍රිතය අගය> 0 ලබා දෙන්නේ නම්, එම නූල සොයා ගන්නා ලදි. ඒ වෙනුවට ඔබට පහසුවෙන් 1 හෝ 0 ආපසු ලබා දිය හැකිය.

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

මෙය https://stackoverflow.com/a/229585/11267590 ට සමාන පිළිතුරකි . නමුත් සරල විලාසිතාව සහ POSIX අනුකූල වේ.

msg="message"

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

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

check

මෙය a හෝ b හෝ c හි කිසියම් සිදුවීමක් සොයා ගනී

සාමාන්‍ය ඉඳිකටු පිදුරු උදාහරණය විචල්යයන් සමඟ අනුගමනය කරයි

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