Saya memiliki string di Bash:

string="My string"

Bagaimana saya bisa menguji apakah itu berisi string lain?

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

Di mana ??operator tidak dikenal saya. Apakah saya menggunakan gema dan grep?

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

Itu terlihat agak canggung.

Anda dapat menggunakan jawaban Marcus (* wildcard) di luar pernyataan kasus, juga, jika Anda menggunakan tanda kurung ganda:

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

Perhatikan bahwa spasi di string harus ditempatkan di antara tanda kutip ganda, dan *wildcard harus di luar. Juga perhatikan bahwa operator pembanding sederhana digunakan (yaitu ==), bukan operator regex =~.

Jika Anda lebih suka pendekatan regex:

string='My string';

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

Saya tidak yakin tentang menggunakan pernyataan if, tetapi Anda bisa mendapatkan efek yang serupa dengan pernyataan kasus:

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

stringContain varian (kompatibel atau case-independent)

Karena sebagian besar jawaban Stack Overflow ini memberi tahu tentang Bash , saya telah memposting fungsi Bash independen kasus di bagian paling bawah posting ini ...

Lagi pula, ini milik saya

Jawaban yang kompatibel

Karena sudah ada banyak jawaban menggunakan fitur spesifik Bash, ada cara untuk bekerja di bawah cangkang fitur yang lebih buruk, seperti BusyBox :

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

Dalam praktiknya, ini bisa memberi:

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

Ini diuji di bawah Bash, Dash , KornShell ( ksh) dan ash (BusyBox), dan hasilnya selalu:

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

Menjadi satu fungsi

Seperti yang ditanyakan oleh @EeroAaltonen di sini adalah versi demo yang sama, diuji di bawah cangkang yang sama:

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
}

Kemudian:

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

Perhatikan: Anda harus melarikan diri atau melampirkan dua tanda kutip dan / atau tanda kutip ganda:

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

Fungsi sederhana

Ini diuji di bawah BusyBox, Dash, dan, tentu saja Bash:

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

Kemudian sekarang:

$ 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

... Atau jika string yang dikirimkan dapat kosong, seperti yang ditunjukkan oleh @Sjlver, fungsi tersebut akan menjadi:

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

atau seperti yang disarankan oleh komentar Adrian Günter , menghindari -osakelar:

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

Fungsi final (sederhana):

Dan membalikkan tes untuk membuatnya berpotensi lebih cepat:

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

Dengan string kosong:

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

Tidak tergantung huruf besar (Hanya Bash!)

Untuk menguji string tanpa peduli case, cukup konversi setiap string ke huruf kecil:

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

Memeriksa:

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

Anda harus ingat bahwa skrip shell kurang dari bahasa dan lebih dari kumpulan perintah. Secara naluriah Anda berpikir bahwa "bahasa" ini mengharuskan Anda untuk mengikuti a ifdengan [a [[. Keduanya hanyalah perintah yang mengembalikan status keluar yang menunjukkan keberhasilan atau kegagalan (sama seperti setiap perintah lainnya). Untuk alasan itu saya akan menggunakan grep, dan bukan [perintah.

Kerjakan saja:

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

Sekarang Anda berpikir untuk ifmenguji status keluar dari perintah yang mengikutinya (lengkap dengan semi-colon), mengapa tidak mempertimbangkan kembali sumber string yang Anda uji?

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

The -qpilihan membuat grep apa pun tidak output, karena kami hanya ingin kode kembali. <<<membuat shell memperluas kata berikutnya dan menggunakannya sebagai input ke perintah, versi satu-baris dari <<dokumen di sini (saya tidak yakin apakah ini standar atau Bashism).

Jawaban yang diterima adalah yang terbaik, tetapi karena ada lebih dari satu cara untuk melakukannya, inilah solusi lain:

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

${var/search/replace}adalah $vardengan contoh pertama searchdiganti oleh replace, jika ditemukan (tidak berubah $var). Jika Anda mencoba untuk mengganti foodengan tidak ada, dan string telah berubah, maka jelas fooditemukan.

Jadi ada banyak solusi berguna untuk pertanyaan - tetapi mana yang tercepat / menggunakan sumber daya paling sedikit?

Tes berulang menggunakan frame ini:

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

Mengganti TEST setiap kali:

[[ $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 ada dalam jawaban F. Houri)

Dan untuk cekikikan:

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

Jadi pilihan substitusi sederhana dapat diprediksi menang, baik dalam tes diperpanjang atau kasus. Kasingnya portabel.

Menyalurkan ke 100000 greps diduga menyakitkan! Aturan lama tentang menggunakan utilitas eksternal tanpa perlu benar.

Ini juga berfungsi:

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

Dan tes negatifnya adalah:

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

Saya kira gaya ini sedikit lebih klasik - kurang tergantung pada fitur Bash shell.

The --argumen adalah murni paranoia POSIX, digunakan untuk dilindungi terhadap string masukan mirip dengan pilihan, seperti --abcatau -a.

Catatan: Dalam loop ketat kode ini akan jauh lebih lambat daripada menggunakan fitur internal Bash shell, karena satu (atau dua) proses terpisah akan dibuat dan dihubungkan melalui pipa.

Bash 4+ contoh. Catatan: tidak menggunakan tanda kutip akan menyebabkan masalah ketika kata-kata mengandung spasi, dll. Selalu kutip di Bash, IMO.

Berikut adalah beberapa contoh Bash 4+:

Contoh 1, periksa 'ya' dalam string (case-sensitive):

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

Contoh 2, periksa 'ya' dalam string (case-sensitive):

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

Contoh 3, periksa 'ya' dalam string (peka huruf besar kecil):

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

Contoh 4, periksa 'ya' dalam string (peka huruf besar kecil):

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

Contoh 5, pencocokan tepat (peka huruf besar-kecil):

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

Contoh 6, kecocokan persis (tidak sensitif huruf besar):

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

Contoh 7, kecocokan persis:

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

Contoh 8, wildcard match .ext (case-sensitive):

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

Nikmati.

Bagaimana dengan ini:

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

Seperti yang disebutkan Paul dalam perbandingan kinerjanya:

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

Ini sesuai dengan POSIX seperti 'case "$ string" pada' jawaban yang diberikan oleh Marcus , tetapi sedikit lebih mudah dibaca daripada jawaban pernyataan kasus. Perhatikan juga bahwa ini akan jauh lebih lambat daripada menggunakan pernyataan kasus. Seperti yang ditunjukkan Paul, jangan menggunakannya dalam satu lingkaran.

Jawaban Stack Overflow ini adalah satu-satunya yang menjebak karakter spasi dan dash:

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

Satu adalah:

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

Saya suka sed.

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

Edit, Logika:

• Gunakan sed untuk menghapus turunan dari string

• Jika string baru berbeda dari string lama, substring ada

grep -q berguna untuk tujuan ini.

Penggunaan yang sama awk:

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

Keluaran:

Tidak ditemukan

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

Keluaran:

Ditemukan

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

Saya menemukan sangat membutuhkan fungsi ini, jadi saya menggunakan fungsi shell buatan saya .bashrcseperti ini yang memungkinkan saya untuk menggunakannya kembali sesering yang saya butuhkan, dengan nama yang mudah diingat:

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

Untuk menguji apakah $string1(katakanlah, abc ) terkandung dalam $string2(katakanlah, 123abcABC ) Saya hanya perlu menjalankan stringinstring "$string1" "$string2"dan memeriksa nilai pengembalian, misalnya

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

File .bash_profile saya dan bagaimana saya menggunakan grep:

Jika variabel lingkungan PATH menyertakan dua bindirektori saya , jangan tambahkan mereka,

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

Perpanjangan pertanyaan dijawab di sini Bagaimana Anda tahu jika sebuah string berisi string lain di POSIX sh? :

Solusi ini bekerja dengan karakter khusus:

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

Karena pertanyaan POSIX / BusyBox ditutup tanpa memberikan jawaban yang tepat (IMHO), saya akan memposting jawaban di sini.

Jawaban sesingkat mungkin adalah:

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

atau

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

Perhatikan bahwa hash ganda adalah wajib dengan beberapa kerang ( ash). Di atas akan mengevaluasi [ stringvalue ]ketika substring tidak ditemukan. Ia tidak mengembalikan kesalahan. Ketika substring ditemukan hasilnya kosong dan mengevaluasi [ ]. Ini akan membuang kode kesalahan 1 karena string sepenuhnya diganti (karena *).

Sintaks terpendek yang lebih umum:

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

atau

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

Yang lainnya:

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

atau

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

Perhatikan tanda sama dengan tunggal !

Pencocokan kata yang tepat:

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

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

Coba oobash.

Ini adalah pustaka string gaya OO untuk Bash 4. Ia memiliki dukungan untuk umlaut Jerman. Itu ditulis dalam Bash.

Banyak fungsi yang tersedia: -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, dan -zfill.

Lihatlah contoh berisi :

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

oobash tersedia di Sourceforge.net .

Saya menggunakan fungsi ini (satu ketergantungan tidak termasuk tetapi jelas). Itu melewati tes yang ditunjukkan di bawah ini. Jika fungsi mengembalikan nilai> 0 maka string ditemukan. Anda bisa dengan mudah mengembalikan 1 atau 0 sebagai gantinya.

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

Ini adalah jawaban yang sama dengan https://stackoverflow.com/a/229585/11267590 . Tapi gaya simpel dan juga POSIX Compliant.

msg="message"

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

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

check

Ini akan menemukan terjadinya a atau b atau c

Contoh tumpukan jerami jarum generik mengikuti variabel

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