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




bash substring (14)

संगत उत्तर

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

https://code.i-harness.com

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

string="My string"

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

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

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

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

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


आपको याद रखना चाहिए कि शेल स्क्रिप्टिंग एक भाषा से कम है और कमांड का संग्रह है। सहजता से आप सोचते हैं कि इस "भाषा" के लिए आपको एक [ या एक [[ । वे दोनों केवल आदेश हैं जो सफलता या विफलता को इंगित करने वाली निकास स्थिति लौटाते हैं (बस हर दूसरे आदेश की तरह)। इसी कारण से मैं grep उपयोग करता हूं, न कि [ आदेश।

बस करो:

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

अब आप इस बारे में सोच रहे हैं कि इसके बाद के आदेश के बाहर निकलने की स्थिति का परीक्षण (सेमी-कोलन के साथ पूर्ण)। आप जिस स्ट्रिंग का परीक्षण कर रहे हैं उसके स्रोत पर पुनर्विचार क्यों नहीं करते?

## 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 को कुछ भी आउटपुट नहीं बनाता है, क्योंकि हम केवल रिटर्न कोड चाहते हैं। <<< खोल अगले शब्द का विस्तार करता है और इसे कमांड के इनपुट के रूप में उपयोग करता है, << यहां दस्तावेज़ का एक-पंक्ति संस्करण (मुझे यकीन नहीं है कि यह मानक है या एक बाशवाद है)।


एक है:

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

ओबाश का प्रयास करें यह बैश 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 उपलब्ध है


तो सवाल के बहुत सारे उपयोगी समाधान हैं - लेकिन कम से कम संसाधन का सबसे तेज़ / उपयोग कौन सा है?

इस फ्रेम का उपयोग करके दोहराए गए परीक्षण:

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

प्रत्येक बार परीक्षा बदलना:

[[ $b =~ $a ]]           2.92user 0.06system 0:02.99elapsed 99%CPU

[ "${b/$a//}" = "$b" ]   3.16user 0.07system 0:03.25elapsed 99%CPU

[[ $b == *$a* ]]         1.85user 0.04system 0:01.90elapsed 99%CPU

case $b in *$a):;;esac   1.80user 0.02system 0:01.83elapsed 99%CPU

doContain $a $b          4.27user 0.11system 0:04.41elapsed 99%CPU

(डकंटन एफ। अवेरी के जवाब में था)

और गिगल्स के लिए:

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

तो सरल प्रतिस्थापन विकल्प predicatbly जीतता है चाहे एक विस्तारित परीक्षण या एक मामले में। मामला पोर्टेबल है।

100000 ग्रिप्स तक पिपिंग अनुमानित रूप से दर्दनाक है! जरूरत के बिना बाहरी उपयोगिताओं का उपयोग करने के बारे में पुराना नियम सच है।


मुझे sed पसंद है

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

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

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

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


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

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

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

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

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

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

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

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

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

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


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

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




substring