Theory
Logs શોધવા
Campus ના server ની log ની file માં હજારો લીટીઓ છે, અને તમને ERROR કહેતી લીટીઓ જોઈએ છે. હાથે scroll કરવું નિરાશાજનક છે. આ grep નું રોજિંદું કામ છે: એને ભાત અને file આપો, અને એ મળતી દરેક લીટી છાપે છે.
grep એ આખા Linux માં સૌથી વધુ વપરાતા commands માંનું એક છે, અને એ ત્રણ સ્વાદમાં આવે છે, grep, egrep, અને fgrep, જે તમારી ભાતનું અર્થઘટન કેવી રીતે કરે છે એમાં જુદા પડે છે. આ પાઠ ત્રણેય દેખાડે છે અને એ મુઠ્ઠીભર flags પણ જે grep ને ખરેખર શક્તિશાળી બનાવે છે.
At a glance
| Command | એ ભાતને કેવી રીતે વાંચે છે |
|---|---|
| grep | Basic regular expressions (મૂળભૂત) |
| egrep (grep -E) | Extended regular expressions: |, +, ?, ( ) escape કર્યા વગર |
| fgrep (grep -F) | નિશ્ચિત શબ્દશઃ string: regex નહીં, ખાસ અક્ષરો પોતાની જાતને જ મેળવે છે |
| -i | Flag: અક્ષરોના સ્વરૂપને અવગણીને મેળવવું |
| -c / -n | Flag: મળતી લીટીઓ ગણવી / લીટીના ક્રમાંક દેખાડવા |
| -v | Flag: ઊલટાવો, જે લીટીઓ મળતી નથી એ દેખાડો |
Practical
grep એક log શોધે છે (ચકાસાયેલું)
$ grep "ERROR" log.txt # lines containing ERROR
ERROR disk full
ERROR timeout
$ grep -c "ERROR" log.txt # count them instead
2
$ grep -i "info" log.txt # case-insensitive: INFO and info
INFO started
info lowercase
$ grep -E "ERROR|WARN" log.txt # extended: ERROR or WARN
ERROR disk full
ERROR timeout
WARN low memoryFormula
તમારી ભાતને બંધબેસતો પ્રકાર પસંદ કરો
તમારી ભાતને શું જોઈએ છે એ પ્રમાણે પસંદ કરો. સાદી ભાત કે basic regex માટે સાદું grep વાપરો. જ્યારે તમારી ભાત | (કે), +, કે જૂથ જેવાં extended લક્ષણો વાપરે ત્યારે egrep (કે grep -E) વાપરો, જેથી તમે એમને backslash વગર લખી શકો. જ્યારે તમને શબ્દશઃ string બરાબર મેળવવી હોય, અને . તથા * જેવા અક્ષરોને regex નહીં પણ પોતાની જાત તરીકે ગણવા હોય, ત્યારે fgrep (કે grep -F) વાપરો.
અને flags યાદ રાખો: -i અક્ષરોનું સ્વરૂપ અવગણે છે, -c ગણે છે, -n લીટીઓને ક્રમાંક આપે છે, -v જે મળતું નથી એ દેખાડે છે. આ grep ને શોધનારામાંથી ચોકસાઈભરી તપાસનું ઓજાર બનાવે છે.
Quiz
તમને ગણવું છે કે log.txt માં કેટલી લીટીઓમાં ERROR શબ્દ છે, અને એ પણ અક્ષરોના સ્વરૂપ પ્રમાણે. કયો command સૌથી સારો છે?
- grep -v "ERROR" log.txt, જે મળતાં ગણે છે
- grep -c "ERROR" log.txt, જે મળતી લીટીઓની સંખ્યા છાપે છે
- grep -i "ERROR" log.txt, જે મળતાં ગણે છે
- fgrep કોઈ flag વગર આપોઆપ ગણે છે
Show the answer
grep -c "ERROR" log.txt, જે મળતી લીટીઓની સંખ્યા છાપે છે
grep -c એ મળતી લીટીઓની સંખ્યા છાપે છે, એટલે grep -c "ERROR" log.txt સીધો આંકડો આપે છે (અહીં 2). વિકલ્પ A એ -v વાપરે છે, જે મેળને ઊલટાવે છે, એ ERROR વગરની લીટીઓ દેખાડત કે ગણત, જે તમને જોઈએ છે એનાથી ઊલટું. વિકલ્પ C એ -i (સ્વરૂપ અવગણતું) વાપરે છે અને, વધુ મહત્ત્વનું, એ ગણતું નથી, એ મળતી લીટીઓ પોતે છાપે છે; વળી -i નાના અક્ષરે લખાયેલા 'error' ને પણ મેળવત, જે 'સ્વરૂપ પ્રમાણે' ની શરત તોડે છે. વિકલ્પ D ખોટો છે: -c ના flag વગર grep નો કોઈ પ્રકાર ગણતો નથી. Flag ને કામ સાથે મેળવો: ગણવા -c, સ્વરૂપ અવગણવા -i, ઊલટાવવા -v, લીટીના ક્રમાંક માટે -n.
Think first
grep પહેલેથી શોધી શકતું હોય તો fgrep કેમ છે?
grep ભાતો સંભાળે છે, તો નિશ્ચિત strings માટે fgrep શા માટે? 'નિશ્ચિત' હોવાથી શું મળે છે? પછી tap કરો.
Show the answer
fgrep (grep -F) તમારી ભાતને શબ્દશઃ string તરીકે ગણે છે, જે ખાસ અક્ષરો માટે વધુ સલામત પણ છે અને વધુ ઝડપી પણ. સલામતીનો મુદ્દો: સામાન્ય grep માં . * [ ] ^ $ જેવા regex ના અક્ષરોનો ખાસ અર્થ હોય છે, એટલે '192.168.1.1' જેવી ખરેખરી ટપકાંવાળી string ને સાદા grep થી શોધવાથી દરેક . કોઈ પણ અક્ષરને મેળવત, અને ખોટા મેળ મળત. fgrep સાથે એ અક્ષરો શબ્દશઃ ગણાય છે, એટલે 'a.b' ફક્ત ખરેખરા 'a.b' ને મેળવે છે, 'aXb' ને નહીં. બરાબર એટલા માટે જ તમે fgrep તરફ હાથ લંબાવો છો જ્યારે તમારા શોધના લખાણમાં regex ના ખાસ અક્ષરો હોય જેને તમે સામાન્ય લખાણ તરીકે ગણવા માંગો છો (file ના રસ્તા, IP નાં સરનામાં, code ના ટુકડા). ઝડપનો મુદ્દો: fgrep ને regular expression નું અર્થઘટન કરવું પડતું નથી, ફક્ત નિશ્ચિત string શોધવાની હોય છે, એટલે એ વધુ ઝડપી હોઈ શકે છે, જે બહુ મોટી files તપાસતી વખતે મહત્ત્વનું છે. એટલે તમારું લક્ષ્ય ચોક્કસ શબ્દશઃ string હોય ત્યારે fgrep સાચું ઓજાર છે: તમે આકસ્મિક regex નાં આશ્ચર્ય ટાળો છો અને ઝડપી, ધારી શકાય એવી શોધ મેળવો છો. જો તમારા લખાણમાં ટપકાં, કૌંસ, કે તારાચિહ્ન હોય જેને તમે શબ્દશઃ જ ગણવા માંગતા હો, તો fgrep તમને દરેકને escape કરવામાંથી બચાવે છે. શબ્દશઃ અને ઝડપી: એ જ fgrep નું ક્ષેત્ર છે.
Summary
Key takeaways
- grep લખાણમાં ભાત શોધીને મળતી લીટીઓ છાપે છે, જે logs અને files શોધવાની રોજિંદી રીત છે.
- grep basic regex વાપરે છે; egrep (grep -E) extended regex વાપરે છે (|, +, ?, escape વગરનું જૂથ).
- fgrep (grep -F) નિશ્ચિત શબ્દશઃ string મેળવે છે: ખાસ અક્ષરો શબ્દશઃ ગણાય છે, અને એ ઝડપી છે.
- મુખ્ય flags: -i સ્વરૂપ અવગણે, -c મળતી લીટીઓ ગણે, -n લીટીના ક્રમાંક દેખાડે, -v ઊલટાવે (ન મળતી), -r ઊંડે સુધી.
- grep -c "ERROR" મળતી લીટીઓ ગણે છે; grep -i સ્વરૂપ ગમે તે હોય તોય મેળવે છે; grep -v જે મળતું નથી એ દેખાડે છે.
- Regex ના અક્ષરોવાળા શબ્દશઃ લખાણ (રસ્તા, IPs) માટે fgrep વાપરો જેથી આકસ્મિક મેળ ટળે.
- Memory hook: grep basic, egrep extended, fgrep fixed; -i -c -n -v એ રોજિંદા flags છે.