Shell Metacharacters and Operators: Filename Expansion (wildcards *, ?, []), Input/Output Redirection (>, >>, <), Pipes (|), Command Substitution ($(...))

📖 Theory

મહાશક્તિ ધરાવતા અક્ષરો

કેટલાક અક્ષરોનો shell માટે ખાસ અર્થ થાય છે. તમે * ટાઇપ કરો ત્યારે shell શબ્દશઃ 'તારો' નામની file શોધતું નથી, પણ એને files નાં નામ સાથે મેળવવા માટે ફેલાવે છે. તમે > ટાઇપ કરો ત્યારે તમે મોટાનું ચિહ્ન છાપતા નથી, પણ પરિણામને file માં વાળી રહ્યા છો.

આવા ખાસ અક્ષરોને metacharacters (અને operators) કહે છે, અને એ સાદા commands ને શક્તિશાળી એક લીટીની આજ્ઞાઓમાં ફેરવી નાખે છે. આ પાઠ એમાંના પાયાના અક્ષરો આવરી લે છે: wildcards, redirection, pipes અને command substitution. આ બધા પર પકડ આવે એટલે command line ની ક્ષમતા ધરખમ રીતે વધી જાય છે.

📊 At a glance

⌨️ Practical

Metacharacters કામ કરતાં (ચકાસાયેલું)

$ ls *.txt              # wildcard: every name ending in .txt
a1.txt  a2.txt  out.txt
$ ls ?1.*              # ? = one char: names like a1.xxx, b1.xxx
a1.txt  b1.log

$ echo "line1" > out.txt    # > creates/overwrites out.txt
$ echo "line2" >> out.txt   # >> appends a second line
$ wc -l < out.txt           # < feeds the file in as input
2

$ echo "There are $(ls *.txt | wc -l) txt files"   # pipe + substitution
There are 3 txt files

✏️ Formula

Redirection files તરફ જાય છે; pipes commands તરફ

બે વિચારો અલગ રાખો. Redirection એ command ને file સાથે જોડે છે: > અને >> પરિણામને file માં મોકલે છે, જ્યારે < file માંથી input વાંચે છે. Pipe | એ command ને બીજા command સાથે જોડે છે: એ પહેલાનું પરિણામ સીધું બીજામાં ખવડાવે છે, અને વચ્ચે કોઈ file હોતી નથી.

એટલે sort names.txt > sorted.txt ગોઠવેલું પરિણામ file માં મૂકે છે, જ્યારે sort names.txt | uniq ગોઠવેલું પરિણામ uniq માં ખવડાવે છે. એક બાજુ files, બીજી બાજુ commands: આ ભેદ સમજાય એટલે મોટા ભાગની ગૂંચ ઊકલી જાય છે.

🧩 Quiz

તમે ચલાવો છો: echo "first" > log.txt , અને પછીથી echo "second" > log.txt (બંનેમાં એક જ >). log.txt માં શું હશે?

1. બંને લીટીઓ: first અને second
2. ફક્ત 'second', કારણ કે એકલો > દર વખતે file ઉપર લખી નાખે છે
3. ફક્ત 'first', કારણ કે file પહેલેથી બની ચૂકી હતી
4. કશું નહીં; > એ file ને ભૂંસી નાખે છે

💭 Think first

> અને >> ને ગૂંચવવા એ આટલી જોખમી ભૂલ કેમ છે?

બંને file માં લખે છે. તો પછી અનુભવી વપરાશકારો એકલા > ને આટલી સાવધાનીથી કેમ વાપરે છે? વિચારીને પછી tap કરો.

✅ Summary

Key takeaways

• Metacharacters એટલે shell જેમને ખાસ રીતે લે છે એવા અક્ષરો, જે સાદા commands ને શક્તિશાળી એક લીટીની આજ્ઞાઓ બનાવે છે.
• Wildcards files નાં નામ ફેલાવે છે: * ગમે તેટલા અક્ષરો સાથે મેળવે છે, ? બરાબર એક સાથે, અને [ ] અક્ષરોના સમૂહ સાથે.
• Redirection command ને file સાથે જોડે છે: > ઉપર લખી નાખે છે, >> અંતે ઉમેરે છે, અને < file માંથી input વાંચે છે.
• Pipe | એ command ને બીજા command સાથે જોડે છે, અને વચ્ચે કોઈ file વગર પરિણામ સીધું ખવડાવે છે.
• Command substitution $(cmd) ની જગ્યાએ એ command નું પરિણામ મુકાય છે, અને એ સીધું તમારી લીટીમાં આવી જાય છે.
• જોખમ: એકલો > ઉપર લખી નાખે છે (અને હયાત લખાણનો નાશ કરે છે) જ્યારે >> અંતે ઉમેરે છે; ઉમેરવું હોય ત્યારે મૂળભૂત રીતે >> વાપરો.
• યાદ રાખવાની કડી: * એટલે ઘણા, ? એટલે એક, > એટલે ઉપર લખવું, >> એટલે ઉમેરવું, | એટલે command ને ખવડાવવું, $(...) એટલે પરિણામ મૂકવું.