Theory
નાનાં ઓજારો, મોટા પ્રશ્નો
Server પરની એક log ની file માં 10000 લીટીઓ છે. તમને એમાંથી ફક્ત છેલ્લી 20 જોઈએ છે. અથવા દરેક error કેટલી વાર આવે છે એની ગણતરી જોઈએ છે. અથવા data ની file નો ત્રીજો સ્તંભ જોઈએ છે. Linux આના માટે એક જંગી program આપતું નથી; એ લખાણનાં નાનાં ઓજારો ઘણાં આપે છે, અને દરેક પોતાનું એક જ કામ સરસ રીતે કરે છે.
આ કુટુંબમાં head, tail, cut, sort, uniq, wc, tr, cmp અને tee આવે છે. દરેક લખાણ વાંચે છે અને લખાણ લખે છે, અને, જેમ તમે જોશો, એમને સાંકળીને વાપરવા માટે જ ઘડવામાં આવ્યાં છે. આ પાઠ એમનો પરિચય આપે છે અને એ સાંકળવાની ઝલક દેખાડે છે.
At a glance
| Command | એ શું કરે છે |
|---|---|
| head -n N | પહેલી N લીટીઓ દેખાડે છે |
| tail -n N | છેલ્લી N લીટીઓ દેખાડે છે |
| cut -d D -f N | D ને વિભાજક ગણીને N મું ખાનું કાઢી આપે છે |
| sort | લીટીઓને ક્રમમાં ગોઠવે છે |
| uniq | પાસે પાસે આવેલી સરખી લીટીઓને એક કરી દે છે (uniq -c એમને ગણે છે) |
| wc | લીટીઓ (-l), શબ્દો (-w) કે bytes (-c) ગણે છે |
| tr | અક્ષરો બદલે છે કે કાઢી નાખે છે (દા.ત. tr a-z A-Z) |
| cmp / tee | બે files સરખાવે છે / file માં લખે અને પરિણામ આગળ પણ મોકલે |
Practical
ઉકેલેલા દાખલા (ચકાસાયેલું પરિણામ)
$ cat fruits.txt
banana
apple
cherry
apple
$ wc -l fruits.txt # count lines
4 fruits.txt
$ sort fruits.txt | uniq -c # sort, then count each unique line
2 apple
1 banana
1 cherry
$ head -2 fruits.txt # first 2 lines
banana
apple
$ echo "hello" | tr a-z A-Z # translate lowercase to uppercase
HELLOFormula
આ ગાળણ ઓજારો છે, pipe થી જોડવા માટે જ બનેલાં
આમાંનું દરેક ઓજાર standard input માંથી વાંચે છે અને standard output માં લખે છે. એનો અર્થ એ કે તમે એકનું પરિણામ સીધું બીજામાં નાખી શકો છો, અને એ માટે pipe નું ચિહ્ન | વપરાય છે, જેનો વ્યવસ્થિત અભ્યાસ તમે Unit 3 માં કરશો.
ખરી તાકાત એ જ છે: sort fruits.txt | uniq -c ક્રમમાં ગોઠવેલી લીટીઓ uniq માં મોકલે છે જેથી એ એમને ગણી શકે. થોડાંક નાનકડાં ઓજારો ભેગાં થઈને એવા પ્રશ્નોના જવાબ આપે છે જે એકલું કોઈ ઓજાર આપી ન શકે. 'એક કામ સરસ કરો, પછી જોડો' નો આ વિચાર જ Linux ની command line નું હૃદય છે.
Quiz
તમારી file માં આ ક્રમે લીટીઓ છે: banana, apple, cherry, apple. તો sort file | uniq માં uniq પહેલાં sort કેમ ચલાવો છો?
- sort તો ફક્ત શણગાર છે; uniq આખી file માં ગમે ત્યાં પડેલી નકલો કાઢી નાખે છે
- uniq ફક્ત પાસે પાસે આવેલી સરખી લીટીઓને જ એક કરે છે, એટલે પહેલાં ગોઠવવાથી સરખી લીટીઓ પાસે આવે અને uniq એમને ભેગી કરી શકે
- sort જ નકલો કાઢી નાખે છે, એટલે uniq ની જરૂર જ નથી
- uniq ને પહેલાં file મોટા અક્ષરોમાં જોઈએ છે
Show the answer
uniq ફક્ત પાસે પાસે આવેલી સરખી લીટીઓને જ એક કરે છે, એટલે પહેલાં ગોઠવવાથી સરખી લીટીઓ પાસે આવે અને uniq એમને ભેગી કરી શકે
uniq ફક્ત પાસે પાસે આવેલી (એટલે એકદમ બાજુ બાજુમાં પડેલી) નકલો જ કાઢે છે. મૂળ ક્રમમાં (banana, apple, cherry, apple) બંને 'apple' લીટીઓ પાસે પાસે નથી, એટલે એકલું uniq એમને ભેગી કરી શકે નહીં. પહેલાં ગોઠવવાથી બધી સરખી લીટીઓ સાથે આવી જાય છે (apple, apple, banana, cherry), અને પછી uniq એમને એક કરી શકે છે; એટલા માટે જ sort | uniq એ રૂઢ પ્રયોગ છે. વિકલ્પ A ખોટો છે: ગોઠવ્યા વગર uniq પાસે પાસે ન હોય એવી નકલો ચૂકી જાય છે. વિકલ્પ C ખોટો છે: sort લીટીઓ ક્રમમાં ગોઠવે છે, નકલો કાઢતું નથી (એ uniq નું કામ છે, અથવા sort -u નું). વિકલ્પ D બનાવટી છે. જોડી યાદ રાખો: પહેલાં sort અને પછી uniq, કારણ કે uniq ફક્ત પડોશીઓને જ જુએ છે.
Think first
એક મોટા ઓજારને બદલે આટલાં બધાં નાનાં ઓજારો કેમ?
Linux લખાણ માટે એક શક્તિશાળી program આપવાને બદલે ડઝનેક નાના commands કેમ આપે છે? વિચારીને પછી tap કરો.
Show the answer
કારણ કે એક જ કામ કરતાં અને જોડી શકાય એવાં નાનાં ઓજારો એક મોટા અને જડ program કરતાં વધુ લવચીક અને વધુ વાર કામ લાગે એવાં હોય છે; આ જ પ્રખ્યાત Unix ની ફિલસૂફી છે: 'એક કામ સરસ કરો, અને સાથે મળીને કામ કરો'. દરેક ઓજારને, એટલે કે sort, uniq, cut, wc ને, એક જ સ્પષ્ટ કામ છે, જેથી એ શીખવામાં સહેલું, ભરોસો મૂકવામાં સહેલું અને સાચવવામાં સહેલું બને છે. તાકાત એમને pipes થી જોડવામાં છે: દરેક ઓજાર standard input વાંચતું અને standard output લખતું હોવાથી તમે એમને અનંત સંયોજનોમાં એકબીજા સાથે જડી શકો છો અને એવી સમસ્યાઓ ઉકેલી શકો છો જેની કોઈએ કલ્પના પણ કરી ન હોય. Log માં સૌથી વધુ વાર આવતી ત્રણ errors જોઈએ છે? error વાળો સ્તંભ cut કરો, એને sort કરો, ગણવા uniq -c કરો, ક્રમ આપવા sort -rn કરો, અને ટોચનાં લેવા head -3 કરો; તમે પહેલેથી જાણો છો એવાં પાંચ નાનકડાં ઓજારો, ત્યાં ને ત્યાં ગોઠવી દીધાં. એક જંગી 'લખાણનો program' આવી દરેક જરૂરિયાતની અગાઉથી કલ્પના કરી શકે નહીં, પણ નાનાં અને જોડી શકાય એવાં ઓજારો તમને તમારી જોઈતી ચોક્કસ pipeline બાંધવા દે છે. ઓજારદીઠ ઓછાં લક્ષણો, પણ સંયોજનો અમાપ: એટલા માટે જ ઓજારપેટી પેલા એકાકી ઢાંચાને હરાવે છે, અને એટલા માટે જ આ નાના commands શીખવાનું ફળ એમની પોતાની સાદગી કરતાં ઘણું આગળ સુધી મળે છે.
Summary
Key takeaways
- Linux લખાણનાં ઘણાં નાનાં ઓજારો આપે છે, અને દરેક એક જ કામ કરે છે: head, tail, cut, sort, uniq, wc, tr, cmp, tee.
- head -n પહેલી N લીટીઓ દેખાડે છે; tail -n છેલ્લી N; cut વિભાજક પ્રમાણે ખાનું કાઢી આપે છે; wc લીટીઓ, શબ્દો કે bytes ગણે છે.
- sort લીટીઓ ક્રમમાં ગોઠવે છે; uniq પાસે પાસે આવેલી નકલો એક કરે છે (uniq -c ગણે છે), એટલે uniq પહેલાં સામાન્ય રીતે sort કરવું પડે છે.
- tr અક્ષરો બદલે કે કાઢે છે (tr a-z A-Z મોટા અક્ષર કરે છે); cmp files સરખાવે છે; tee file માં લખે છે અને પરિણામ આગળ પણ મોકલે છે.
- આ ગાળણ ઓજારો છે: એ standard input વાંચે છે અને standard output લખે છે, એટલે pipe | થી જોડાય છે (Unit 3).
- નાનાં ઓજારોને pipes થી જોડવાથી એવા પ્રશ્નોના જવાબ મળે છે જે એકલો કોઈ command આપી ન શકે: આ જ Linux નો મુખ્ય વિચાર છે.
- યાદ રાખવાની કડી: એક કામ સરસ કરો, અને પછી એમને pipe થી જોડો.