Theory
લખાણને એના આકારથી વર્ણવવું
ક્યારેક તમને જોઈતું ચોક્કસ લખાણ ખબર હોતું નથી, ફક્ત એનો આકાર જ ખબર હોય છે. ERROR થી શરૂ થતી દરેક લીટી. કોઈ આંકડો ધરાવતી દરેક string. .txt થી પૂરો થતો દરેક શબ્દ. આ બધું નિશ્ચિત string થી શોધી શકાતું નથી, કારણ કે એ ભાતો છે, કોઈ ચોક્કસ શબ્દો નહીં.
Regular expression (regex) બરાબર એ જ છે: એક ટૂંકી ભાત જે શક્ય લખાણોના સમૂહનું વર્ણન કરે છે. Command line ના સૌથી શક્તિશાળી વિચારોમાં આ એક છે, અને હવે પછી તમને મળનારાં grep તથા sed એના પર જ ચાલે છે. આ પાઠ એના પાયાના ટુકડાનો પરિચય આપે છે.
Theory
પાયાના ટુકડા
Regex સામાન્ય અક્ષરો (જે પોતાની જાતને જ મેળવે છે) અને ખાસ અક્ષરો (જેમની પાસે શક્તિ હોય છે) થી બંધાય છે. પાયાના આટલા:
- . ગમે તે એક અક્ષર સાથે મેળ ખાય છે.
- [ ] કોઈ સમૂહમાંના ગમે તે એક અક્ષર સાથે મેળ ખાય છે:
[aeiou]એટલે સ્વર,[0-9]એટલે આંકડો. - ^ લીટીની શરૂઆત સાથે બાંધે છે; $ લીટીના અંત સાથે બાંધે છે.
- ***** એટલે 'એની આગળના ટુકડાની શૂન્ય કે વધુ નકલ'.
એટલે ^ERROR એ ERROR થી શરૂ થતી લીટીઓ મેળવે છે, [0-9] એ આંકડો ધરાવતી કોઈ પણ લીટી મેળવે છે, અને ^$ એ ખાલી લીટી મેળવે છે (શરૂઆત પછી તરત જ અંત).
At a glance
| ભાત | શું મેળવે છે |
|---|---|
| . | ગમે તે એક અક્ષર |
| [0-9] | ગમે તે એક આંકડો (એક વ્યાપ); [a-z] એટલે ગમે તે એક નાનો અક્ષર |
| [^0-9] | ગમે તે એક અક્ષર જે આંકડો નથી (નકારેલો સમૂહ) |
| ^ | લીટીની શરૂઆત (anchor) |
| $ | લીટીનો અંત (anchor) |
| * | એની આગળના ટુકડાની શૂન્ય કે વધુ નકલ |
| + ? | ( ) | Extended regex: એક કે વધુ, શૂન્ય કે એક, કે, અને જૂથ |
Practical
ભાતો કામ કરતી (grep થી ચકાસાયેલું)
# [0-9] matches any line containing a digit
$ printf "abc\na1b\nxyz\n" | grep "[0-9]"
a1b
# ^ERROR matches lines that START with ERROR
$ grep "^ERROR" log.txt
ERROR disk full
ERROR timeout
# Extended regex: ERROR OR WARN (needs grep -E)
$ grep -E "ERROR|WARN" log.txt
ERROR disk full
ERROR timeout
WARN low memoryFormula
Anchors અને સમૂહો જ ખરા ભારવાહક છે
રોજિંદી ભાતોમાં મોટા ભાગનું કામ બે વિચારો કરે છે. Anchors મેળને કોઈ સ્થાન સાથે જડી દે છે: લીટીની શરૂઆત માટે ^ અને અંત માટે $, એટલે ^ERROR ફક્ત એ જ લીટીઓ શોધે છે જે ERROR થી શરૂ થાય, નહીં કે જેમાં એ ક્યાંક આવતું હોય. [ ] વાળા અક્ષરોના સમૂહ કોઈ સમૂહમાંનો એક અક્ષર મેળવે છે, જેમાં [0-9] અને [a-z] જેવા વ્યાપ પણ આવે છે, અને નકારવા માટે [^...] વપરાય છે.
એ બંનેને જોડો એટલે તમે નવાઈ પમાડે એવા ચોક્કસ આકારો વર્ણવી શકો છો: દાખલા તરીકે આંકડાથી શરૂ થતી લીટીઓ માટે ^[0-9]. પહેલાં anchors અને સમૂહો શીખો; લગભગ દરેક ખરેખરી ભાતમાં એ આવે જ છે.
Quiz
^ERROR નામનું regular expression શું મેળવે છે?
- એવી કોઈ પણ લીટી જેમાં ક્યાંય પણ ERROR શબ્દ આવતો હોય
- ફક્ત એ લીટીઓ જે ERROR થી શરૂ થાય, કારણ કે ^ મેળને લીટીની શરૂઆત સાથે બાંધે છે
- ERROR થી પૂરી થતી લીટીઓ
- શબ્દશઃ લખાણ caret-E-R-R-O-R, જેમાં ^ ચિહ્ન પણ આવી જાય
Show the answer
ફક્ત એ લીટીઓ જે ERROR થી શરૂ થાય, કારણ કે ^ મેળને લીટીની શરૂઆત સાથે બાંધે છે
^ એ લીટીની શરૂઆતનું anchor છે, એટલે ^ERROR ફક્ત એ જ લીટીઓ મેળવે છે જે ERROR થી શરૂ થાય. વિકલ્પ A એ anchor નો અર્થ પડતો મૂકે છે: સાદું ERROR (^ વગર) લીટીમાં ગમે ત્યાં આવતા ERROR ને મેળવે છે, પણ ^ એને શરૂઆત પૂરતું મર્યાદિત કરે છે. વિકલ્પ C એ બીજા anchor, એટલે કે $, નું વર્ણન કરે છે, જે લીટીનો અંત મેળવે છે (ERROR$ એ ERROR થી પૂરી થતી લીટીઓ મેળવત). વિકલ્પ D ખોટો છે: regex માં ^ ખાસ છે (એ anchor છે), શબ્દશઃ અક્ષર નહીં; મેળવેલા લખાણમાં caret આવતું નથી. Anchors તમારા મેળનું સ્થાન નક્કી કરે છે: શરૂઆતે ^, અંતે $, અને ચોકસાઈભરી શોધ માટે એ અનિવાર્ય છે.
Think first
Basic અને extended, એમ બે પ્રકાર કેમ છે?
Regex એ basic (BRE) અને extended (ERE) એમ બે રૂપે આવે છે. આ ભાગલા કેમ, અને એ ક્યારે મહત્ત્વના બને છે? વિચારીને પછી tap કરો.
Show the answer
એ મોટે ભાગે ઇતિહાસનો વારસો છે, અને વ્યવહારુ ફેર એટલો જ છે કે કયા ખાસ અક્ષરો backslash વગર કામ કરે છે. જૂનાં basic regular expressions (BRE), જે grep અને sed મૂળભૂત રીતે વાપરે છે, અમુક શક્તિશાળી operators ને, એટલે કે +, ?, | અને જૂથ ( ) ને, સામાન્ય અક્ષરો તરીકે લે છે, સિવાય કે તમે એમને backslash થી escape કરો (\+, \?, \|, \( \)). નવાં extended regular expressions (ERE), જે grep -E (egrep) અને sed -E વાપરે છે, એ જ operators ને આપોઆપ ખાસ ગણે છે, એટલે તમે એમને સીધા લખી શકો છો: 'ERROR કે WARN' માટે ERROR|WARN, કે 'એક કે વધુ ab' માટે (ab)+. મેળવવાની શક્તિ મૂળે એકસરખી જ છે; તમને વિકલ્પ, જૂથ કે એક-કે-વધુ જોઈએ ત્યારે ERE લખવામાં વધુ સ્વચ્છ પડે છે. એટલા માટે જ |, + કે ( ) વાળી કોઈ પણ વસ્તુ માટે લોકો grep -E તરફ હાથ લંબાવે છે: ભાત backslash થી ખરડાવાને બદલે સહજ વંચાય છે. સાદી ભાતો માટે (એક શબ્દ, એક anchor, અક્ષરોનો સમૂહ) basic regex પૂરેપૂરું ચાલે છે અને બંને પ્રકાર એકસરખું જ વર્તે છે. એટલે અંગૂઠાનો નિયમ આવો છે: સાદી ભાત હોય તો બેમાંથી ગમે તે ચાલે; 'કે', જૂથ કે વત્તાની જરૂર હોય તો escape ટાળવા extended (grep -E) પસંદ કરો. કયું ઓજાર કયો પ્રકાર વાપરે છે એ ખબર હોય તો 'મારું | કેમ કામ નથી કરતું?' જેવી રહસ્યમય ક્ષણોમાંથી બચી જવાય છે.
Summary
Key takeaways
- Regular expression એટલે એવી ભાત જે લખાણને ચોક્કસ જોડણીથી નહીં પણ એના આકારથી વર્ણવે છે.
- મુખ્ય ટુકડા: . (ગમે તે અક્ષર), [ ] (સમૂહ, જેમ કે [0-9]), [^...] (નકારેલો સમૂહ), * (શૂન્ય કે વધુ).
- Anchors મેળનું સ્થાન નક્કી કરે છે: ^ એને લીટીની શરૂઆત સાથે બાંધે છે, $ એને અંત સાથે.
- એટલે ^ERROR એ ERROR થી શરૂ થતી લીટીઓ મેળવે છે; [0-9] એ આંકડો ધરાવતી લીટીઓ મેળવે છે.
- Basic regex (BRE, જે grep/sed વાપરે છે) માં + ? | ( ) માટે backslash જોઈએ છે; extended regex (ERE, grep -E) માં નહીં.
- તમને વિકલ્પ |, જૂથ ( ), કે એક-કે-વધુ + જોઈએ ત્યારે extended regex (grep -E) તરફ હાથ લંબાવો.
- યાદ રાખવાની કડી: . એટલે ગમે તે, [ ] એટલે સમૂહ, ^ એટલે શરૂઆત, $ એટલે અંત; અને 'કે' તથા જૂથ માટે -E.