బాష్ స్క్రిప్ట్‌లలో సబ్‌స్ట్రింగ్‌ల కోసం తనిఖీ చేస్తోంది

బాష్‌లో స్ట్రింగ్ కంటైన్‌మెంట్ పరిచయం

బాష్ స్క్రిప్ట్‌లతో పని చేస్తున్నప్పుడు, స్ట్రింగ్ నిర్దిష్ట సబ్‌స్ట్రింగ్‌ని కలిగి ఉందో లేదో మీరు తనిఖీ చేయాల్సిన సందర్భాలు సర్వసాధారణం. ఇన్‌పుట్ డేటాను అన్వయించడం, స్ట్రింగ్‌లను ధృవీకరించడం లేదా నిర్దిష్ట ప్రమాణాల ఆధారంగా కంటెంట్‌ను ఫిల్టర్ చేయడం వంటి అనేక స్క్రిప్టింగ్ దృశ్యాలలో ఇది ప్రాథమిక పని.

ఈ కథనంలో, మేము షరతులతో కూడిన స్టేట్‌మెంట్‌లు మరియు `echo` మరియు `grep` వంటి ఆదేశాలను ఉపయోగించడంతో సహా బాష్‌లో దీన్ని సాధించడానికి వివిధ పద్ధతులను అన్వేషిస్తాము. మేము మీ స్క్రిప్ట్‌లను మరింత మెయింటెయిన్ చేయగలిగేలా మరియు లోపాలకి తక్కువ అవకాశం ఉండేలా చేయడానికి అత్యంత సమర్థవంతమైన మరియు చదవగలిగే విధానాలను కూడా చర్చిస్తాము.

బాష్‌లో సబ్‌స్ట్రింగ్ తనిఖీని అర్థం చేసుకోవడం

మొదటి స్క్రిప్ట్‌లో, మేము ఉపయోగిస్తాము conditional statements స్ట్రింగ్ నిర్దిష్ట సబ్‌స్ట్రింగ్‌ని కలిగి ఉందో లేదో తనిఖీ చేయడానికి. మేము ప్రధాన స్ట్రింగ్ మరియు సబ్‌స్ట్రింగ్‌ని నిర్వచించాము, ఆపై దాన్ని ఉపయోగించండి [[ ]] నిర్మాణం, ఇది అధునాతన స్ట్రింగ్ పోలికలను అనుమతిస్తుంది. బ్రాకెట్ల లోపల, మేము ఉపయోగిస్తాము * వైల్డ్‌కార్డ్ సబ్‌స్ట్రింగ్‌కు ముందు మరియు తర్వాత ఎన్ని అక్షరాలనైనా సూచించడానికి. షరతు నిజమైతే, స్క్రిప్ట్ "అది ఉంది!" అని ముద్రిస్తుంది; లేకుంటే, అది "అది లేదు!" అని ముద్రిస్తుంది. ఈ పద్ధతి సమర్థవంతమైనది మరియు నమూనా సరిపోలిక కోసం బాష్ యొక్క అంతర్నిర్మిత సామర్థ్యాలను ఉపయోగించుకుంటుంది.

రెండవ స్క్రిప్ట్ ఉపయోగిస్తుంది echo మరియు grep అదే ఫలితాన్ని సాధించడానికి ఆదేశాలు. మేము మళ్లీ ప్రధాన స్ట్రింగ్ మరియు సబ్‌స్ట్రింగ్‌ని నిర్వచించి, ఆపై ఉపయోగించండి echo ప్రధాన స్ట్రింగ్‌ను అవుట్‌పుట్ చేయడానికి మరియు దానిని పైప్ చేయడానికి grep ఉపయోగించి -q సాధారణ అవుట్‌పుట్‌ను అణిచివేసే ఎంపిక. Grep ప్రధాన స్ట్రింగ్‌లోని సబ్‌స్ట్రింగ్ కోసం శోధిస్తుంది. సబ్‌స్ట్రింగ్ కనుగొనబడితే, స్క్రిప్ట్ "అది ఉంది!" అని ముద్రిస్తుంది; కాకపోతే, అది "అది లేదు!" అని ప్రింట్ చేస్తుంది. ఈ విధానం శక్తివంతమైన వచన-శోధన సామర్థ్యాలను ప్రభావితం చేస్తుంది grep, సంక్లిష్టమైన వచన నమూనాలను సరిపోల్చాల్సిన స్క్రిప్ట్‌లకు ఇది అనుకూలంగా ఉంటుంది.

అధునాతన బాష్ స్ట్రింగ్ ఆపరేషన్‌లను అన్వేషించడం

మూడవ స్క్రిప్ట్ a ని ఉపయోగిస్తుంది case సబ్‌స్ట్రింగ్ ఉనికిని తనిఖీ చేయడానికి ప్రకటన. ప్రధాన స్ట్రింగ్ మరియు సబ్‌స్ట్రింగ్‌ను నిర్వచించిన తర్వాత, ది case ప్రకటన వివిధ నమూనాలకు వ్యతిరేకంగా ప్రధాన స్ట్రింగ్‌తో సరిపోలుతుంది. సబ్‌స్ట్రింగ్ ఉన్నట్లయితే, సంబంధిత చర్య అమలు చేయబడుతుంది, "అది ఉంది!". సబ్‌స్ట్రింగ్ కనుగొనబడకపోతే, డిఫాల్ట్ చర్య "అది లేదు!" అని ముద్రిస్తుంది. తనిఖీ చేయడానికి బహుళ నమూనాలు ఉన్నప్పుడు ఈ పద్ధతి చాలా ఉపయోగకరంగా ఉంటుంది case స్టేట్‌మెంట్ మల్టిపుల్ కంటే కాంప్లెక్స్ బ్రాంకింగ్ లాజిక్‌ని మరింత క్లీన్‌గా హ్యాండిల్ చేయగలదు if-else ప్రకటనలు.

మొత్తంగా, ఈ పద్ధతుల్లో ప్రతి ఒక్కటి బాష్‌లో స్ట్రింగ్ నిర్దిష్ట సబ్‌స్ట్రింగ్‌ని కలిగి ఉందో లేదో తెలుసుకోవడానికి ఒక మార్గాన్ని అందిస్తుంది. పద్ధతి యొక్క ఎంపిక అవసరమైన స్ట్రింగ్ మ్యాచింగ్ యొక్క సంక్లిష్టత మరియు స్క్రిప్ట్ యొక్క నిర్దిష్ట అవసరాలపై ఆధారపడి ఉంటుంది. ఉపయోగించి [[ ]] వైల్డ్‌కార్డ్‌లతో కలపడం, సాధారణ తనిఖీల కోసం సూటిగా మరియు సమర్థవంతంగా ఉంటుంది echo మరియు grep మరింత శక్తివంతమైన నమూనా సరిపోలికను అందిస్తుంది. ది case ప్రకటన, మరోవైపు, నిర్మాణాత్మక మార్గంలో బహుళ సరిపోలిక పరిస్థితులను నిర్వహించడానికి అనువైనది.

#!/bin/bash
# Define the main string
string="My string"
# Define the substring to search for
substring="foo"
# Check if the substring is present in the main string
if [[ "$string" == *"$substring"* ]]; then
  echo "It's there!"
else
  echo "It's not there!"
fi

#!/bin/bash
# Define the main string
string="My string"
# Define the substring to search for
substring="foo"
# Use echo and grep to check if the substring is present
if echo "$string" | grep -q "$substring"; then
  echo "It's there!"
else
  echo "It's not there!"
fi

#!/bin/bash
# Define the main string
string="My string"
# Define the substring to search for
substring="foo"
# Use case statement to check for the substring
case "$string" in
  *"$substring"*)
    echo "It's there!"
    ;;
  *)
    echo "It's not there!"
    ;;
esac

బాష్‌లో స్ట్రింగ్ కంటైన్‌మెంట్ కోసం అధునాతన పద్ధతులు

బాష్‌లో స్ట్రింగ్ సబ్‌స్ట్రింగ్‌ని కలిగి ఉందో లేదో తనిఖీ చేయడానికి ప్రాథమిక పద్ధతులతో పాటు, విభిన్న దృశ్యాలలో ఉపయోగపడే మరిన్ని అధునాతన పద్ధతులు ఉన్నాయి. అటువంటి పద్ధతిలో సాధారణ వ్యక్తీకరణలను ఉపయోగించడం awk ఆదేశం. Awk నమూనా స్కానింగ్ మరియు ప్రాసెసింగ్ కోసం శక్తివంతమైన ప్రోగ్రామింగ్ భాష. ఉపయోగించడం ద్వార awk, మీరు ఎక్కువ సౌలభ్యంతో క్లిష్టమైన స్ట్రింగ్ ఆపరేషన్‌లను చేయవచ్చు. ఉదాహరణకు, మీరు ఉపయోగించవచ్చు awk స్ట్రింగ్‌లోని సబ్‌స్ట్రింగ్ కోసం శోధించడానికి మరియు మ్యాచ్ ఆధారంగా చర్యలను అమలు చేయడానికి.

మరొక అధునాతన టెక్నిక్‌ను ఉపయోగించడం sed కమాండ్, ఇది స్ట్రీమ్ ఎడిటర్. Sed డేటా స్ట్రీమ్ లేదా ఫైల్‌లో వచనాన్ని అన్వయించడానికి మరియు మార్చడానికి ఉపయోగపడుతుంది. మీరు ఉపయోగించవచ్చు sed సబ్‌స్ట్రింగ్ కోసం శోధించడానికి మరియు సరిపోలిన వచనంపై ప్రత్యామ్నాయాలు లేదా ఇతర కార్యకలాపాలను నిర్వహించడానికి. ఈ అధునాతన పద్ధతులు, మరింత క్లిష్టంగా ఉన్నప్పటికీ, బాష్ స్క్రిప్ట్‌లలో టెక్స్ట్ ప్రాసెసింగ్ కోసం శక్తివంతమైన సామర్థ్యాలను అందిస్తాయి, అధునాతన స్ట్రింగ్ మానిప్యులేషన్‌లు అవసరమయ్యే పనుల కోసం వాటిని అమూల్యమైనవిగా చేస్తాయి.

బాష్‌లో స్ట్రింగ్ కంటైన్‌మెంట్‌పై తుది ఆలోచనలు

బాష్‌లో స్ట్రింగ్ సబ్‌స్ట్రింగ్‌ని కలిగి ఉందో లేదో నిర్ణయించడం అనేది షరతులతో కూడిన స్టేట్‌మెంట్‌లు, grep ఆదేశాలు మరియు కేస్ స్టేట్‌మెంట్‌లతో సహా అనేక పద్ధతులను ఉపయోగించి నిర్వహించగల సాధారణ పని. ప్రతి పద్ధతి సమస్యను పరిష్కరించడానికి ఒక ప్రత్యేకమైన విధానాన్ని అందిస్తుంది, మీ నిర్దిష్ట అవసరాల ఆధారంగా అత్యంత అనుకూలమైనదాన్ని ఎంచుకోవడానికి మిమ్మల్ని అనుమతిస్తుంది. ఈ టెక్నిక్‌లను ప్రావీణ్యం చేసుకోవడం ద్వారా, మీరు మీ బాష్ స్క్రిప్ట్‌ల సామర్థ్యాన్ని మరియు చదవగలిగే సామర్థ్యాన్ని పెంచుకోవచ్చు.