Control Flow Structures (if-else, case, for, while, until)

📖 Theory

નક્કી કરતા અને દોહરાવતા scripts

જે script ફક્ત ઉપરથી નીચે સુધી પોતાની લીટીઓ એક જ વાર ચલાવી નાખે એ ઉપયોગી તો છે, પણ મર્યાદિત છે. ખરા scripts ને નક્કી કરવું પડે છે (જો backup નું folder ન હોય તો એને બનાવવું) અને દોહરાવવું પડે છે (યાદીમાંની દરેક file ની નકલ કરવી). એ જ control flow છે, અને આ વિચારો તમે Python તથા C માં પહેલાં મળી ચૂક્યા છો; અહીં તમે shell નું રૂપ શીખો છો.

એનાં બે કુટુંબ છે: શાખા પાડવી (if-else અને case, એટલે રસ્તો પસંદ કરવો) અને આંટા મારવા (for, while, until, એટલે કામ દોહરાવવું). આ પાઠ પાંચેયને આવરી લે છે, shell ના પોતાના લખાણના નિયમો અને એના આગવા સમાપન શબ્દો સાથે.

📖 Theory

શાખા પાડવી: if-else અને case

if કોઈ ખંડ ત્યારે જ ચલાવે છે જ્યારે તપાસ સફળ થાય, અને એની સાથે વૈકલ્પિક elif (else-if) તથા else શાખાઓ પણ આવી શકે છે, અને એ fi થી બંધ થાય છે (એટલે કે if ને ઊલટું લખેલું):

if [ test ]; then ... elif [ test ]; then ... else ... fi

case એક કિંમતને અનેક ભાતો સામે સરખાવે છે, અને જ્યારે તમે એક જ variable ને મેળવતા હો ત્યારે એ elif ની લાંબી સાંકળ કરતાં વધુ સ્વચ્છ રહે છે. દરેક ભાત ;; થી પૂરી થાય છે, અને આખો ખંડ esac થી બંધ થાય છે (એટલે કે case ને ઊલટું લખેલું). સામાન્ય સાચું/ખોટું જેવી શરતો માટે if વાપરો, અને એક કિંમતને અનેક ચોક્કસ શક્યતાઓ સામે તપાસવી હોય ત્યારે case વાપરો.

⌨️ Practical

if-elif-else અને case (ચકાસાયેલું)

n=7
if [ $n -lt 5 ]; then
    echo "small"
elif [ $n -lt 10 ]; then
    echo "medium"          # n=7 -> prints medium
else
    echo "large"
fi

fruit=apple
case $fruit in
    apple)  echo "It is an apple" ;;   # this matches
    banana) echo "It is a banana" ;;
    *)      echo "Unknown" ;;          # * = anything else
esac

📖 Theory

આંટા મારવા: for, while, until

for યાદીમાંની દરેક વસ્તુ માટે એક વાર દોહરાવે છે, જે 'દરેક file સાથે આ કરો' માટે બરાબર બંધબેસે છે:

for f in *.txt; do ... done

while ત્યાં સુધી દોહરાવે છે જ્યાં સુધી શરત સાચી રહે: while [ test ]; do ... done. until એનું અરીસા જેવું ઊલટું રૂપ છે: એ ત્યાં સુધી દોહરાવે છે જ્યાં સુધી શરત સાચી ન થાય (એટલે કે શરત ખોટી હોય ત્યાં સુધી). આ ત્રણેય આંટા done થી બંધ થાય છે.

એટલે while [ $i -le 3 ] ત્યાં સુધી ચાલતું રહે છે જ્યાં સુધી i ત્રણ કે એથી ઓછો હોય, અને until [ $i -gt 3 ] ત્યાં સુધી ચાલતું રહે છે જ્યાં સુધી i ત્રણથી વધી ન જાય, અને બંને, 1 થી ગણતરી શરૂ કરીએ તો, 1, 2, 3 છાપે છે. જેની શરત વાંચવામાં સૌથી સહજ લાગે એ પસંદ કરો.

⌨️ Practical

for, while અને until (ચકાસાયેલું)

# for: iterate over a list
for f in *.txt; do
    echo "file: $f"
done

# while: repeat WHILE the condition is true
i=1
while [ $i -le 3 ]; do
    echo "while $i"        # prints while 1, while 2, while 3
    i=$((i+1))
done

# until: repeat UNTIL the condition becomes true
i=1
until [ $i -gt 3 ]; do
    echo "until $i"        # also prints 1, 2, 3
    i=$((i+1))
done

✏️ Formula

સમાપન શબ્દોનું ધ્યાન રાખો

Shell દરેક ખંડને એક ચોક્કસ શબ્દથી બંધ કરે છે, અને એ શબ્દો ગૂંચવાઈ જવા એ સામાન્ય ભૂલ છે:

if એ fi થી બંધ થાય છે, case એ esac થી બંધ થાય છે (બંને એ જ શબ્દ ઊલટા લખેલા છે), અને દરેક આંટો, એટલે કે for, while, until, એ done થી બંધ થાય છે.

એ પણ યાદ રાખો કે case ની દરેક ભાત પછી ;; આવે છે, અને [ ... ] વાળી તપાસમાં કૌંસની અંદર જગ્યા જોઈએ છે. લખાણના આ નાના નિયમો જ shell માં શરૂઆત કરનારાને ગૂંચવે છે, એટલે એમને ધ્યાન દઈને ટાઇપ કરો.

🧩 Quiz

આ આંટો શું છાપશે? i=1; while [ $i -le 3 ]; do echo $i; i=$((i+1)); done

1. 1 2 3 4, એટલે 4 સુધી ગણતરી
2. 1 2 3, દરેક લીટીએ એક આંકડો
3. કશું નહીં, કારણ કે શરૂઆતમાં જ શરત ખોટી છે
4. કદી ન અટકતો આંટો

💭 Think first

while કે until: પસંદગી કઈ રીતે કરવી?

while અને until એકબીજાનાં અરીસા જેવાં રૂપ છે. કયું ક્યારે વધુ સહજ વંચાય છે? વિચારીને પછી tap કરો.

✅ Summary

Key takeaways

• Control flow script ને નક્કી કરવા (શાખા) અને દોહરાવવા (આંટા) દે છે, બરાબર Python અને C ની જેમ, પણ shell ના લખાણના નિયમો સાથે.
• if-then-elif-else-fi તપાસ પરથી રસ્તો પસંદ કરે છે; case એક કિંમતને ભાતો સામે મેળવે છે અને esac થી બંધ થાય છે.
• for યાદી પર ફરી વળે છે (for f in *.txt); દરેક file સાથે કંઈક કરવા માટે આદર્શ.
• while ત્યાં સુધી દોહરાવે છે જ્યાં સુધી શરત સાચી હોય; until ત્યાં સુધી દોહરાવે છે જ્યાં સુધી શરત સાચી ન થાય (અરીસા જેવું ઊલટું).
• સમાપન શબ્દો મહત્ત્વના છે: if એ fi થી, case એ esac થી, અને બધા આંટા done થી બંધ થાય છે.
• 1 થી ગણતરી શરૂ કરીએ તો while [ $i -le 3 ] એ 1, 2, 3 છાપે છે અને i 4 થાય ત્યારે અટકે છે.
• યાદ રાખવાની કડી: if/case નક્કી કરે, for/while/until દોહરાવે; બંધ કરવા fi, esac, done.