{"id":1674,"date":"2013-07-12T12:40:37","date_gmt":"2013-07-12T12:40:37","guid":{"rendered":"http:\/\/blog.designed79.co.uk\/?p=1674"},"modified":"2013-07-12T12:44:56","modified_gmt":"2013-07-12T12:44:56","slug":"break-and-continue-in-bash","status":"publish","type":"post","link":"https:\/\/blog.designed79.co.uk\/?p=1674","title":{"rendered":"Break and Continue in Bash"},"content":{"rendered":"

Commands affecting loop behavior<\/p>\n

break, continue
\nThe break and continue loop control commands [1] correspond exactly to their counterparts in other programming languages. The break command terminates the loop (breaks out of it), while continue causes a jump to the next iteration of the loop, skipping all the remaining commands in that particular loop cycle.<\/p>\n

Example Effects of break and continue in a loop<\/p>\n

#!\/bin\/bash
\n
\nLIMIT=19  # Upper limit
\n
\necho
\necho "Printing Numbers 1 through 20 (but not 3 and 11)."
\n
\na=0
\n
\nwhile [ $a -le "$LIMIT" ]
\ndo
\n a=$(($a+1))
\n
\n if [ "$a" -eq 3 ] || [ "$a" -eq 11 ]  # Excludes 3 and 11.
\n then
\n   continue      # Skip rest of this particular loop iteration.
\n fi
\n
\n echo -n "$a "   # This will not execute for 3 and 11.
\ndone
\n
\n# Exercise:
\n# Why does the loop print up to 20?
\n
\necho; echo
\n
\necho Printing Numbers 1 through 20, but something happens after 2.
\n
\n##################################################################
\n
\n# Same loop, but substituting 'break' for 'continue'.
\n
\na=0
\n
\nwhile [ "$a" -le "$LIMIT" ]
\ndo
\n a=$(($a+1))
\n
\n if [ "$a" -gt 2 ]
\n then
\n   break  # Skip entire rest of loop.
\n fi
\n
\n echo -n "$a "
\ndone
\n
\necho; echo; echo
\n
\nexit 0<\/div><\/div>\n

The break command may optionally take a parameter. A plain break terminates only the innermost loop in which it is embedded, but a break N breaks out of N levels of loop.<\/p>\n

Example Breaking out of multiple loop levels<\/p>\n

#!\/bin\/bash
\n# break-levels.sh: Breaking out of loops.
\n
\n# "break N" breaks out of N level loops.
\n
\nfor outerloop in 1 2 3 4 5
\ndo
\n  echo -n "Group $outerloop:   "
\n
\n  # --------------------------------------------------------
\n  for innerloop in 1 2 3 4 5
\n  do
\n    echo -n "$innerloop "
\n
\n    if [ "$innerloop" -eq 3 ]
\n    then
\n      break  # Try   break 2   to see what happens.
\n             # ("Breaks" out of both inner and outer loops.)
\n    fi
\n  done
\n  # --------------------------------------------------------
\n
\n  echo
\ndone  
\n
\necho
\n
\nexit 0<\/div><\/div>\n

The continue command, similar to break, optionally takes a parameter. A plain continue cuts short the current iteration within its loop and begins the next. A continue N terminates all remaining iterations at its loop level and continues with the next iteration at the loop, N levels above.<\/p>\n

Example Continuing at a higher loop level<\/p>\n

#!\/bin\/bash
\n# The "continue N" command, continuing at the Nth level loop.
\n
\nfor outer in I II III IV V           # outer loop
\ndo
\n  echo; echo -n "Group $outer: "
\n
\n  # --------------------------------------------------------------------
\n  for inner in 1 2 3 4 5 6 7 8 9 10  # inner loop
\n  do
\n
\n    if [[ "$inner" -eq 7 && "$outer" = "III" ]]
\n    then
\n      continue 2  # Continue at loop on 2nd level, that is "outer loop".
\n                  # Replace above line with a simple "continue"
\n                  # to see normal loop behavior.
\n    fi  
\n
\n    echo -n "$inner "  # 7 8 9 10 will not echo on "Group III."
\n  done  
\n  # --------------------------------------------------------------------
\n
\ndone
\n
\necho; echo
\n
\n# Exercise:
\n# Come up with a meaningful use for "continue N" in a script.
\n
\nexit 0<\/div><\/div>\n

Example Using continue N in an actual task<\/p>\n

# Albert Reiner gives an example of how to use "continue N":
\n# ---------------------------------------------------------
\n
\n#  Suppose I have a large number of jobs that need to be run, with
\n#+ any data that is to be treated in files of a given name pattern
\n#+ in a directory. There are several machines that access
\n#+ this directory, and I want to distribute the work over these
\n#+ different boxen.
\n#  Then I usually nohup something like the following on every box:
\n
\nwhile true
\ndo
\n  for n in .iso.*
\n  do
\n    [ "$n" = ".iso.opts" ] && continue
\n    beta=${n#.iso.}
\n    [ -r .Iso.$beta ] && continue
\n    [ -r .lock.$beta ] && sleep 10 && continue
\n    lockfile -r0 .lock.$beta || continue
\n    echo -n "$beta: " `date`
\n    run-isotherm $beta
\n    date
\n    ls -alF .Iso.$beta
\n    [ -r .Iso.$beta ] && rm -f .lock.$beta
\n    continue 2
\n  done
\n  break
\ndone
\n
\nexit 0
\n
\n#  The details, in particular the sleep N, are particular to my
\n#+ application, but the general pattern is:
\n
\nwhile true
\ndo
\n  for job in {pattern}
\n  do
\n    {job already done or running} && continue
\n    {mark job as running, do job, mark job as done}
\n    continue 2
\n  done
\n  break        # Or something like `sleep 600' to avoid termination.
\ndone
\n
\n#  This way the script will stop only when there are no more jobs to do
\n#+ (including jobs that were added during runtime). Through the use
\n#+ of appropriate lockfiles it can be run on several machines
\n#+ concurrently without duplication of calculations [which run a couple
\n#+ of hours in my case, so I really want to avoid this]. Also, as search
\n#+ always starts again from the beginning, one can encode priorities in
\n#+ the file names. Of course, one could also do this without `continue 2',
\n#+ but then one would have to actually check whether or not some job
\n#+ was done (so that we should immediately look for the next job) or not
\n#+ (in which case we terminate or sleep for a long time before checking
\n#+ for a new job).<\/div><\/div>\n

The continue N construct is difficult to understand and tricky to use in any meaningful context. It is probably best avoided.<\/p>\n","protected":false},"excerpt":{"rendered":"

Commands affecting loop behavior break, continue The break and continue loop control commands [1] correspond exactly to their counterparts in other programming […]<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-1674","post","type-post","status-publish","format-standard","hentry","category-info-on-tech"],"_links":{"self":[{"href":"https:\/\/blog.designed79.co.uk\/index.php?rest_route=\/wp\/v2\/posts\/1674","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.designed79.co.uk\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.designed79.co.uk\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.designed79.co.uk\/index.php?rest_route=\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.designed79.co.uk\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=1674"}],"version-history":[{"count":0,"href":"https:\/\/blog.designed79.co.uk\/index.php?rest_route=\/wp\/v2\/posts\/1674\/revisions"}],"wp:attachment":[{"href":"https:\/\/blog.designed79.co.uk\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=1674"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.designed79.co.uk\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=1674"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.designed79.co.uk\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=1674"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}