SSD Nodes Learn Hosting plans →
మార్గదర్శకాలు Matt Connorద్వారా Matt Connor · అప్‌డేట్ చేయబడింది 2026-10-25

Bash Globbing: Wildcards, nullglob, globstar మరియు extglob

Bash globbing ఆదేశం నడవకముందే filenames ను ఎలా విస్తరిస్తుందో తెలుసుకోండి. nullglob, dotglob, globstar మరియు extglob negation తో ఖచ్చితమైన ఉదాహరణలు చూడండి.

Verified Every command ran end-to-end on a fresh Ubuntu 24.04 server, August 14, 2026.

మీ ఆదేశం అమలుకాకముందు Bash globbing చేసే పని

Bash globbing అంటే ఆదేశం ప్రారంభమయ్యే ముందు `*.log వంటి pattern ను నిజంగా ఉన్న filenames యొక్క క్రమబద్ధీకరించిన జాబితాగా shell మార్చడం. rm *.log ఎప్పుడూ rm కు pattern ను పంపదు. Bash directory ను చదివి, pattern కు సరిపోలే పేర్లను ఉంచి, వాటిని sort చేసి, తరువాత ప్రతి పేరును ప్రత్యేక argument గా rm ను అమలు చేస్తుంది. Pattern ఉపయోగించబడిందని rm` program గుర్తించలదు.

Globbing గురించి ఆశ్చర్యంగా అనిపించే దాదాపు ప్రతి విషయం ఈ ఒక్క వాస్తవం నుంచే వస్తుంది. Matching ను shell, ఆ క్షణంలో ఉన్న files కు వ్యతిరేకంగా చేస్తుంది. Command కు పూర్తయిన జాబితా మాత్రమే కనిపిస్తుంది. దీనికి అధికారిక పేరు pathname expansion. రోజువారీ వాడుకలో దీనిని globbing అంటారు. రెండు పదాల అర్థం ఒకటే.

అభ్యాసం కోసం చిన్న tree ను సృష్టించండి

క్రింద ఉన్న ప్రతి ఉదాహరణ ఒకే files పై పనిచేస్తుంది. వాటిని temporary directory లో సృష్టించండి. మీరు అవసరంగా భావించే ఇతర files అక్కడ ఉండవు, అలాగే cleanup ను ఒక command తో చేయవచ్చు.

lab=$(mktemp -d)
cd "$lab"
mkdir -p logs archive/2025 archive/2026
touch app.log app.log.1 app.log.2 app.log.10 error.log debug.LOG
touch notes.txt notes.md README 'weekly report.log'
touch .env .apprc
touch logs/nginx.log logs/nginx.log.1
touch archive/2025/dec.log archive/2026/jan.log

mktemp -d కొత్త directory ను సృష్టించి, దాని path ను return చేస్తుంది. $(...) ఆ path ను lab variable లోకి capture చేస్తుంది. ఈ syntax మీకు కొత్తగా ఉంటే, command యొక్క output ను command substitution ఎలా capture చేస్తుందో ఇందులో పూర్తిగా వివరించబడింది.

మీరు సృష్టించినదాన్ని పరిశీలించండి. అలాగే మీ shell ను తనిఖీ చేయండి, ఎందుకంటే చివర్లోని ఒక గమనిక version పై ఆధారపడి ఉంటుంది:

ls -a
bash --version

ఇక్కడ ఉన్న ప్రతిదీ bash 4.0 మరియు తరువాతి versions లో పనిచేస్తుంది. చివర్లో ఉన్న globskipdots గమనిక bash 5.2 మరియు తరువాతి versions కు వర్తిస్తుంది. October 2026 నాటికి, Ubuntu 26.04 LTS లో bash 5.3, Ubuntu 24.04 LTS మరియు Debian 13 (trixie) లో bash 5.2 ఉన్నాయి. Ubuntu 22.04 LTS లో ఇంకా bash 5.1 ఉంది; ఆ version లో ఈ option అందుబాటులో లేదు.

మొత్తం tutorial లో ఉపయోగించే preview command printf '%s\n' PATTERN. ఇది ప్రతి match ను ఒక line లో print చేస్తుంది. Disk పై ఎలాంటి మార్పు చేయదు. అందువల్ల మీకు నమ్మకం లేని ఏ pattern పైనైనా దీన్ని సురక్షితంగా run చేయవచ్చు.

మూడు wildcards: star, question mark మరియు brackets

  • * ఖాళీగా ఉన్నదానితో సహా, characters యొక్క ఏదైనా వరుసకు సరిపోతుంది.
  • ? సరిగ్గా ఒక character కు సరిపోతుంది.
  • [...] brackets లోపల ఉన్న set నుంచి తీసుకున్న సరిగ్గా ఒక character కు సరిపోతుంది.
printf '%s\n' *.log
printf '%s\n' app.log.?
printf '%s\n' app.log.[0-9]
printf '%s\n' notes.*
printf '%s\n' *

మీరు రూపొందించిన file list తో రెండో line ను పోల్చండి. ? ఒక character కు మాత్రమే సరిపోతుంది; అంతకంటే ఎక్కువకు కాదు. అందువల్ల రెండు digits ఉన్న suffix ఆ pattern కు సరిపోదు. దాన్ని app.log.[0-9]* గా విస్తరించి, తేడాను చూడటానికి మళ్లీ run చేయండి.

ఈ మూడు wildcards కు రెండు నియమాలు వర్తిస్తాయి. ఏ wildcard కూడా ఎప్పుడూ / కు సరిపోదు. అందువల్ల pattern ఒకే directory level లోనే ఉంటుంది. అలాగే ప్రారంభంలో ఉన్న . ను అక్షరాలా type చేయాలి. కాబట్టి * తో ప్రారంభమయ్యే pattern ప్రతి hidden name ను దాటవేస్తుంది. అందుకే rm * మీ dotfiles ను మార్చకుండా ఉంచుతుంది.

Glob ఫలితాలు ప్రస్తుత locale యొక్క collation order ప్రకారం sorted గా వస్తాయి. ఇది character by character text sort. అందువల్ల 10 suffix, 2 suffix కంటే ముందు sorted అవుతుంది. పోలికలో వాటిలో దేనినీ number గా పరిగణించదు. printf '%s\n' app.log.* ను run చేసి, తరువాత ls -v app.log.* ను run చేసి రెండింటినీ పోల్చండి: ls -v embedded numbers ను వాటి value ప్రకారం sort చేస్తుంది. Pipeline లో అదే పని sort -V చేస్తుంది.

అక్షర తరగతులు మరియు పరిధులు

బ్రాకెట్లలో జాబితా, పరిధి లేదా నిరాకరణను రాయవచ్చు.

  • [ch] ఒక అక్షరాన్ని సరిపోలుస్తుంది; అది c లేదా h కావచ్చు.
  • [a-f] a నుంచి f వరకు ఉన్న పరిధిలోని ఒక అక్షరాన్ని సరిపోలుస్తుంది.
  • [!0-9] అంకె కాని ఒక అక్షరాన్ని సరిపోలుస్తుంది. [^0-9] కూడా ఇదే అర్థాన్ని ఇస్తుంది.
printf '%s\n' [dn]*
printf '%s\n' *.[A-Z]*
printf '%s\n' [A-Z]*

పరిధుల విషయంలో వేర్వేరు యంత్రాల మధ్య ఫలితాలు మారవచ్చు. పరిధి plain ASCII క్రమాన్ని కాకుండా ప్రస్తుత locale యొక్క collation order ఆధారంగా పరిష్కరించబడుతుంది. అందువల్ల కొన్ని సిస్టమ్‌లలో [a-z] పెద్ద అక్షరాలను కూడా సరిపోల్చవచ్చు. plain ASCII క్రమాన్ని బలవంతంగా ఉపయోగించే globasciiranges option Bashలో ఉంది. ఇటీవలి buildsలో ఇది defaultగా enable అయి ఉండవచ్చు. కాబట్టి ఊహించకుండా shopt globasciiranges ద్వారా మీ సిస్టమ్‌లోని అమరికను తనిఖీ చేయండి. ప్రతిచోటా ఒకే విధంగా సరిపోల్చాల్సిన script అయితే, పైభాగానికి సమీపంలో ప్రత్యేక lineలో LC_ALL=C ను set చేసి క్రమాన్ని స్వయంగా స్థిరపరచవచ్చు. అప్పుడు ప్రతి పరిధి తిరిగి plain byte orderను ఉపయోగిస్తుంది.

ఆ assignment స్వతంత్ర commandగా ఉండాలి. Prefixగా రాస్తే, LC_ALL=C ls [a-z]* కేవలం ls కోసం localeను set చేస్తుంది; మరేదానికీ కాదు. అంతేకాకుండా ls ప్రారంభమయ్యేలోపే shell తన స్వంత localeలో patternను expand చేసి ఉంటుంది. మొదటి sectionలో చెప్పిన నియమం ఇక్కడ మళ్లీ వర్తిస్తుంది.

Brace expansion globbing కాదు

Braces wildcard లాగా కనిపిస్తాయి, కానీ wildcard లాగా పనిచేయవు. Brace expansion, globbing కంటే చాలా ముందే జరుగుతుంది. ఇది disk ను ఎప్పుడూ పరిశీలించదు.

echo file{1,2,3}.txt
echo {01..10}
echo {a..e}
echo {0..20..5}

ఆ files ఏవీ లేవు. అయినప్పటికీ expansion జరుగుతుంది. ఇదే ప్రధాన తేడా: glob filesystem ను ప్రశ్నిస్తుంది, కానీ brace కేవలం text ను generate చేస్తుంది. అందుకే files ను కనుగొనడం కంటే సృష్టించడానికి braces సరైన సాధనం.

mkdir -p site/{css,js,img}
cp app.log{,.bak}
touch report-{2025,2026}-{01,02}.csv

cp app.log{,.bak} రెండు words గా విస్తరిస్తుంది: app.log మరియు app.log.bak. ఎందుకంటే comma కు ముందు ఉన్న ఖాళీ item అసలు text ను మళ్లీ ఉత్పత్తి చేస్తుంది. {01..10} తన zero padding ను కొనసాగిస్తుంది. ఎందుకంటే ఏదైనా endpoint కు ముందు zero ఉంటే, bash రూపొందించే ప్రతి number ను ఒకే width కు pad చేస్తుంది.

Expansion order వల్ల తరచుగా ఎదురయ్యే ఒక సమస్య కూడా అర్థమవుతుంది. Bash ముందుగా braces ను expand చేస్తుంది, తరువాత variables ను expand చేస్తుంది, చివరగా pathname expansion చేస్తుంది.

n=5
echo {1..$n}

$n number గా మారే సమయానికి Brace expansion ఇప్పటికే పూర్తయి ఉంటుంది. అందువల్ల ఏ range కూడా నిర్మించబడదు. seq 1 "$n" ను ఉపయోగించండి. లేదా for ((i=1; i<=n; i++)) గా రాసిన C-style loop ను ఉపయోగించండి.

ఏ pattern ఏదీ సరిపోలనప్పుడు ఏమి జరుగుతుంది

ఇది మొదటి విఫల పరిస్థితి. ప్రతి ఒక్కరూ కనీసం ఒకసారి దీనిలో చిక్కుకుంటారు. డిఫాల్ట్‌గా bash సరిపోలని pattern ను పూర్తిగా అలాగే ఉంచుతుంది. మీరు టైప్ చేసిన విధంగానే ఆ పదం command కు చేరుతుంది. అందువల్ల command *, ., t, m మరియు p అక్షరాలను స్వీకరించి, వాటిని filename లుగా పరిగణించడానికి ప్రయత్నిస్తుంది.

printf '%s\n' *.tmp

printf తో ఇది హానికరం కాదు. అయితే వస్తువులను సృష్టించే command తో ఇది హానికరం. .tmp files లేని directory లో touch *.tmp ను నడిపితే, దాని పేరు అక్షరాలా *.tmp గా ఉన్న file సృష్టించబడుతుంది. దాన్ని తరువాత తొలగించేటప్పుడు shell దాన్ని మళ్లీ expand చేయకుండా quoting ఉపయోగించాలి: rm -- '*.tmp'.

రెండు shell options ఈ నియమాన్ని మార్చుతాయి. ఏదీ సరిపోలని pattern పై ఒక్కో option ను పరీక్షించి, తరువాత దాన్ని unset చేయండి.

shopt -s nullglob
printf '%s\n' *.tmp
shopt -u nullglob

shopt -s failglob
printf '%s\n' *.tmp
shopt -u failglob

nullglob సరిపోలని pattern ను పూర్తిగా ఏమీ లేకుండా expand చేస్తుంది. అందువల్ల మీరు రాసిన దానికంటే తక్కువ arguments తో command నడుస్తుంది. Loop లో ఇది అవసరమైన ప్రవర్తన. nullglob off లో ఉన్నప్పుడు, for f in *.tmp తన body ని ఒకసారి నడుపుతుంది. ఆ సమయంలో f లో literal pattern ఉంటుంది. ఇలా చేసే దాదాపు ప్రతి script లో ఇది bug అవుతుంది. nullglob on లో ఉన్నప్పుడు body zero సార్లు నడుస్తుంది.

nullglob కు ప్రత్యేకమైన ప్రమాదం ఉంది. దాని అన్ని arguments తొలగించబడినా command నడుస్తూనే ఉంటుంది. ls *.nope అనేది ఖాళీ ls గా మారుతుంది. ఇది మొత్తం directory ని list చేస్తుంది. grep -l needle *.nope అనేది grep -l needle గా మారుతుంది. చదవడానికి దానికి file ఏదీ ఉండదు. అందువల్ల అది standard input కోసం వేచి ఉండి, frozen అయినట్లు కనిపిస్తుంది. అవసరమైన loop చుట్టూ nullglob ను on చేయండి. Loop తర్వాత మళ్లీ off చేయండి.

failglob మరో విధానాన్ని అనుసరిస్తుంది. సరిపోలని pattern ను error గా పరిగణిస్తుంది. bash దాన్ని report చేస్తుంది. Command అసలు నడవదు. Interactive shell కు ఇది మంచి setting. తప్పుగా టైప్ చేసిన pattern ను literal name గా rm కు పంపకుండా ఇది ఆపుతుంది.

దాచిన ఫైళ్లు: dotglob

shopt -s dotglob
printf '%s\n' *
shopt -u dotglob

ఆ block ను అమలు చేసి, ఆ listing ను ముందుగా ఉన్న సాధారణ printf '%s\n' * తో పోల్చండి. dotglob ప్రారంభ dot నియమాన్ని తొలగిస్తుంది. అందువల్ల * దాచిన పేర్లతో కూడా సరిపోతుంది. ఇది * ను . లేదా .. వరకు చేరనివ్వదు. ఎందుకంటే dotglob ఉన్నప్పటికీ, ఆ రెండు పేర్లను సరిపోల్చే pattern కూడా dot తోనే ప్రారంభం కావాలి.

dotglob లేకుండా దాచిన ఫైళ్లను చేరుకునే సాధారణ మార్గం .*. అయితే గతంలో ఇది ప్రమాదకరంగా ఉండేది. 5.2 కంటే ముందు ఉన్న bash లో, dotglob సెట్ చేసినా చేయకపోయినా, .* కూడా . మరియు .. కు సరిపోలేది. అందువల్ల chmod -R 755 .* వంటి recursive command నేరుగా parent directory లోకి వెళ్లేది. Bash 5.2 లో globskipdots option చేర్చబడింది. ఇది default గా enabled అయి ఉంటుంది. ప్రతి expansion నుంచి . మరియు .. ను ఇది తొలగిస్తుంది. దానిపై ఆధారపడే ముందు shopt globskipdots ను అమలు చేయండి. పాత system లో ఈ option ఉండకపోవచ్చు. కొత్త system లో ఇది off చేసి ఉండవచ్చు.

globstar: ట్రీలో అన్ని స్థాయిల్లో matching

shopt -s globstar
printf '%s\n' **/*.log
printf '%s\n' **/
shopt -u globstar

globstar సెట్ అయి ఉంటే, పూర్తి path component గా ఉండే **, సున్నా స్థాయితో సహా ఏ లోతులోనైనా ఉన్న files మరియు directories కు match అవుతుంది. అందువల్ల **/*.log ప్రస్తుత directory తో పాటు logs/ మరియు archive/ కింద ఉన్న ప్రతిదానినీ కూడా కవర్ చేస్తుంది. చివరలో slash ఉన్న **/ directories కు మాత్రమే match అవుతుంది. దీంతో ట్రీ నిర్మాణాన్ని త్వరగా చూడవచ్చు.

globstar సెట్ చేయకపోతే, ** సాధారణ * లా పనిచేసి ఒకే directory లో పరిమితం అవుతుంది. option ఆఫ్‌లో ఉంచి అదే pattern ను అమలు చేసి ఫలితాలను పోల్చండి. వేరే చోటు నుంచి కాపీ చేసిన recursive pattern మీరు ఆశించిన దానికంటే చాలా తక్కువ ఫలితాలను ఇస్తే, సాధారణంగా కారణం ఇదే. ప్రతి bash లో globstar డిఫాల్ట్‌గా ఆఫ్‌లో ఉంటుంది.

తెలుసుకోవాల్సిన ఒక పరిమితి ఉంది: ** directories కు ఉన్న symbolic links ను అనుసరించదు. symbolic links తో కలిపిన ట్రీ కోసం find -L అవసరం.

nocaseglob, పెద్దచిన్న అక్షర భేదాన్ని పట్టించుకోని పేర్ల కోసం

shopt -s nocaseglob
printf '%s\n' *.log
shopt -u nocaseglob

nocaseglob ఫైల్ పేర్ల సరిపోలింపులో పెద్దచిన్న అక్షర భేదాన్ని విస్మరిస్తుంది. అందువల్ల పెద్ద అక్షరాలతో ఉన్న .LOG suffix, చిన్న అక్షరాలతో ఉన్న .log pattern కు సరిపోతుంది. ఈ listing ను మొదటి section లో ఉన్న listing తో పోల్చండి. ఈ option ను వెంటనే మళ్లీ off చేయండి. ఇది on లో ఉంటే, ఆ shell లో తరువాత అమలు చేసే ప్రతి command కు matching విధానం మారుతుంది. ఒక గంట తర్వాత దీన్ని debug చేయడం గందరగోళంగా ఉంటుంది.

nocaseglob ఫైల్ పేరు expansion కు మాత్రమే వర్తిస్తుంది. case statement లో లేదా double bracket test లో pattern matching కోసం ఉపయోగించే సంబంధిత option nocasematch. ఈ రెండు options ను విడిగా set చేయాలి.

extglob: “ఇది కాకుండా” అని చెప్పగల patterns

Extended patterns డిఫాల్ట్‌గా ఆఫ్‌లో ఉంటాయి. వాటిని ప్రత్యేక లైన్‌లో ఆన్ చేయండి:

shopt -s extglob

ఇవికి ఐదు రూపాలు ఉన్నాయి. ప్రతి రూపం | తో వేరు చేసిన patterns జాబితాను స్వీకరిస్తుంది:

  • ?(list) సున్నా లేదా ఒక occurrence కు సరిపోతుంది.
  • *(list) సున్నా లేదా అంతకంటే ఎక్కువ occurrences కు సరిపోతుంది.
  • +(list) ఒకటి లేదా అంతకంటే ఎక్కువ occurrences కు సరిపోతుంది.
  • @(list) ప్రత్యామ్నాయాల్లో ఖచ్చితంగా ఒకదానికి సరిపోతుంది.
  • !(list) ఏ ప్రత్యామ్నాయానికీ సరిపోని దేనికైనా సరిపోతుంది.

Extended pattern ను option ఇప్పటికే ఆన్‌లో ఉన్న shell చదవాలి. అందువల్ల దిగువ batch, bash -O extglob తో ప్రారంభించే చిన్న script లో ఉండాలి. కొత్త shell ఫైల్‌లోని ఒక్క లైన్‌ను చదవకముందే shopt option ను సెట్ చేయడానికి -O flag ఉపయోగపడుతుంది. అందువల్ల అందులోని ప్రతి pattern సరిగ్గా parse అవుతుంది. క్రమం ఎందుకు ముఖ్యమో ఈ section లోని చివరి paragraph వివరిస్తుంది.

cat > patterns.sh <<'EOF'
printf '%s\n' @(app|error).log
printf '%s\n' app.log.+([0-9])
printf '%s\n' *.@(md|txt)
printf '%s\n' !(*.log)
printf '%s\n' !(*.log|*.md|README)
EOF
bash -O extglob patterns.sh

+([0-9]) అంటే ఒకటి లేదా అంతకంటే ఎక్కువ digits. అందువల్ల ఇది ఏ పొడవున్న numbered suffix కైనా సరిపోతుంది. ఇదే ఇంతకుముందు ఉన్న ? పరిమితికి పరిష్కారం. రెండు patterns ను వరుసగా అమలు చేసి ఫలితాన్ని చూడటం ఉపయోగకరం.

“దీనిని మినహాయించి మిగతావన్నీ” అనే అవసరానికి negation రూపం సమాధానం. extglob ను ఆన్ చేయడానికి ఇదే ప్రధాన కారణం. ఇందులో రెండు విషయాలు చాలామందికి ఆశ్చర్యం కలిగిస్తాయి.

ఇది files తో పాటు directories కు కూడా సరిపోతుంది. అందువల్ల ls !(*.log) ఫలితంలో directory name కు బదులుగా ఆ directory లోని contents ను చూపిస్తుంది. పేర్లను మాత్రమే చూడటానికి ls -d లేదా printf preview ను ఉపయోగించండి.

ప్రతి ఇతర glob లాగే ఇది dot rule ను కూడా అనుసరిస్తుంది. అందువల్ల !(*.log), .log తో ముగియని ప్రతి visible name కు సరిపోతుంది. Hidden names కోసం dotglob ను కూడా సెట్ చేయాలి.

!(...) లోని ! glob negation. దీనికి history expansion మరియు bang character తో ఎలాంటి సంబంధం లేదు. అది వేరే stage లో అమలయ్యే ప్రత్యేక feature.

ఇంకో సమస్య parse time లోనే వస్తుంది. Bash పూర్తి command ను అమలు చేయడానికి ముందు parse చేస్తుంది. అందువల్ల extglob ను ఆన్ చేసి, అదే line లో extended pattern ను ఉపయోగిస్తే విఫలమవుతుంది. Option ఇంకా ఆఫ్‌లో ఉన్నప్పుడే pattern parse అవుతుంది. shopt -s extglob ను patterns కు ముందు, ప్రత్యేక line లో, script పైభాగానికి సమీపంలో ఉంచండి. Function body, function నిర్వచించినప్పుడు parse అవుతుంది. కాబట్టి call కు ముందు కాకుండా definition కు ముందే option ఆన్‌లో ఉండాలి. పై batch చేసినట్లుగా bash -O extglob తో shell ను ప్రారంభిస్తే, parsing ప్రారంభమయ్యే ముందే క్రమం సరిగ్గా అమలవుతుంది.

Shell pattern ను విస్తరిస్తుంది, command కాదు

ఇది రెండవ వైఫల్య విధానం. దీనివల్ల ఒకే రకమైన అనేక bugs ఎలా ఏర్పడతాయో అర్థమవుతుంది.

grep -l needle *.log
find . -name '*.log'
find . -name *.log

మొదటి line లో matching ను bash నిర్వహిస్తుంది. grep కు filenames జాబితా అందుతుంది. రెండవ line pattern ను quotes లో ఉంచుతుంది. అందువల్ల find కు *.log అనే ఐదు characters అందుతాయి. అది starting point కింద ప్రతి depth వద్ద తనంతట తానే matching చేస్తుంది. మూడవ line లోనే bug ఉంది. bash ముందుగా pattern ను ప్రస్తుత directory కి మాత్రమే సరిపడేలా expand చేస్తుంది. అందువల్ల find ఒక నిర్దిష్ట name కోసం వెతకమని ఆదేశించబడుతుంది. ఒక directory లో ఒక్క match మాత్రమే ఉంటే, అది తప్పు విషయం కోసం నిశ్శబ్దంగా వెతుకుతుంది. రెండు లేదా అంతకంటే ఎక్కువ matches ఉంటే, find usage error చూపిస్తుంది. ఎందుకంటే అదనపు names expression ఉండాల్సిన స్థానంలోకి వస్తాయి.

నియమం చిన్నదే. Pattern command కోసం ఉద్దేశించినదైతే, దాన్ని quotes లో ఉంచండి. Pattern shell కోసం ఉద్దేశించినదైతే, దాన్ని quotes లేకుండా ఉంచండి. ఇదే విభజన tar లోని --exclude patterns కు, అలాగే grep లోని --include filters కు వర్తిస్తుంది. rsync కూడా ఇందులో భాగమే.

Globs regular expressions కావు, అయితే రెండింటిలోనూ కొన్ని characters ఒకేలా ఉంటాయి. Glob లో * అంటే characters యొక్క ఏదైనా వరుస. Regular expression లో * అంటే దానికి ముందు ఉన్న అంశం zero లేదా అంతకంటే ఎక్కువ సార్లు రావడం. అందువల్ల grep '*.log', కనిపిస్తున్న అర్థానికి భిన్నమైనదాన్ని కోరుతుంది.

Variables కూడా ఇదే operations క్రమాన్ని అనుసరిస్తాయి. Variable expansion తర్వాత globbing జరుగుతుంది. అందువల్ల pattern ను కలిగి ఉన్న unquoted variable directory కి వ్యతిరేకంగా expand అవుతుంది.

pat='*.log'
printf '%s\n' $pat
printf '%s\n' "$pat"

Quotes లేకుండా ఉంచితే, variable ఫలితాన్ని bash glob చేస్తుంది. Quotes లో ఉంచితే, pattern literal గానే ఉంటుంది. దీనికి సంబంధించిన మరో ఫలితాన్ని గుర్తుంచుకోవాలి: globbing ద్వారా ఏర్పడిన words ను spaces ఆధారంగా మళ్లీ split చేయదు. అందువల్ల for f in *.log space ఉన్న filename ను ఒక name గా నిర్వహిస్తుంది. for f in $(ls *.log) మాత్రం ఆ name ను రెండు words గా విడగొడుతుంది. Glob పై నేరుగా loop చేయండి.

Destructive pattern ను అమలు చేయడానికి ముందు preview చూడండి

కొత్త pattern తో మొదట ప్రయత్నించే command గా rm ను ఎప్పుడూ ఉపయోగించవద్దు. Pattern ను హానికరం కాని command తో అమలు చేయండి. జాబితాను చదవండి. తరువాత line ప్రారంభంలోని command ను మాత్రమే మార్చండి.

target='!(*.log)'
printf '%s\n' $target
ls -ld -- $target
rm -- $target

Pattern ను ఒక్కసారి target లో రాయడం వల్ల మూడు lines వేరువేరుగా మారకుండా ఉంటాయి. $target ను ఉద్దేశపూర్వకంగా quotes లేకుండా ఉంచారు, ఎందుకంటే అలా ఉంచినప్పుడే bash దాన్ని expand చేస్తుంది. printf '%s\n' ప్రతి name ను ఒక్కో line లో print చేస్తుంది. ఏదీ మార్చదు. ls -ld ప్రతి entry ను స్వతంత్రంగా చూపిస్తుంది; directories లోని contents ను list చేయదు. Mode column ఏ entries directories అనేది చూపిస్తుంది. Recursive delete కు ముందు తనిఖీ చేయాల్సింది ఇదే. drwxr-xr-x permission bits ను చదవడం లో ఆ column గురించి వివరించబడింది.

మునుపటి line ను up arrow తో మళ్లీ తీసుకురండి. Pattern అలాగే ఉండేలా command ను మాత్రమే edit చేయండి. జ్ఞాపకం నుంచి pattern ను మళ్లీ type చేయడంలోనే పొరపాటు చొరబడుతుంది.

Pattern కు ముందు -- ఉంచండి. ఇది options ముగిసినట్లు సూచిస్తుంది. అందువల్ల - తో ప్రారంభమయ్యే filename flag గా కాకుండా name గా పరిగణించబడుతుంది.

Script లోని కొంత భాగానికి globbing ను ఆపివేయాలనుకుంటే, set -f దాన్ని disable చేస్తుంది. set +f దాన్ని మళ్లీ enable చేస్తుంది.

rm కు undo ఉండదు కాబట్టి ఈ అలవాటు ముఖ్యం. rm -rf తో తొలగించిన files ను తిరిగి పొందడం నెమ్మదిగా జరుగుతుంది మరియు సాధారణంగా కొంత భాగం మాత్రమే తిరిగి పొందగలిగేలా ఉంటుంది. అందువల్ల preview చేయడం ప్రత్యామ్నాయంతో పోలిస్తే చాలా తక్కువ ఖర్చుతో పూర్తవుతుంది.

పని పూర్తయ్యాక practice directory ను clean up చేయండి. Path ను print చేసి ముందుగా చదవండి. ఎందుకంటే తప్పు variable ను సూచించే rm -rf ఈ section వివరిస్తున్న ప్రమాదమే.

cd ~
echo "$lab"
rm -rf -- "$lab"

FAQ

find . -name *.log తప్పు ఫైళ్లను ఎందుకు కనుగొంటుంది?

ఎందుకంటే find ప్రారంభమయ్యేలోపే bash *.log ను విస్తరిస్తుంది. Shell ప్రస్తుత directory లో pattern కు సరిపడే పేర్లను గుర్తించి, వచ్చిన filename ను find కు పంపుతుంది. find ఆ ఒక్క పేరును ప్రతి directory స్థాయిలో వెతుకుతుంది. రెండు లేదా అంతకంటే ఎక్కువ ఫైళ్లు సరిపోతే, expression ఉండాల్సిన చోట find కు అదనపు arguments అందుతాయి. అప్పుడు అది usage error చూపిస్తుంది. Pattern ను find . -name '*.log' గా quote చేయండి. అప్పుడు find తన స్వంత నియమాలు మరియు recursion తో matching చేస్తుంది.

నా pattern అక్షరాలా కనిపిస్తే దాని అర్థం ఏమిటి?

ఏదీ సరిపోలలేదని అర్థం. సాధారణంగా unmatched pattern ను bash అలాగే ఉంచి, raw characters ను command కు పంపుతుంది. ఆ command వాటిని filename గా పరిగణిస్తుంది. Unmatched pattern ను command ఆపే error గా మార్చడానికి shopt -s failglob ను సెట్ చేయండి. లేదా అది ఏమీ విస్తరించకుండా ఉండేందుకు shopt -s nullglob ను సెట్ చేయండి. nullglob ఉపయోగించినప్పుడు arguments ఏవీ లేకపోయినా command సరిగ్గా పనిచేస్తుందో తనిఖీ చేయండి. ఎందుకంటే ls *.nope ఒక bare ls గా మారి మొత్తం directory ను జాబితా చేస్తుంది.

bash లో ఒక pattern మినహా ప్రతి ఫైలుతో ఎలా match చేయాలి?

ఒక ప్రత్యేక line లో shopt -s extglob ను ఉపయోగించి extended patterns ను enable చేయండి. తరువాత negation రూపాన్ని ఉపయోగించండి. !(*.log), .log తో ముగియని పేర్లకు match అవుతుంది. !(*.log|*.md) రెండింటినీ మినహాయిస్తుంది. dotglob కూడా set చేయకపోతే hidden files ఫలితంలో ఉండవు. Directories కూడా చేర్చబడతాయి. అందువల్ల pattern ను rm కు అందించే ముందు printf '%s\n' !(*.log) తో preview చేయండి.

* hidden files ను ఎందుకు వదిలేస్తుంది?

ప్రారంభ dot ను అక్షరాలా match చేయాలి. అందువల్ల *, dot తో ప్రారంభమయ్యే పేర్లకు ఎప్పుడూ match కాదు. Hidden names ను చేరుకోవడానికి .* ను ఉపయోగించండి. లేదా సాధారణ ప్రతి pattern లో వాటిని చేర్చడానికి shopt -s dotglob ను set చేయండి. dotglob ఉపయోగించినప్పటికీ *, . లేదా .. కు ఎప్పుడూ match కాదు. ఆ రెండు పేర్లకు ప్రారంభంలో dot ఉన్న pattern మాత్రమే match అవుతుంది. Bash 5.2 మరియు తరువాతి versions, default గా on ఉన్న globskipdots option ద్వారా వాటిని .* లో కూడా చేర్చవు.

** పనిచేయడానికి globstar అవసరమా?

అవును. shopt -s globstar లేకుండా bash, ** ను సాధారణ * గా పరిగణిస్తుంది. అది ఒక directory లోపల match చేసి అక్కడే ఆగిపోతుంది. globstar on ఉన్నప్పుడు, పూర్తి path component గా ఉన్న ** ఏ directory depth లోనైనా match అవుతుంది. అందువల్ల **/*.log ప్రస్తుత directory మరియు దాని కింద ఉన్న ప్రతి subdirectory ను చేరుతుంది. **/ ను ఒంటరిగా ఉపయోగిస్తే directories కు మాత్రమే match అవుతుంది. ** directories కు ఉన్న symbolic links ను follow చేయదు. అందువల్ల symlinks తో నిర్మించిన tree కోసం find -L ను ఉపయోగించండి.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?

#bash#globbing#shell#linux#scripting