Theory
એ કૌંસની અંદર છે શું?
તમે if [ $n -lt 5 ] લખતા આવ્યા છો, પણ ખરેખર [ ] છે શું એ કદી પૂછ્યું નથી. આશ્ચર્ય આ છે: એ ચોરસ કૌંસ પોતે એક command છે, જેનું નામ છે test. [ $n -lt 5 ] એ test નામનો command ચલાવે છે, જે શરત તપાસીને સફળતા કે નિષ્ફળતા પાછી આપે છે, એટલે કે બરાબર એ જ exit status જેના પર if અને && આધાર રાખે છે.
એટલે શરતો પર પકડ મેળવવી એટલે test પર પકડ મેળવવી. એ ત્રણ પ્રકારની વસ્તુઓ તપાસે છે: files, આંકડા અને strings. આ પાઠ ત્રણેય ગોઠવીને મૂકે છે, અને લખાણના એ નિયમો પણ જે શરૂઆત કરનારાને પકડી પાડે છે.
At a glance
| પ્રકાર | Operators | દાખલો |
|---|---|---|
| File | -e હયાત છે, -f regular file, -d directory, -r/-w/-x વંચાય/લખાય/ચાલે | [ -f notes.txt ] |
| આંકડાકીય | -eq બરાબર, -ne બરાબર નહીં, -lt, -le, -gt, -ge | [ $n -gt 3 ] |
| String | = બરાબર, != બરાબર નહીં, -z ખાલી, -n ખાલી નહીં | [ "$a" = "$b" ] |
Practical
Files, આંકડા અને strings તપાસવાં (ચકાસાયેલું)
$ [ -f real.txt ] && echo "it is a regular file"
it is a regular file
$ [ -d demo ] && echo "demo is a directory"
demo is a directory
$ [ 5 -gt 3 ] && echo "5 is greater than 3"
5 is greater than 3
$ [ "abc" = "abc" ] && echo "strings equal"
strings equal
$ [ -z "" ] && echo "empty string"
empty stringWatch out
આંકડા માટે -eq, strings માટે = , અને જગ્યાનું ધ્યાન રાખો
બે નિયમો અઢળક માથાકૂટ બચાવે છે. પહેલો, પ્રકાર પ્રમાણે સાચા operators વાપરો: આંકડા ને -eq -ne -lt -le -gt -ge થી સરખાવો, અને strings ને = != -z -n થી સરખાવો. [ $n = 5 ] લખવાથી સરખામણી strings તરીકે થાય છે, અને લખાણ પર [ "$a" -eq "$b" ] લખવું એ ભૂલ છે. Operator ને data સાથે મેળવો.
બીજો, કૌંસની અંદર અને operator ની આસપાસ જગ્યા ફરજિયાત છે: [ $n -lt 5 ] ચાલે છે, પણ [$n -lt 5] કે [ $n -lt5 ] નિષ્ફળ જાય છે, કારણ કે [ એ command છે અને એને પોતાના arguments છૂટા જોઈએ છે. Shell ની તૂટેલી શરતોમાં મોટા ભાગનું કારણ આ બે જ ભૂલો હોય છે.
Quiz
તમારે તપાસવું છે કે variable n માંનો આંકડો 10 બરાબર છે કે નહીં. કઈ test સાચી છે?
- [ $n = 10 ], એટલે સરખામણી માટે = વાપરીને
- [ $n -eq 10 ], એટલે આંકડાકીય સમાનતાનો operator -eq વાપરીને
- [$n -eq 10], એટલે જગ્યા વગર ચુસ્ત રીતે લખીને
- [ $n == equal 10 ]
Show the answer
[ $n -eq 10 ], એટલે આંકડાકીય સમાનતાનો operator -eq વાપરીને
આંકડાની સરખામણી આંકડાકીય operators થી થાય છે, અને સમાનતા માટે -eq છે, એટલે [ $n -eq 10 ] સાચું છે. વિકલ્પ A એ = વાપરે છે, જે string ની સમાનતાનો operator છે; સાદા કિસ્સામાં એ કામ કરતું લાગે ખરું, પણ આંકડાની સરખામણી માટે એ ખોટું ઓજાર છે અને એનું વર્તન જુદું હોય છે (દાખલા તરીકે એ '10' અને '010' ને જુદી strings ગણશે, ભલે એ આંકડા તરીકે સરખા હોય). વિકલ્પ C માં જરૂરી જગ્યા ખૂટે છે: [ એ command છે અને એને પોતાના arguments છૂટા જોઈએ છે, એટલે [$n ને બદલે [ $n લખવું પડે. વિકલ્પ D ઉપજાવી કાઢેલું લખાણ છે. યાદ રાખો: આંકડા માટે -eq, strings માટે =, અને કૌંસની અંદર હંમેશા જગ્યા.
Think first
આંકડાની અને string ની સમાનતા માટે જુદા operators કેમ છે?
Shell દરેક વસ્તુ માટે એક જ સમાનતાનું ચિહ્ન રાખવાને બદલે આંકડા માટે -eq અને strings માટે = નો આગ્રહ કેમ રાખે છે? વિચારીને પછી tap કરો.
Show the answer
કારણ કે આંકડા તરીકે સરખાવવું અને લખાણ તરીકે સરખાવવું જુદા જવાબ આપી શકે છે, એટલે shell તમારી પાસે એ કહેવડાવે છે કે તમારો ઇરાદો કયો છે. Shell માં દરેક વસ્તુ લખાણ તરીકે જ જન્મે છે, અને લખાણ તરીકે જોઈએ તો '10', '010' અને ' 10 ' એ ત્રણ જુદી strings છે, પણ આંકડા તરીકે એ ત્રણેય દસ બરાબર છે. તમે -eq વાપરો તો shell બંને બાજુને પૂર્ણાંક તરીકે ઉકેલે છે અને એમની કિંમતો સરખાવે છે, એટલે [ 10 -eq 010 ] સાચું પડે છે. તમે = વાપરો તો એ કોરા અક્ષરો સરખાવે છે, એટલે [ 10 = 010 ] ખોટું પડે છે, કારણ કે strings જુદી છે. એકંદરે બેમાંથી કોઈ એક 'સાચું' નથી; એ તમને આંકડાની કિંમતની પરવા છે કે ચોક્કસ લખાણની, એના પર આધાર રાખે છે. જુદા operators આપીને shell તમને સ્પષ્ટ થવા દે છે અને ચૂપચાપ ખોટી અટકળ કરવાનું ટાળે છે. ખરા scripts માં આ મહત્ત્વનું છે: વપરાશકારે ટાઇપ કરેલી માહિતી, આવૃત્તિનો ક્રમાંક, કે કોઈ ગણતરી સરખાવવી, એ બધામાં તમે શું પસંદ કરો છો એ પ્રમાણે વર્તન બદલાય છે. શિસ્ત સાદી છે અને વહેલી કેળવવા જેવી છે: જો વસ્તુ આંકડો હોય અને તમને એની કિંમતની પરવા હોય, તો -eq અને એનાં આંકડાકીય ભાઈબંધ વાપરો; જો એ લખાણ હોય અને તમને ચોક્કસ અક્ષરોની પરવા હોય, તો = અને != વાપરો. સાચી સરખામણી પસંદ કરવાથી ઝીણી અને પકડવામાં અઘરી ભૂલો ટળે છે.
Summary
Key takeaways
- if ના વાક્યમાંનું [ ] ખરેખર test નામનો command છે, જે શરત માટે સફળતા કે નિષ્ફળતા પાછી આપે છે.
- File ની tests: -e હયાત છે, -f regular file, -d directory, -r/-w/-x વંચાય/લખાય/ચાલે.
- આંકડાની સરખામણી: -eq, -ne, -lt, -le, -gt, -ge.
- String ની સરખામણી: = બરાબર, != બરાબર નહીં, -z ખાલી (શૂન્ય લંબાઈ), -n ખાલી નહીં.
- આંકડા માટે આંકડાકીય operators અને strings માટે string ના operators વાપરો; એમને ભેળવવાથી ખોટાં પરિણામ કે ભૂલ મળે છે.
- કૌંસની અંદર અને operators ની આસપાસ જગ્યા ફરજિયાત છે: [ $n -lt 5 ], નહીં કે [$n -lt5].
- યાદ રાખવાની કડી: test એ files (-f/-d), આંકડા (-eq/-lt) અને strings (=) તપાસે છે; અને જગ્યા જરૂરી છે.