Skip to main content

ఒక బాష్ స్క్రిప్ట్ లోపల టెస్టు నిబంధనలు ఎలా ఉపయోగించాలి

Anonim

పరీక్ష కమాండ్ మరొకటి వ్యతిరేకంగా ఒక మూలకాన్ని సరిపోల్చడానికి లినక్స్ కమాండ్ లైన్లో ఉపయోగించబడుతుంది, అయితే ఇది సామాన్యంగా బాష్ షెల్ స్క్రిప్ట్స్లో ఉపయోగించబడుతుంది, ఇవి నియత తర్కం మరియు కార్యక్రమ ప్రవాహాన్ని నియంత్రించే నిబంధనలలో భాగంగా ఉంటాయి.

ప్రాథమిక ఉదాహరణ

టెర్మినల్ విండోను తెరవడం ద్వారా మీరు కేవలం ఈ ఆదేశాలను ప్రయత్నించవచ్చు.

పరీక్ష 1 -eq 2 && echo "yes" || ప్రతిధ్వని "కాదు"

కింది కింది విభజన విచ్ఛిన్నం చేయవచ్చు:

  • పరీక్ష - అంటే మీరు ఒక పోలికను నిర్వహించబోతున్నారు
  • 1 - మొదటి అంశం మీరు పోల్చడానికి వెళ్తున్నారు
  • -eq - ఎలా మీరు పోల్చారు. ఈ సందర్భంలో, మీరు ఒక సంఖ్య మరొకటి సమానం అని మీరు పరీక్షిస్తున్నారు.
  • 2 - మీరు మొదటి మూలకాన్ని పోల్చే మూలకం
  • && - ఫలితం నిజమైతే క్రింది ప్రకటనను అమలు చేయండి
  • ప్రతిధ్వని "అవును" - పోలిక తిరిగి నిజమైతే నడుపుటకు ఆదేశం
  • || - ఫలితం తప్పుగా ఉంటే క్రింది ప్రకటనను అమలు చేయండి
  • ప్రతిధ్వని "లేదు" - పోలిక తిరిగి తప్పుగా ఉంటే నడుపుటకు ఆదేశం

సారాంశంలో, కమాండ్ 1 నుండి 2 కు సరిపోలుతుంది మరియు వారు సరిపోలితే, "అవును" ప్రదర్శించబడుతున్న "అవును" ప్రకటన నిర్వర్తించబడుతుంది మరియు అవి "అవును" ప్రదర్శించబడితే, ప్రతిధ్వని "నో" ప్రకటన ప్రదర్శించబడుతుంది, ఇది "నో" ప్రదర్శిస్తుంది.

సంఖ్యలు పోల్చడం

మీరు సంఖ్యలుగా అన్వయించే అంశాలను పోల్చి ఉంటే, మీరు క్రింది పోలిక ఆపరేటర్లను ఉపయోగించవచ్చు:

  • -eq - విలువ 1 సమాన విలువ 2 చేస్తుంది
  • -g - విలువ 1 ఎక్కువ లేదా విలువ 2 సమానంగా ఉంటుంది
  • -gt - value 2 కంటే విలువ 1 ఎక్కువ
  • -le - విలువ 1 కంటే తక్కువ లేదా విలువ 2 సమానంగా ఉంటుంది
  • -lt - value 2 కన్నా విలువ 1 తక్కువ
  • -ne - value 1 కాదు సమాన విలువ 2 చేస్తుంది

ఉదాహరణలు

పరీక్ష 1 -eq 2 && echo "yes" || ప్రతిధ్వని "కాదు"

(స్క్రీన్కి "నో" ప్రదర్శిస్తుంది ఎందుకంటే 1 సమానం 2 కాదు)

test 1 -ge 2 && echo "yes" || ప్రతిధ్వని "కాదు"

(స్క్రీన్కి "నో" ప్రదర్శిస్తుంది ఎందుకంటే 1 ఎక్కువ కాదు లేదా 2 కు సమానంగా ఉంటుంది)

test 1-gt 2 && echo "yes" || ప్రతిధ్వని "కాదు"

(స్క్రీన్కి "నో" ప్రదర్శిస్తుంది ఎందుకంటే 1 2 కంటే ఎక్కువ కాదు)

test 1 -le 2 && echo "yes" || ప్రతిధ్వని "కాదు"

(స్క్రీన్కి "అవును" ప్రదర్శిస్తుంది ఎందుకంటే 1 కన్నా తక్కువ లేదా 2 కి సమానంగా ఉంటుంది)

పరీక్ష 1-lt 2 && echo "yes" || ప్రతిధ్వని "కాదు"

(స్క్రీన్కి "అవును" ప్రదర్శిస్తుంది ఎందుకంటే 1 కన్నా తక్కువ లేదా 2 కి సమానంగా ఉంటుంది)

test 1 -ne 2 && echo "yes" || ప్రతిధ్వని "కాదు"

(స్క్రీన్కి "అవును" ప్రదర్శిస్తుంది ఎందుకంటే 1 సమానం 2 కాదు)

టెక్స్ట్ పోల్చడం

మీరు స్ట్రింగ్స్ వలె అన్వయించే అంశాలను పోల్చి ఉంటే, మీరు క్రింది పోలిక ఆపరేటర్లను ఉపయోగించవచ్చు:

  • = - స్ట్రింగ్ 1 మ్యాచ్ స్ట్రింగ్ 2 చేస్తుంది
  • స్ట్రింగ్ 2 కు స్ట్రింగ్ 1 విభిన్నంగా ఉంటుంది!
  • -n - 0 కన్నా ఎక్కువ స్ట్రింగ్ పొడవు
  • -z - స్ట్రింగ్ పొడవు 0

ఉదాహరణలు

పరీక్ష "string1" = "string2" && echo "yes" || ప్రతిధ్వని "కాదు"

("స్ట్రింగ్ 1" సమాన కాదు "స్ట్రింగ్ 2" ఎందుకంటే స్క్రీన్ "లేదు" ప్రదర్శిస్తుంది)

పరీక్ష "string1"! = "string2" && echo "yes" || ప్రతిధ్వని "కాదు"

(స్క్రీన్కి "అవును" ప్రదర్శిస్తుంది ఎందుకంటే "string1" సమాన కాదు "string2")

test -n "string1" && echo "yes" || ప్రతిధ్వని "కాదు"

(స్క్రీన్పై "అవును" ప్రదర్శిస్తుంది ఎందుకంటే "string1" సున్నా కంటే ఎక్కువ స్ట్రింగ్ పొడవును కలిగి ఉంది)

test -z "string1" && echo "yes" || ప్రతిధ్వని "కాదు"

(స్క్రీన్కి "నో" ప్రదర్శిస్తుంది ఎందుకంటే "string1" సున్నా కంటే ఎక్కువ స్ట్రింగ్ పొడవును కలిగి ఉంది)

ఫైల్స్ పోల్చడం

మీరు ఫైళ్ళను పోల్చి చూస్తే, మీరు ఈ క్రింది పోలిక ఆపరేటర్లను ఉపయోగించవచ్చు:

  • -ef - ఫైళ్ళు ఒకే పరికరం మరియు ఐనోడ్ సంఖ్యలు (అవి అదే ఫైల్)
  • -nt - మొదటి ఫైలు రెండవ ఫైల్ కంటే కొత్తది
  • -ot - రెండవ ఫైల్ కంటే పాతది మొదటి ఫైల్
  • -b - ఫైల్ ఉంది మరియు ప్రత్యేక బ్లాక్ ఉంది
  • -c - ఫైలు ఉంది మరియు ప్రత్యేక పాత్ర
  • -d - ఫైల్ ఉంది మరియు డైరెక్టరీ
  • -e - ఫైల్ ఉంది
  • -f - ఫైల్ ఉంది మరియు ఒక సాధారణ ఫైల్
  • -g - ఫైలు ఉంది మరియు పేర్కొన్న సమూహం సంఖ్య ఉంది
  • -G - ఫైలు ఉంది మరియు యూజర్ యొక్క గుంపు ద్వారా యజమాని
  • -h - ఫైలు ఉంది మరియు ఒక లాంఛనప్రాయ లింక్
  • -k - ఫైల్ ఉంది మరియు దాని స్టికీ బిట్ సెట్ ఉంది
  • -L - అదే -h
  • -O - ​​ఫైల్ మీరు యజమాని ఉన్నారు
  • -p - ఫైల్ ఉంది మరియు పేరు పెట్టబడినది
  • -r - ఫైల్ ఉంది మరియు చదవగలిగేది
  • -s - ఫైలు ఉంది మరియు సున్నా కంటే ఎక్కువ పరిమాణం కలిగి ఉంది
  • -S - ఫైల్ ఉంది మరియు సాకెట్ ఉంది
  • -t - ఫైల్ వర్ణన ఒక టెర్మినల్ లో తెరవబడింది
  • -u - ఫైల్ ఉంది మరియు సెట్-యూజర్-id బిట్ సెట్ చేయబడుతుంది
  • -w - ఫైలు ఉంది మరియు వ్రాయదగినది
  • -x - ఫైల్ ఉనికిలో ఉంది మరియు అమలు చేయదగినది

ఉదాహరణలు

test / path / to / file1 -nt / path / to / file2 && echo "yes"

(File2 కంటే file1 కొత్తదైతే, అప్పుడు "yes" అనే పదం ప్రదర్శించబడుతుంది)

test -e / path / to / file1 && echo "yes"

(file1 ఉంటే "అవును" అనే పదం ప్రదర్శించబడుతుంది)

test -O / path / to / file1 && echo "yes"

(మీరు file1 స్వంతం అయితే "అవును" అనే పదం ప్రదర్శించబడుతుంది)

టెర్మినాలజీ

  • బ్లాక్ ప్రత్యేక - ఫైలు ఒక బ్లాక్ పరికరం అంటే డేటా బైట్లు బ్లాక్స్ లో చదవబడుతుంది. ఇవి సాధారణంగా హార్డ్ డ్రైవ్ల వంటి పరికర ఫైళ్ళు.
  • అక్షర ప్రత్యేక - మీరు దానికి వ్రాసేటప్పుడు మరియు వెంటనే సీరియల్ పోర్ట్ లాంటి పరికరం అయినప్పుడు ఫైల్ వెంటనే పని చేస్తుంది

బహుళ నిబంధనలను పోల్చడం

ఇంతవరకు, ప్రతిదీ ఒకదానితో మరొకటి పోల్చడం జరిగింది, కానీ మీరు రెండు పరిస్థితులను పోల్చాలనుకుంటే?

ఉదాహరణకు, ఒక జంతువుకు 4 కాళ్ళు ఉంటే మరియు "మూ" గా ఉంటే, అది బహుశా ఒక ఆవు. కేవలం 4 కాళ్ళ కోసం తనిఖీ చేయడం మీకు ఒక ఆవు ఉందని హామీ ఇవ్వదు, కానీ ఇది ఖచ్చితంగా చేసే ధ్వనిని తనిఖీ చేస్తుంది.

రెండు పరిస్థితులను పరీక్షించడానికి ఒకేసారి ఈ క్రింది ప్రకటన ఉపయోగించండి:

పరీక్ష 4 -eq 4-a "moo" = "moo" && echo "ఇది ఒక ఆవు" || ప్రతిధ్వని "ఇది ఒక ఆవు కాదు"

ఇక్కడ కీలక భాగం - ఇది నిలుస్తుంది మరియు .

అదే పరీక్షను నిర్వహించడం మంచిది మరియు మరింత సాధారణంగా ఉపయోగించబడుతుంది మరియు ఇది క్రింది విధంగా ఉంటుంది:

పరీక్ష 4 -eq 4 && పరీక్ష "moo" = "moo" && echo "ఇది ఒక ఆవు" || ప్రతిధ్వని "ఇది ఒక ఆవు కాదు"

మీరు చేయాలనుకుంటున్న మరొక పరీక్ష రెండు ప్రకటనలు పోల్చడం మరియు నిజమైతే, అవుట్పుట్ స్ట్రింగ్. ఉదాహరణకు, మీరు "file1.txt" పేరుతో ఉన్న ఫైల్ లేదా "file1.doc" అని పిలువబడే ఒక ఫైల్ ఉందని మీరు అనుకుంటే, మీరు కింది ఆదేశాన్ని ఉపయోగించవచ్చు:

test -e file1.txt -o -e file1.doc && echo "file1 exists" || echo "file1 ఉనికిలో లేదు"

ఇక్కడ కీలక భాగం -o ఇది నిలుస్తుంది లేదా .

అదే పరీక్షను నిర్వహించడం మంచిది మరియు మరింత సాధారణంగా ఉపయోగించబడుతుంది మరియు ఇది క్రింది విధంగా ఉంటుంది:

test -e file1.txt || test -e file1.doc && echo "file1 exists" || echo "file1 ఉనికిలో లేదు"

టెస్ట్ కీవర్డ్ తొలగించడం

మీరు నిజంగా పోలికను నిర్వహించడానికి పదం పరీక్షను ఉపయోగించాల్సిన అవసరం లేదు. ఈ క్రింది విధంగా చదరపు బ్రాకెట్లలో ప్రకటన జతపరచు:

-e file1.txt && echo "file1 exists" || echo "file1 ఉనికిలో లేదు"

పరీక్ష మరియు ప్రాథమికంగా అదే పరీక్ష.

ఈ క్రింది విధంగా మీరు బహుళ పరిస్థితులను పోల్చడానికి మీరు మెరుగుపరుస్తారని ఇప్పుడు మీకు తెలుస్తుంది:

4 -eq 4 && "moo" = "moo" && echo "ఇది ఒక ఆవు" || ప్రతిధ్వని "ఇది ఒక ఆవు కాదు"-e file1.txt || -e file1.doc && echo "file1 exists" || echo "file1 ఉనికిలో లేదు"

సారాంశం

పరీక్ష కమాండ్ స్క్రిప్ట్స్లో మరింత ఉపయోగకరంగా ఉంటుంది ఎందుకంటే మీరు మరొక వేరియంట్ యొక్క వేరియంట్ మరియు కంట్రోల్ ప్రోగ్రామ్ ప్రవాహం యొక్క పరీక్షను పరీక్షించవచ్చు. ప్రామాణిక కమాండ్ లైన్లో, మీరు ఒక ఫైల్ ఉందో లేదో పరీక్షించడానికి దాన్ని ఉపయోగించవచ్చు.