string स्ट्रिंग में बैश शामिल है




bash substring (16)

जैसा पौलुस ने अपनी प्रदर्शन तुलना में उल्लेख किया था:

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

यह पॉसिक्स है जो मार्कस द्वारा प्रदान किए गए उत्तर में 'केस "$ स्ट्रिंग" स्ट्रिंग "की तरह अनुपालन करता है, लेकिन केस स्टेटमेंट उत्तर से पढ़ने के लिए थोड़ा आसान है। यह भी ध्यान रखें कि केस स्टेटमेंट का उपयोग करने से यह बहुत धीमा होगा, जैसा कि पौलुस ने बताया था, इसे लूप में उपयोग न करें।

मेरे पास बैश में एक स्ट्रिंग है:

string="My string"

यदि यह एक और स्ट्रिंग है तो मैं परीक्षण कैसे कर सकता हूं?

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

कहाँ ?? मेरा अज्ञात ऑपरेटर है। क्या मैं गूंज और grep उपयोग करता हूँ?

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

यह थोड़ा बेकार दिखता है।


ओबाश का प्रयास करें यह बैश 4 के लिए ओओ-स्टाइल स्ट्रिंग लाइब्रेरी है। इसमें जर्मन उमोट्स के लिए समर्थन है। यह बैश में लिखा गया है। कई फ़ंक्शन उपलब्ध हैं: -base64Decode , -base64Encode , -capitalize , -center , -charAt , -concat , -count , -endsWith , -equals , -equalsIgnoreCase , -reverse , -hashCode , -indexOf , -isAlnum , -isAlnum , -isAlpha , -isAscii , -isDigit , -isEmpty , -isAlpha , -isAscii , -isDigit , -isEmpty , -isHexDigit , -isLowerCase , -isSpace , -isPrintable , -isUpperCase , -isVisible , -lastIndexOf , -startsWith , -substring , -swapCase , -swapCase , -toLowerCase , -toString , -toUpperCase , और -zfill

उदाहरण में देखें:

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

Sourceobge.net पर oobash उपलब्ध है


यदि आप डबल ब्रैकेट का उपयोग करते हैं, तो आप केस स्टेटमेंट के बाहर मार्कस के उत्तर (* वाइल्डकार्ड) का भी उपयोग कर सकते हैं:

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

ध्यान दें कि सुई स्ट्रिंग में रिक्त स्थान को डबल कोट्स के बीच रखा जाना चाहिए, और * वाइल्डकार्ड बाहर होना चाहिए।


स्वीकृत उत्तर सबसे अच्छा है, लेकिन चूंकि इसे करने के एक से अधिक तरीके हैं, तो यहां एक और समाधान है:

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

प्रतिस्थापन द्वारा प्रतिस्थापित किए गए search के पहले उदाहरण के साथ ${var/search/replace} $var , यदि यह पाया जाता है (यह $var नहीं बदलता है)। यदि आप कुछ भी नहीं द्वारा foo को प्रतिस्थापित करने का प्रयास करते हैं, और स्ट्रिंग बदल गई है, तो जाहिर है foo पाया गया था।


मैं इस फ़ंक्शन का उपयोग करता हूं (एक निर्भरता शामिल नहीं है लेकिन स्पष्ट है)। यह नीचे दिखाए गए परीक्षण पास करता है। यदि फ़ंक्शन एक मान> 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 "(" "'[email protected] (dev,web)'" | assert_eq 11
   str_instr ")" "'[email protected] (dev,web)'" | assert_eq 19
   str_instr "[" "'[email protected] [dev,web]'" | assert_eq 11
   str_instr "]" "'[email protected] [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
}

संगत उत्तर

चूंकि बैश-विशिष्ट विशेषताओं का उपयोग करके पहले से ही बहुत सारे उत्तर हैं, इसलिए गरीब-फीचर्ड शैल के तहत काम करने का एक तरीका है, जैसे व्यस्त 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 , ksh और ash ( ksh ) के तहत परीक्षण किया गया था, और परिणाम हमेशा होता है:

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="[email protected]"
    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'.

सरल कार्य

यह busybox , dash और निश्चित रूप से bash तहत परीक्षण किया गया था:

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

... या यदि सबमिट स्ट्रिंग खाली हो सकती है, जैसा कि @Sjlver द्वारा इंगित किया गया है, फ़ंक्शन बन जाएगा:

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

या एड्रियन गुंटर की टिप्पणी द्वारा सुझाए गए अनुसार, से बचने के लिए:

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

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

सटीक शब्द मिलान:

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

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

यदि आप रेगेक्स दृष्टिकोण पसंद करते हैं:

string='My string';

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

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


यह स्टैक ओवरफ़्लो उत्तर अंतरिक्ष और डैश वर्णों को फँसाने वाला एकमात्र था:

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

एक है:

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

इस बारे में कैसा है:

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

मुझे एक कथन का उपयोग करने के बारे में निश्चित नहीं है, लेकिन आप केस स्टेटमेंट के साथ समान प्रभाव प्राप्त कर सकते हैं:

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

मेरा .bash_profile और मैंने grep का उपयोग कैसे किया यदि पथ में मेरे 2 बिन डीआईआर शामिल थे, उन्हें शामिल न करें

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

मुझे sed पसंद है

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

संपादित करें, तर्क:

  • स्ट्रिंग से सबस्ट्रिंग के उदाहरण को हटाने के लिए sed का उपयोग करें

  • यदि नई स्ट्रिंग पुरानी स्ट्रिंग से अलग है, तो सबस्ट्रिंग मौजूद है





substring