{"id":41,"date":"2022-03-04T15:11:17","date_gmt":"2022-03-04T20:11:17","guid":{"rendered":"https:\/\/pressbooks.library.ryerson.ca\/opsyshiraki\/chapter\/controlstruct2\/"},"modified":"2025-02-03T19:35:02","modified_gmt":"2025-02-04T00:35:02","slug":"controlstruct2","status":"publish","type":"chapter","link":"https:\/\/pressbooks.library.torontomu.ca\/opsyshiraki\/chapter\/controlstruct2\/","title":{"raw":"Control Structures - Part 2 - Loops","rendered":"Control Structures – Part 2 – Loops"},"content":{"raw":"

Eventually you will need to repeat actions. \u00a0A practical way to repeat actions without repeating code is achieved with the construct of a loop. <\/span><\/p>\r\n\r\n

\r\n

Computer Science Loop Concepts<\/span><\/h1>\r\n

The construct of a loop allows for the repetition of actions without repeating code. \u00a0<\/span><\/p>\r\n\r\n

General Loop (Concept)<\/span><\/h2>\r\n

The most general flow of control is illustrated in the flowchart below (General). \u00a0Observe that there can be a set of actions (Block 1) which is performed regardless on entry into the loop. \u00a0Then a conditional check is made to determine continuation of the loop. \u00a0If satisfied, further actions within the loop (Block 2) will be performed. \u00a0<\/span><\/p>\r\n

\u00a0<\/span><\/p>\r\n

Not all computer languages support the General loop construct (Unix\r\ndoes <\/span>support a General loop). \u00a0If a computer language does not support the General loop construct, it will usually support one or more of the specific cases of the General loop. \u00a0For example, C Language supports both a While and a Do-While construct but not the General loop construct.<\/span><\/p>\r\n\r\n

While Loop (Concept)<\/span><\/h2>\r\n

The While Loop, as a concept, is a special case of a General Loop which has no actions for Block 1. \u00a0In this case, the condition is checked as a first action on entry into the loop construct. \u00a0See flowchart below (While).<\/span><\/p>\r\n\r\n

Do-While Loop (Concept)<\/span><\/h2>\r\n

The Do-While Loop, as a concept, is a special case of a General Loop which has no actions for Block 2. \u00a0In this case, the Block 1 code is executed on entry into the loop construct, and the condition is checked at the end of the loop construct. \u00a0See flowchart below (Do-While).<\/span><\/p>\r\n\r\n\r\n\r\n\r\n\r\n\r\n
\r\n

General<\/span><\/p>\r\n<\/th>\r\n

\r\n

While<\/span><\/p>\r\n<\/th>\r\n

\r\n

Do-While<\/span><\/p>\r\n<\/th>\r\n<\/tr>\r\n<\/thead>\r\n

\r\n

\r\n\"General\r\n<\/span><\/p>\r\n<\/td>\r\n

\r\n

\r\n\"While\r\n<\/span><\/p>\r\n<\/td>\r\n

\r\n

\r\n\"Do-while\r\n<\/span><\/p>\r\n<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n

\u00a0<\/span><\/p>\r\n\r\n<\/div>\r\n[h5p id=\"3\"]<\/span>\r\n\r\n[h5p id=\"4\"]<\/span>\r\n

Loops in Unix<\/span><\/h1>\r\n

There are three commands in Unix to support loops.<\/p>\r\n\r\n

    \r\n \t
  • while<\/span><\/li>\r\n \t
  • until\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/li>\r\n \t
  • for<\/li>\r\n<\/ul>\r\n

    while command<\/span><\/h2>\r\n

    The while command in Unix implements the General Loop construct discussed earlier.<\/span><\/p>\r\n \r\n\r\n\r\n\r\n\r\n\r\n
    \r\n

    general syntax<\/span><\/p>\r\n<\/th>\r\n

    		\r\n

    relation to flow chart<\/span><\/p>\r\n<\/th>\r\n<\/tr>\r\n<\/thead>\r\n

    \r\n
    while list1<\/span>\r\ndo<\/span>\r\n  list2<\/span>\r\ndone\r\n<\/span><\/pre>\r\n<\/td>\r\n
    		\r\n
    while block1<\/span>\r\n  \u00a0 \u00a0 check<\/span>\r\ndo<\/span>\r\n  \u00a0block 2<\/span>\r\ndone\r\n<\/span><\/pre>\r\n<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n
    Unix runs the list1 <\/span><\/span>and looks at the return code ($?) of the last command <\/span>in list.<\/span>\u00a0 (If there's only one command in the list1<\/span><\/span>, then that's the last command.) \u00a0If the return code of this last command is TRUE, then list2<\/span> <\/span>(loop body) is run. \u00a0Once the keyword \"done\" is reached, control returns to re-run list1<\/span> <\/span>and the return code of the last command in list1<\/span> <\/span>is checked. \u00a0 If the return code of this last command is FALSE, then the while loop terminates, and control continues after the keyword \"done\".<\/span><\/p>\r\n \r\n
    \r\n
    E.g. 1: Count from 1 to 12<\/p>\r\n\r\n<\/header>\r\n
    \r\n
    month=1\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span>\r\nwhile echo Checking limit against month ${month}<\/span>\r\n  [ ${month} -le 12 ]\u00a0\u00a0\u00a0# The test is the last command in list1<\/span>\r\ndo<\/span>\r\n  \u00a0echo Performing action for month ${month}<\/span>\r\n  \u00a0month=$(( ${month} + 1))<\/span>\r\ndone<\/span>\u00a0\r\necho Value of month outside loop is ${month}<\/span><\/pre>\r\n
    Notes and observations<\/h3>\r\n
      \r\n \t
    1. The last command of list1 is a test command using the left bracket synonym.<\/span><\/li>\r\n \t
    2. The -le is a test command option for the numeric comparison less than or equal to.<\/span><\/li>\r\n \t
    3. As Unix program variables hold strings, to perform arithmetic operations, one must use the $(( .. )) syntax with dollar sign and double parentheses.<\/span><\/li>\r\n \t
    4. The formal spelling of Unix variables requires enclosure in set braces { }. \u00a0Where there is no ambiguity, it is common practice in Unix to omit the set braces.<\/span><\/li>\r\n \t
    5. Try running this code and see that the value of month never exceeds 12 in the line \"echo Performing action ...\".<\/li>\r\n<\/ol>\r\n<\/div>\r\n<\/div>\r\n \r\n
      Preamble: Redirecting input from a file<\/span><\/h3>\r\n
      $ cat novel<\/strong><\/span>\r\nIt was a<\/span>\r\ndark and<\/span>\r\nstormy<\/span>\r\n$ read oneline < novel<\/strong><\/span>\r\n$ echo $oneline<\/strong><\/span>\r\nIt was a<\/span>\r\n$ read oneline < novel<\/strong><\/span>\r\n$ echo $oneline<\/strong><\/span>\r\nIt was a<\/span>\r\n$<\/span><\/pre>\r\n
      \u00a0<\/span><\/p>\r\n
      Be reminded that redirection operators in Unix (<, >, etc.) apply only to the current command. \u00a0Once the command is over, redirection is restored to the default configuration (STDIN from keyboard, STDOUT to screen, etc.). \u00a0 Thus, observe that each time the read command is run, redirection is applied anew, and the first line of the file is read in.<\/p>\r\n\r\n
      \r\n
      Eg 2a: How to read every line of a file (a non-functional example)<\/p>\r\n\r\n<\/header>\r\n
      \r\n
      The objective is to read a file one line at a time. \u00a0Here is a newbie's first attempt.<\/p>\r\n
      \u00a0<\/span><\/p>\r\n\r\n
      $ cat badwhile<\/strong><\/span>\r\nwhile read wholeline < novel<\/span>\r\ndo<\/span>\r\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0something $wholeline \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0#e.g. echo $wholeline<\/span>\r\ndone<\/span>\r\n$ .\/badwhile<\/strong><\/span>\r\nIt was a<\/span>\r\nIt was a<\/span>\r\nIt was a<\/span>\r\nIt was a<\/span>\r\n...\r\n\r\n\r\n<\/span><\/span><\/pre>\r\nWhat happened? \u00a0The redirection operator applies to the read command. \u00a0Each time the read command is run, redirection is applied anew and only the first line of the file is ever read.\r\n\r\n \r\n\r\n<\/div>\r\n<\/div>\r\n \r\n\r\nHow can one fix this problem?\r\n
      \r\n
      Eg 2b: How to read every line of a file? (a functional example)<\/p>\r\n\r\n<\/header>\r\n
      \r\n
      To have redirection apply to the entire duration of the while loop and not just the read command, it is necessary to establish redirection and associate it with the while loop.<\/span><\/p>\r\n
      Here is a template which you can use to read lines from a file one-at-a-time.<\/span><\/p>\r\n\r\n
      while read wholeline<\/span>\r\ndo<\/span>\r\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0something $wholeline\u00a0\u00a0#e.g. echo $wholeline<\/span>\r\ndone < inputfile<\/span><\/pre>\r\n
      To make this work, one must position the redirection operator after the command to which it should be applied. \u00a0The correct position is after the while command, in particular the keyword done. \u00a0Unix is smart enough to look ahead for redirection when it starts executing the while command. \u00a0Any commands within the while command which draw from STDIN (e.g. read) will draw from the redirected file. (If you are having difficulty understanding redirection, refer to the chapter on Redirection and Pipes.)<\/span><\/p>\r\n\r\n<\/div>\r\n<\/div>\r\n \r\n
      \r\n
      Eg 3: How to process multiple command line arguments (Method 1)<\/p>\r\n\r\n<\/header>\r\n
      \r\n
      Recall that the cat command will accept any <\/span>number of command line arguments like this: <\/span><\/p>\r\n\r\n
      cat ch1 ch2 ch3 ...<\/span><\/pre>\r\n
      Let's say that you want to write your own Unix script that will accept any number of command line arguments: <\/span><\/p>\r\n\r\n
      mycmd parm1 parm2 ...<\/span><\/pre>\r\n
      The key requirement here is that you will not know beforehand how many command-line arguments the user will supply when the user runs your program. \u00a0Your program must be flexible enough to handle zero or more command line arguments.<\/span><\/p>\r\n
      Here is a template of code to solve this problem:<\/span><\/p>\r\n\r\n
      while [ $1 ]<\/span>\r\ndo<\/span>\r\n \u00a0\u00a0someprocess $1<\/span>\r\n \u00a0\u00a0shift<\/span>\r\ndone<\/span><\/pre>\r\n
      Explanatory notes:<\/span><\/p>\r\n\r\n
        \r\n \t
      1. The last command in the while list is a test command (using the left square bracket synonym).<\/span><\/li>\r\n \t
      2. With no specific test operator (e.g. -r, etc.), the default behaviour of the test command is to check if the string is null. \u00a0The return code ($?) is TRUE for a non-null string (something is there), and FALSE for a null string.<\/span><\/li>\r\n \t
      3. The shift command slides all command line parameters to the left, in this case moving the next unprocessed command line argument into the $1 position. \u00a0(The shift command also has the side-effect of decrementing the $# variable.)<\/span><\/li>\r\n \t
      4. Once there are no more command line arguments, the loop terminates. \u00a0Note that if there were no command line arguments to begin with ($1 is NULL), the loop immediately terminates without entry into the body. \u00a0<\/span><\/li>\r\n<\/ol>\r\n<\/div>\r\n<\/div>\r\n \r\n
        \r\n
        Exercise: Password entry loop<\/p>\r\n\r\n<\/header>\r\n
        \r\n
        Write a bash script which will continually prompt a user to enter a password matching the control flow in the example below. \u00a0If the user enters the correct password, grant access. \u00a0If the user enters the wrong password, give the user another try (unlimited). \u00a0Avoid code duplication.<\/span><\/p>\r\n
        Sample dialog:<\/span><\/p>\r\n\r\n
        $ .\/whilecmdlist<\/span><\/strong>\r\nWhat is the password? happy<\/span><\/strong>\r\n--- Sorry, that is not the right password.<\/span>\r\nWhat is the password? access<\/span><\/strong>\r\n--- Sorry, that is not the right password.<\/span>\r\nWhat is the password? Strawberry<\/span><\/strong>\r\nWelcome to the system.<\/span>\r\n$<\/span><\/pre>\r\n<\/div>\r\n<\/div>\r\n
        until command<\/span><\/h2>\r\n
        The until command in Unix implements the General Loop construct discussed earlier.<\/span><\/p>\r\n
        The syntax is identical to the while command with the only difference that the logic of the conditional test is reversed. \u00a0If the last command in list1 is TRUE, the loop terminates.<\/span><\/p>\r\n
        Here's the same explanation for the until command:<\/span><\/p>\r\n
        Unix runs the list1<\/span> <\/span>and looks at the return code ($?) of the last command <\/span>in list.<\/span>\u00a0 (If there's only one command in the list1<\/span><\/span>, then that's the last command.) \u00a0If the return code of this last command is FALSE, then list2 <\/span><\/span>(loop body) is run. \u00a0Once the keyword \"done\" is reached, control returns to re-run list1 <\/span><\/span>and the return code of the last command in list1<\/span> <\/span>is checked. \u00a0 If the return code of this last command is TRUE, then the until loop terminates, and control continues after the keyword \"done\".<\/span><\/p>\r\n\r\n
        for command<\/span><\/h2>\r\n
        The for command in Unix operates quite differently than what is common in other computer languages like BASIC or Pascal. \u00a0In particular, it is not a counted loop, rather one should think \"iterative substitution\".<\/span><\/p>\r\n\r\n
        \r\n
        Syntax:<\/span>\u00a0<\/span><\/p>\r\n\r\n
        for name in word ...<\/span>\r\ndo<\/span>\r\n  \u00a0list<\/span>\r\ndone<\/span><\/pre>\r\n
        The list of words is expanded to create a list of items. \u00a0Each of these items is substituted into the variable name one-at-a-time and the list is run.<\/span><\/p>\r\n\r\n<\/div>\r\n \r\n
        \r\n
        E.g. 1: Multiple file rename problem<\/p>\r\n\r\n<\/header>\r\n
        \r\n
        Consider the problem of adding a suffix to several files.<\/span><\/p>\r\n
        Those familiar with a DOS or Windows Power Shell environment could use a command like this:<\/span><\/p>\r\n\r\n
        ren assig* assig*.bak<\/span><\/pre>\r\n
        Unfortunately a similar command does not work in Unix:<\/span><\/p>\r\n\r\n
        mv assig* assig*.backup<\/span><\/pre>\r\n
        Nevertheless, this problem can be solved with the simple use of a for command:<\/span><\/p>\r\n\r\n
        for filevar in assig*<\/span>\r\ndo<\/span>\r\n  \u00a0mv ${filevar} ${filevar}.backup<\/span>\r\ndone<\/span>\u00a0<\/span><\/pre>\r\n
        Explanatory notes<\/span><\/p>\r\n\r\n
          \r\n \t
        1. The word list is the wildcard file specification assig*. \u00a0On expansion, for the purposes of this example, assume that the result is three matching files: assig1, assig2, assig3.<\/span><\/li>\r\n \t
        2. Each of these words is substituted one-at-a-time in the loop variable filevar, and the body of the loop is run (code between do and done).<\/span><\/li>\r\n \t
        3. When the body of the loop is run with the variable substitutions, the effective commands generated are:<\/span><\/li>\r\n<\/ol>\r\n
            \r\n \t
          • \r\n
            mv assig1 assig1.backup<\/pre>\r\n<\/li>\r\n \t
          • \r\n
            mv assig2 assig2.backup<\/pre>\r\n<\/li>\r\n \t
          • \r\n
            mv assig3 assig3.backup<\/pre>\r\n<\/li>\r\n<\/ul>\r\n
            Additional Notes<\/span><\/p>\r\n\r\n
              \r\n \t
            1. There is no specific string concatenation operator in Unix. \u00a0Simply placing text adjacently achieves the desired result. \u00a0Here the string \".backup\" is appended to the \"assig1\", etc.<\/span><\/li>\r\n \t
            2. As stated earlier, while the use of set braces { } is often omitted when spelling variables, here it helps to clarify the distinction between the variable name and surrounding text.<\/span><\/li>\r\n<\/ol>\r\n<\/div>\r\n<\/div>\r\n \r\n
              \r\n
              E.g. 2: Count the number of entries in a directory<\/p>\r\n\r\n<\/header>\r\n
              \r\n
              Print the number of entries in the \/etc directory.<\/span><\/p>\r\n\r\n
              cou<\/span>nt=0<\/span>\r\nfor files in $(ls \/etc)<\/span>\r\ndo<\/span>\r\n \u00a0\u00a0count=$(( $count +1 ))<\/span>\r\ndone<\/span>\r\necho The number of entries is $count<\/span>\u00a0<\/span><\/pre>\r\n
              Explanatory notes<\/span><\/p>\r\n\r\n
                \r\n \t
              1. The word list consists of a command substitution call of the ls command on the \/etc directory.<\/span><\/li>\r\n \t
              2. Expansion of this word list is the names of the entries in the \/etc directory.<\/span><\/li>\r\n \t
              3. Each name is substituted into the loop variable files.<\/span><\/li>\r\n \t
              4. The body of the loop consists of incrementing a counter which will eventually hold the number of entries.<\/span><\/li>\r\n \t
              5. Outside the loop, the total number of entries is printed in an appropriate message.<\/span><\/li>\r\n<\/ol>\r\n<\/div>\r\n<\/div>\r\n \r\n
                \u00a0<\/span><\/p>\r\n\r\n
                \r\n
                Eg 3: How to process multiple command line arguments (Method 2)<\/p>\r\n\r\n<\/header>\r\n
                \r\n
                Let's say that you want to write your own Unix script that will accept any number of command line arguments: <\/span><\/p>\r\n\r\n
                mycmd parm1 parm2 \u2026<\/span><\/pre>\r\n
                Here is another method, this one using the for command<\/span><\/p>\r\n\r\n
                for cmdarg in $*<\/span>\r\ndo<\/span>\r\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0myprocess $cmdarg<\/span>\r\ndone<\/span>\r\n <\/span><\/pre>\r\n
                Explanatory notes<\/span><\/p>\r\n\r\n
                  \r\n \t
                1. The special variable $* expands to all command line arguments present starting with $1.<\/span><\/li>\r\n \t
                2. Each of these words is substituted into the loop variable cmdarg.<\/span><\/li>\r\n \t
                3. The body of the loop is run against each command line argument (myprocess is a fictitious Unix command or script).<\/span><\/li>\r\n \t
                4. Unlike the while command example, there is no need for the shift command.<\/span><\/li>\r\n \t
                5. The value of $# is intact after the completion of the for loop.<\/span><\/li>\r\n<\/ol>\r\n \r\n\r\n<\/div>\r\n<\/div>\r\n
                  break<\/h2>\r\nThe break statement causes control to exit the current for, while, or until loop.\u00a0 One must be judicious in its use to avoid \"spaghetti\" code.\u00a0 Except in rare circumstances, adherence to structure programming principles leads to clearer and less error-prone code. In many cases the use of break should be avoided.\r\n\r\n\r\n\r\n\r\n\r\n
                  \r\n
                  Poor (and rampant) use of break<\/h4>\r\n<\/td>\r\n
                  		\r\n
                  Better code<\/h4>\r\n<\/td>\r\n<\/tr>\r\n
                  \r\n
                  i=0\r\nwhile true\r\ndo\r\n  if [ $i -eq 5 ]\r\n  then\r\n    echo Reached 5\r\n    break<\/strong>\r\n  fi\r\n  i=$(( $i + 1 ))\r\ndone<\/pre>\r\n<\/td>\r\n
                  		\r\n
                  i=0\r\nwhile [ $i -ne 5 ]\r\ndo\r\n  i=$(( $i + 1 ))\r\ndone\r\necho Reached 5<\/pre>\r\n<\/td>\r\n<\/tr>\r\n
                  \r\n
                  Observations<\/h4>\r\nThe use of an infinite loop (while true) is generally unnecessary (except perhaps in server processes) and should be avoided because it requires unstructured exit points leading to \"spaghetti\" code.\u00a0 Here, the break statement is used to jump out midway through the loop contributing to poor program structure.\r\n\r\n <\/td>\r\n
                  		\r\n
                  Observations<\/h4>\r\nThe purpose and limit of the loop is coded clearly in the while condition.\u00a0 Termination of the loop naturally follows coded instructions.\u00a0 There is no jumping out from the middle of the loop.\u00a0 The code is clearer, shorter, and better structured with a single entry and exit point for the loop.<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n \r\n\r\n \r\n\r\n \r\n\r\n \r\n\r\n ","rendered":"
                  Eventually you will need to repeat actions. \u00a0A practical way to repeat actions without repeating code is achieved with the construct of a loop. <\/span><\/p>\n
                  \n
                  Computer Science Loop Concepts<\/span><\/h1>\n
                  The construct of a loop allows for the repetition of actions without repeating code. \u00a0<\/span><\/p>\n
                  General Loop (Concept)<\/span><\/h2>\n
                  The most general flow of control is illustrated in the flowchart below (General). \u00a0Observe that there can be a set of actions (Block 1) which is performed regardless on entry into the loop. \u00a0Then a conditional check is made to determine continuation of the loop. \u00a0If satisfied, further actions within the loop (Block 2) will be performed. \u00a0<\/span><\/p>\n
                  \u00a0<\/span><\/p>\n
                  Not all computer languages support the General loop construct (Unix
                  \ndoes <\/span>support a General loop). \u00a0If a computer language does not support the General loop construct, it will usually support one or more of the specific cases of the General loop. \u00a0For example, C Language supports both a While and a Do-While construct but not the General loop construct.<\/span><\/p>\n
                  While Loop (Concept)<\/span><\/h2>\n
                  The While Loop, as a concept, is a special case of a General Loop which has no actions for Block 1. \u00a0In this case, the condition is checked as a first action on entry into the loop construct. \u00a0See flowchart below (While).<\/span><\/p>\n
                  Do-While Loop (Concept)<\/span><\/h2>\n
                  The Do-While Loop, as a concept, is a special case of a General Loop which has no actions for Block 2. \u00a0In this case, the Block 1 code is executed on entry into the loop construct, and the condition is checked at the end of the loop construct. \u00a0See flowchart below (Do-While).<\/span><\/p>\n\n\n\n\n\n
                  \n
                  General<\/span><\/p>\n<\/th>\n
                  		\n
                  While<\/span><\/p>\n<\/th>\n
                  		\n
                  Do-While<\/span><\/p>\n<\/th>\n<\/tr>\n<\/thead>\n
                  \n

                  \n\"General
                  \n<\/span><\/p>\n<\/td>\n
                  		\n

                  \n\"While
                  \n<\/span><\/p>\n<\/td>\n
                  		\n

                  \n\"Do-while
                  \n<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                  \u00a0<\/span><\/p>\n<\/div>\n
                  <\/p>\n
                  \n