Theory
અને પછી, નહીં તો
ઘણી વાર તમને એવું જોઈએ છે કે એક command ત્યારે જ ચાલે જ્યારે બીજો command સફળ થયો હોય. Directory બનાવો અને પછી એની અંદર જાઓ, પણ બનાવવાનું કામ સફળ થયું હોય તો જ. File ખોલવાનો પ્રયત્ન કરો, નહીં તો નિષ્ફળ જાય ત્યારે ચેતવણી છાપો.
Shell આ વાત બે logical operators થી કહે છે: && (અને) તથા || (કે). એ commands ને એકબીજા સાથે સાંકળે છે, અને એનો આધાર છે કે દરેક command સફળ થયો કે નિષ્ફળ ગયો. એમને સમજવા માટે પહેલાં એક વિચાર જોઈએ: exit status.
Theory
Exit status: સફળતા એટલે શૂન્ય
દરેક command પૂરો થાય ત્યારે એક છુપો આંકડો પાછો આપે છે, જેને એનું exit status કહે છે. પ્રથા આવી છે: 0 એટલે સફળતા, અને શૂન્ય સિવાયની કોઈ પણ કિંમત એટલે નિષ્ફળતા. (છેલ્લું status તમે echo $? થી જોઈ શકો છો.)
તમે જે ધારો એનાથી આ ઊલટું છે, કારણ કે અહીં શૂન્ય એ 'સારું' પરિણામ છે, પણ એમાં અર્થ છે: સફળ થવાની રીત એક જ છે, જ્યારે નિષ્ફળ જવાની રીતો ઘણી બધી છે, એટલે શૂન્ય સિવાયની કિંમતો જુદી જુદી ભૂલો દર્શાવી શકે છે. Logical operators આ જ status જોઈને નક્કી કરે છે કે પછીનો command ચલાવવો કે નહીં.
Practical
&& અને || કામ કરતાં (ચકાસાયેલું)
# && runs the next command ONLY if the first succeeded (exit 0)
$ mkdir demo && cd demo # cd only happens if mkdir worked
$ true && echo "ran"
ran
$ false && echo "skipped" # first failed, so this is skipped
$
# || runs the next command ONLY if the first FAILED (non-zero)
$ false || echo "fallback" # first failed, so this runs
fallback
$ true || echo "skipped" # first succeeded, so this is skipped
$Formula
&& એટલે 'અને પછી', || એટલે 'નહીં તો'
એમને મોટેથી વાંચો તો એ પોતે જ પોતાની જાતને સમજાવી દે છે. `A && B` એટલે 'A ચલાવો, અને પછી B ત્યારે જ ચલાવો જ્યારે A સફળ થયો હોય'. `A || B` એટલે 'A ચલાવો, નહીં તો B ત્યારે જ ચલાવો જ્યારે A નિષ્ફળ ગયો હોય'.
એટલે mkdir demo && cd demo directory બની હોય તો જ સલામત રીતે એની અંદર જાય છે, અને ping -c1 host || echo "host down" ping નિષ્ફળ જાય ત્યારે જ ચેતવણી છાપે છે. && અને || થી સાંકળવાથી તમે આખા if statement વગર જ સલામત અને જાતે તપાસ કરી લેતી એક લીટીની આજ્ઞાઓ લખી શકો છો.
Quiz
આ શું છાપશે? false && echo "A" ; true || echo "B"
- A અને B બંને
- ન તો A, ન તો B
- ફક્ત A
- ફક્ત B
Show the answer
ન તો A, ન તો B
એક એક ભાગ લો. 'false && echo A' માં પહેલો command false નિષ્ફળ જાય છે, અને && પછીનો command ફક્ત સફળતા પર જ ચલાવે છે, એટલે echo A છોડી દેવાય છે (A છપાતું નથી). પછી 'true || echo B' માં પહેલો command true સફળ થાય છે, અને || પછીનો command ફક્ત નિષ્ફળતા પર જ ચલાવે છે, એટલે echo B પણ છોડી દેવાય છે (B છપાતું નથી). તેથી ન તો A છપાય છે, ન તો B. વિકલ્પ A ખોટો છે: && ને સફળતા જોઈએ (અને false સફળ નથી) તથા || ને નિષ્ફળતા જોઈએ (અને true નિષ્ફળ નથી), એટલે બંને echo છોડી દેવાય છે. વિકલ્પ C અને D બંને પેલા બેમાંથી એક એક છોડી દેવાનું ચૂકી જાય છે. નિયમ આ છે: && સફળતા પર ચાલે છે, || નિષ્ફળતા પર ચાલે છે, અને અહીં પહેલા command નું status દરેક echo ને રોકી દે છે.
Think first
બધા આંકડામાંથી 'સફળતા' માટે શૂન્ય જ કેમ પસંદ થયું?
Programming માં મોટે ભાગે શૂન્ય એટલે false કે કંઈ નહીં. તો પછી exit status 0 નો અર્થ સફળતા કેમ થાય છે? વિચારીને પછી tap કરો.
Show the answer
કારણ કે exit status એ જણાવે છે કે command કઈ રીતે પૂરો થયો, અને પૂરેપૂરું સફળ થવાની રીત બરાબર એક જ છે જ્યારે નિષ્ફળ જવાની જુદી જુદી રીતો ઘણી છે, એટલે શૂન્ય 'કોઈ ભૂલ નહીં' માટે અલગ રાખવામાં આવ્યું છે અને બાકીના આંકડા ચોક્કસ ભૂલોને નામ આપવા માટે મુક્ત રહે છે. Exit status ને એક error code તરીકે વિચારો: 0 એટલે 'શૂન્ય સમસ્યા, બધું બરાબર ચાલ્યું', જ્યારે 1, 2 અને શૂન્ય સિવાયની બીજી કિંમતો દરેક જુદા પ્રકારની નિષ્ફળતા દર્શાવી શકે છે (file મળી નહીં, permission નકારાઈ, ખોટા arguments, વગેરે). જો સફળતા માટે શૂન્ય સિવાયનો કોઈ આંકડો રાખ્યો હોત, તો તમે એવી કિંમત વેડફી નાખત જે ભૂલોને એકબીજાથી જુદી પાડવા માટે ઘણી વધારે ઉપયોગી છે. એટલે જ boolean true/false ની સરખામણીએ આ ઊલટું લાગે છે: exit status ની દુનિયામાં પ્રશ્ન 'સાચું કે ખોટું?' નથી, પણ 'કેટલી વસ્તુઓ ખોટી પડી?' છે, અને એનો શ્રેષ્ઠ જવાબ શૂન્ય છે. Logical operators સીધા આના પર જ ઊભા છે: && ત્યારે આગળ વધે છે જ્યારે સમસ્યાઓની સંખ્યા શૂન્ય હોય (સફળતા), અને || ત્યારે વચમાં આવે છે જ્યારે એ શૂન્ય ન હોય (નિષ્ફળતા). એક વાર 'શૂન્ય એટલે કામ થઈ ગયું' મનમાં બેસી જાય, પછી $?, && અને || ત્રણેય પોતપોતાની જગ્યાએ ગોઠવાઈ જાય છે. શૂન્ય સમસ્યા એ જ ધ્યેય છે.
Summary
Key takeaways
- દરેક command એક exit status પાછો આપે છે: 0 એટલે સફળતા, શૂન્ય સિવાયની કોઈ પણ કિંમત એટલે નિષ્ફળતા (echo $? થી દેખાય છે).
- && (logical AND) પછીનો command ત્યારે જ ચલાવે છે જ્યારે આગલો command સફળ થયો હોય.
- || (logical OR) પછીનો command ત્યારે જ ચલાવે છે જ્યારે આગલો command નિષ્ફળ ગયો હોય.
- એમને આ રીતે વાંચો: && એટલે 'અને પછી', અને || એટલે 'નહીં તો'.
- રૂઢ પ્રયોગો: mkdir dir && cd dir (બની હોય તો જ અંદર જવું); command || echo 'failed' (નિષ્ફળતા પર બીજો રસ્તો).
- સફળતા શૂન્ય છે કારણ કે સફળ થવાની રીત એક જ છે પણ નિષ્ફળ જવાની રીતો ઘણી, એટલે શૂન્ય સિવાયની કિંમતો ભૂલોને નામ આપી શકે છે.
- યાદ રાખવાની કડી: && સફળતા પર, || નિષ્ફળતા પર, અને 0 એટલે કામ થઈ ગયું.