{"id":37,"date":"2022-03-04T15:11:16","date_gmt":"2022-03-04T20:11:16","guid":{"rendered":"https:\/\/pressbooks.library.ryerson.ca\/opsyshiraki\/chapter\/controlstruct1\/"},"modified":"2025-05-14T13:27:39","modified_gmt":"2025-05-14T17:27:39","slug":"controlstruct1","status":"publish","type":"chapter","link":"https:\/\/pressbooks.library.torontomu.ca\/opsyshiraki\/chapter\/controlstruct1\/","title":{"raw":"Control Structures - Part 1 - branching","rendered":"Control Structures – Part 1 – branching"},"content":{"raw":"

In order to support control structures (branching, looping, etc.), all computer languages need some method of evaluating a condition. \u00a0In Unix, the command to evaluate a condition is the test command. \u00a0The test command is often at the heart of most control structures in Unix.<\/span><\/p>\r\n \r\n

test<\/span><\/h1>\r\n

What does the test command do? \u00a0It evaluates a condition and sets the special shell variable $?, the return code. \u00a0Much to the confusion of new users, the test command is silent in that it does not print anything to standard output. \u00a0Thus when running the test command, it appears as if to do nothing. \u00a0To check the return code, one may simply print its value with an echo statement.<\/span><\/p>\r\n\r\n

\r\n

Example 1: \u00a0Check if a file is readable.<\/span><\/p>\r\n\r\n<\/header>\r\n

\r\n
$ test -r myfile<\/strong><\/span>\r\n$ echo $?<\/strong><\/span>\r\n0<\/span><\/pre>\r\n<\/div>\r\n<\/div>\r\n
\u00a0<\/span><\/p>\r\n
How does one interpret the return code? \u00a0 <\/span><\/p>\r\n
Unix convention:<\/span><\/p>\r\n\r\n\r\n\r\n\r\n\r\n
\r\n
0 (zero)<\/span><\/p>\r\n<\/th>\r\n
\r\n
means TRUE<\/span><\/p>\r\n<\/td>\r\n<\/tr>\r\n
\r\n
not 0 (not zero)<\/span><\/p>\r\n<\/th>\r\n
\r\n
means FALSE<\/span><\/p>\r\n<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n
\u00a0<\/span><\/p>\r\n\r\n
\r\n
Example 2: \u00a0Compare if two strings are equal.<\/span><\/p>\r\n\r\n<\/header>\r\n
\r\n
$ test \"this\" = \"that\"<\/strong><\/span>\r\n$ echo $?<\/strong><\/span>\r\n1<\/span><\/pre>\r\n<\/div>\r\n<\/div>\r\n
\u00a0<\/span><\/p>\r\n\r\n
Synonym to the test command: \u00a0[<\/span><\/h2>\r\n
For reasons of readability, many programmers with use the synonym or abbreviation for the test command which is the left square bracket: [ . \u00a0In all examples above, replace the word test with the left square bracket. \u00a0Note that a matching right square bracket needs to be added for syntactic reasons. \u00a0As with all Unix commands, spaces are a big deal and a space is required after the left square bracket and before the right square bracket.<\/span><\/p>\r\n
\u00a0<\/span><\/p>\r\n\r\n
\r\n
Example 3: Synonym to the test command [<\/span><\/p>\r\n\r\n<\/header>\r\n
\r\n
$ [ -r myfile ]<\/strong> # note the space after the left bracket<\/span>\r\n$ echo $?<\/span>\r\n<\/strong>0<\/span>\u00a0<\/span><\/pre>\r\n<\/div>\r\n<\/div>\r\n \r\n
Control Structures<\/span><\/h1>\r\n
if<\/span><\/h2>\r\n
The if statement in Unix is the basic two-way branch.<\/span><\/p>\r\n \r\n
\r\n
Syntax<\/span><\/p>\r\n\r\n
if unix_statements<\/span>\r\nthen<\/span>\r\n  \u00a0actions_true<\/span>\r\nelse \u00a0# optional<\/span>\r\n  \u00a0actions_false<\/span>\r\nfi<\/span><\/pre>\r\n<\/div>\r\n
How does the if statement work? \u00a0Here is the sequence of operations. \u00a0The if statement will:<\/span><\/p>\r\n\r\n
    \r\n \t
  1. Run all the unix_statements. \u00a0 <\/span><\/li>\r\n \t
  2. Check the return code ($?) of the last statement in the list (just prior to the keyword \"then\". <\/span><\/li>\r\n \t
  3. If the return code is true. the \"then\" clause is executed (\r\nactions_true)<\/span>. \u00a0If the return code is false, the \"else\" clause is executed (actions_false)<\/span>. \u00a0The else clause is optional (can be left out if not needed).<\/span><\/li>\r\n<\/ol>\r\n
    \r\n
    Example of if<\/span><\/p>\r\n\r\n<\/header>\r\n
    \r\n
    #!\/bin\/bash<\/span>\r\ncomfort=20<\/span>\r\ntemperature=18<\/span>\r\nif echo The current temperature is $temperature<\/span>\r\n  \u00a0echo Temperature for comparison is $comfort<\/span>\r\n  \u00a0[ $temperature -lt $comfort ]<\/span>\r\nthen<\/span>\r\n  echo It is cold.<\/span>\r\nelse<\/span>\r\n  echo It is warm.<\/span>\r\nfi<\/span>\u00a0<\/span><\/pre>\r\n<\/div>\r\n<\/div>\r\n[h5p id=\"5\"]\r\n
    Nested conditions are supported in Unix. \u00a0Any statement in the \"then\" or \"else\" clause can itself be another if statement.<\/span><\/p>\r\n\r\n
    elif<\/h3>\r\n
    Although the if statement is primarily a two-way branch (e.g. true or false), a multi-way branch (e.g. red, yellow, green) can be coded using a set of nested if statements. \u00a0Some computer languages support an \"else-if\"-type clause; Unix is one of them.<\/span><\/p>\r\n
    There is an \"else-if\" clause called \"elif\" which requires a statement just like the if clause. <\/span><\/p>\r\n\r\n
    \r\n
    Example: elif<\/p>\r\n\r\n<\/header>\r\n
    \r\n
    if [ $temperature -lt $comfort ]<\/span>\r\nthen<\/span>\r\n  echo It is cold.<\/span>\r\nelif [ $temperature -eq $comfort ]<\/span>\r\nthen<\/span>\r\n  echo It is perfect.<\/span>\r\nelse<\/span>\r\n  echo It is warm.<\/span>\r\nfi<\/span>\r\n <\/span><\/pre>\r\n
    Note that the \"elif\" clause is actually a clause of the main \"if\" and not <\/span>a nested if statement. \u00a0Thus, there is only one \"fi\" (end if) required for each opening \"if\" regardless of how many \"elif\" clauses there are.<\/span><\/p>\r\n\r\n<\/div>\r\n<\/div>\r\n[h5p id=\"6\"]<\/span>\r\n\r\n[h5p id=\"7\"]<\/span>\r\n
    case<\/h2>\r\n
    Many computer languages support a multi-way branch. Unix is included as one of them.<\/p>\r\n\r\n
    \r\n
    Simplified syntax:<\/span><\/p>\r\n
    \u00a0<\/span><\/p>\r\n\r\n
    case $variable <\/span>\r\nin<\/span>\r\n  val1) action1;;<\/span>\r\n  val2) action2;;<\/span>\r\n  *) default action;;<\/span>\r\nesac<\/span>\u00a0<\/span><\/pre>\r\n
    The keywords are case, in, and esac. \u00a0The double semi-colon is a syntactic requirement to separate the inner clauses of the case statement.<\/span><\/p>\r\n\r\n<\/div>\r\n \r\n\r\n \r\n\r\n \r\n
    \r\n
    Example: \u00a0Flexible command line processing. <\/span><\/p>\r\n\r\n<\/header>\r\n
    \r\n
    Allow your user to <\/span>run your script in various ways.\u00a0 Accommodate all of the following invocations.<\/span><\/p>\r\n\r\n
    $ .\/mysc<\/strong><\/span>ript<\/strong> <\/span># user omits filename; give second chance<\/span>\r\n$ .\/myscript chapter3<\/span><\/strong> # <\/span>preferred syntax; just proceed<\/span>\r\n$ .\/myscript chapter3 chapter5 <\/span><\/strong># multiple arguments not s<\/span>upported; \r\n<\/span>inform user<\/span>\r\n\r\nPlace this code snippet at the beginning of your script like this:<\/span>\r\n$ cat myscript<\/strong>\r\ncase $# in<\/span>\r\n  0) echo Enter file name:<\/span>\r\n  \u00a0 \u00a0 \u00a0 \u00a0 \u00a0read arg1;;<\/span>\r\n  1) arg1=$1;;<\/span>\r\n  *) echo invalid number of arguments<\/span>\r\n  \u00a0 \u00a0echo \"Syntax: $0 filename\"<\/span>\r\n  \u00a0 \u00a0exit 1;;<\/span>\r\nesac<\/span>\r\n# rest of program continues after esac\r\n$<\/span><\/pre>\r\n<\/div>\r\n<\/div>\r\n \r\n
    \r\n
    General syntax:<\/span>\u00a0<\/span><\/p>\r\n\r\n
    case match_string_expr in<\/span>\r\n  match_pattern) action1;;<\/span>\r\n  match_pattern) action2;;<\/span>\r\n  ...<\/span><\/pre>\r\n
    esac<\/pre>\r\n<\/div>\r\n \r\n
    \r\n
    Example: \u00a0Demonstrate pattern matching use in case statement. \u00a0Print a message about the length of the current month.<\/span><\/p>\r\n\r\n<\/header>\r\n
    \r\n
    lhiraki@metis:~\/test$ cat case_month\r\n<\/strong>case $(date '+%m') in\r\n01|03|05|07|08|10|12)\r\n  \u00a0 \u00a0echo This is a long month;;\r\n04|06|09|11)\r\n  \u00a0 \u00a0echo This is a short month;;\r\n02)\r\n  \u00a0 \u00a0echo This is the shortest month;;\r\n*)\r\n  \u00a0 \u00a0echo Something wrong with date command;;\r\nesac\r\n\r\n# Example run in September\r\n\r\nlhiraki@metis:~\/test$ .\/case_month<\/strong>\r\nThis is a short month\r\nlhiraki@metis:~\/test$\r\n\r\n<\/pre>\r\n
    The date command is called with an option to return the numerical value of the month (e.g. Jan=01, Feb=02, etc.). \u00a0Depending on the month, a message is printed regarding the length of the month. \u00a0Months with the same number of days are grouped together using a pattern with the OR (vertical bar) syntax.<\/span><\/p>\r\n\r\n<\/div>\r\n<\/div>\r\n \r\n
    Defensive programming<\/span><\/h3>\r\n
    Well the previous example is rather trivial and the date command has been well tested over the years, it is considered good practice to always have a default clause even if you think you have covered all possible conditions.<\/span><\/p>\r\n\r\n
    Summary<\/h2>\r\n[caption id=\"\" align=\"alignnone\" width=\"519\"]\"Entry Flow of case statement: one entry point, only one action chosen.[\/caption]\r\n\r\n \r\n
    \u00a0<\/span>The match_string_expr is matched against each match_pattern in the order coded. \u00a0At the first match, the corresponding action is taken. \u00a0After one action is completed, the case statement terminates and execution continues after the esac (end case). \u00a0There is no \"fall-through\". \u00a0The case statement will not execute multiple actions.<\/p>\r\n[h5p id=\"8\"]<\/span>\r\n
    shift<\/span><\/h2>\r\n
    When processing multiple command-line arguments, it may be necessary to manipulate them to facilitate processing.<\/span><\/p>\r\n
    The shift command moves all command-line arguments one position to the left. \u00a0For example the second command line argument is moved into the first position; the third command line argument is moved into the second position, and so forth.<\/p>\r\n \r\n
    \r\n
    Example of\u00a0 shift command<\/p>\r\n\r\n<\/header>\r\n
    \r\n
    lhiraki@thebe:~\/test$ cat shifter<\/strong><\/span>\r\n\r\n#!\/bin\/bash<\/span>\r\necho The 1st arg is $1<\/span>\r\necho The 2nd arg is $2<\/span>\r\nshift<\/span>\r\necho The 2nd arg is $1<\/span>\r\nshift<\/span>\r\necho The 3rd arg is $1<\/span>\u00a0<\/span><\/pre>\r\n
    Execution results in:<\/span><\/p>\r\n\r\n
    lhiraki@thebe:~\/te<\/span>st$ .\/shifter apple pear grape<\/strong><\/span>\r\nThe 1st arg is apple<\/span>\r\nThe 2nd arg is pear<\/span>\r\nThe 2nd arg is pear<\/span>\r\nThe 3rd arg is grape<\/span>\r\nlhiraki@thebe:~\/test$<\/span><\/pre>\r\n
    \u00a0<\/span><\/p>\r\n\r\n<\/div>\r\n<\/div>\r\n
    The exit command<\/h3>\r\n
    The exit command does <\/span>two\u00a0things:<\/span><\/p>\r\n\r\n
      \r\n \t
    1. It terminates the current shell (or script), returning control to the calling shell, if any.<\/span><\/li>\r\n \t
    2. It sets the return code ($?) for your script<\/span>.<\/li>\r\n<\/ol>\r\n
      \r\n
      Example - exit command usage<\/p>\r\n\r\n<\/header>\r\n
      \r\n\r\nThe trivial but illustrative script exit_example shows the exit command setting return code for the script to 3 and then terminating the script.\u00a0 Control returns to the calling program, in this case just back to the operating system prompt.<\/span>\r\n
      $ cat exit_example<\/strong>\r\n#!\/bin\/bash\r\nexit 3\r\necho This line never executed.\r\n\r\n$ .\/exit_example<\/strong>\r\n$ echo $?<\/strong>\r\n3\r\n$<\/pre>\r\nNote that one must inspect the return code ($?) immediately after running exit_example.\u00a0 The return code is updated (overwritten) by each Unix command executed. <\/span>\r\n\r\n<\/div>\r\n<\/div>\r\n
      The exit command is typically used to terminate a script midway through often due to an errror condition. The other primary use of the exit command is for a sub-script to communicate information back to the calling script.<\/span><\/p>\r\n \r\n
      \r\n
      Example - parent\/child script relation<\/p>\r\n\r\n<\/header>\r\n
      \r\n\r\n\r\n\r\n\r\n\r\n
      \r\n
      parent<\/span><\/p>\r\n<\/th>\r\n
      		\r\n
      child<\/span><\/p>\r\n<\/th>\r\n<\/tr>\r\n<\/thead>\r\n
      \r\n
      .\/child\u00a0\r\n<\/span>ret_val=$?\r\n<\/span>case $ret_val<\/span><\/pre>\r\n<\/td>\r\n
      		\r\n
      ...<\/span>\r\n\u00a0 \u00a0exit 2\r\n<\/span>...\r\n<\/span>exit 0<\/span><\/pre>\r\n<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n
      Note: parent-child relationship can be used for team project where multiple people can work on the same file at the same time.<\/span><\/p>\r\n\r\n<\/div>\r\n<\/div>\r\n
      \u00a0<\/span><\/p>\r\n\r\n
      Shebang line<\/span><\/h2>\r\n
      To specify which interpreter Unix should use when executing your script, as the first line of the file place the path to the interpreter after \"#!\". \u00a0While the number sign character (#) normally introduces a comment, when used with the exclamation mark at the beginning of a file, Unix will load the interpreter specified in the path to run the rest of the script file.<\/span><\/p>\r\n
      This is especially important to make your script portable in Unix environments. \u00a0If you write your script in bash, and you give your script for someone else to use who works in a c-shell or Korn shell environment, your script may not work properly. \u00a0To ensure that the script is run under bash, you must specify the shebang line.<\/span><\/p>\r\n
      Careful: \u00a0The shebang line must be the first line of the file<\/span>, not just the first line of text, or the first line of code. \u00a0A common mistake is to have a blank line as the first line, or some comments above the shebang line. \u00a0Unix does not look beyond the first line of the file in order to identify the expected interpreter.<\/span><\/p>\r\n\r\n\r\n\r\n\r\n\r\n\r\n
      \r\n
      Right<\/span><\/p>\r\n<\/th>\r\n
      		\r\n
      Wrong<\/span><\/p>\r\n<\/th>\r\n
      		\r\n
      Wrong<\/span><\/p>\r\n<\/th>\r\n<\/tr>\r\n<\/thead>\r\n
      \r\n
      1:#!\/bin\/bash\r\n<\/span>2:#comments\r\n<\/span>3:#comments\r\n<\/span>4:code begins here\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 <\/span><\/pre>\r\n<\/td>\r\n
      		\r\n
      1:#comments\r\n<\/span>2:#comments\r\n<\/span>3:#!\/bin\/bash\r\n<\/span>4:code begins here<\/span><\/pre>\r\n<\/td>\r\n
      		\r\n
      1:\r\n2:#!\/bin\/bash\r\n3:\r\n4:<\/span>code begins here<\/span><\/pre>\r\n<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n[h5p id=\"9\"]<\/span>\r\n\r\n ","rendered":"
      In order to support control structures (branching, looping, etc.), all computer languages need some method of evaluating a condition. \u00a0In Unix, the command to evaluate a condition is the test command. \u00a0The test command is often at the heart of most control structures in Unix.<\/span><\/p>\n
       <\/p>\n
      test<\/span><\/h1>\n
      What does the test command do? \u00a0It evaluates a condition and sets the special shell variable $?, the return code. \u00a0Much to the confusion of new users, the test command is silent in that it does not print anything to standard output. \u00a0Thus when running the test command, it appears as if to do nothing. \u00a0To check the return code, one may simply print its value with an echo statement.<\/span><\/p>\n
      \n
      \n
      Example 1: \u00a0Check if a file is readable.<\/span><\/p>\n<\/header>\n
      \n
      $ test -r myfile<\/strong><\/span>\r\n$ echo $?<\/strong><\/span>\r\n0<\/span><\/pre>\n<\/div>\n<\/div>\n
      \u00a0<\/span><\/p>\n
      How does one interpret the return code? \u00a0 <\/span><\/p>\n
      Unix convention:<\/span><\/p>\n\n\n\n\n
      \n
      0 (zero)<\/span><\/p>\n<\/th>\n
      		\n
      means TRUE<\/span><\/p>\n<\/td>\n<\/tr>\n
      \n
      not 0 (not zero)<\/span><\/p>\n<\/th>\n
      		\n
      means FALSE<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
      \u00a0<\/span><\/p>\n
      \n
      \n
      Example 2: \u00a0Compare if two strings are equal.<\/span><\/p>\n<\/header>\n
      \n
      $ test \"this\" = \"that\"<\/strong><\/span>\r\n$ echo $?<\/strong><\/span>\r\n1<\/span><\/pre>\n<\/div>\n<\/div>\n
      \u00a0<\/span><\/p>\n
      Synonym to the test command: \u00a0[<\/span><\/h2>\n
      For reasons of readability, many programmers with use the synonym or abbreviation for the test command which is the left square bracket: [ . \u00a0In all examples above, replace the word test with the left square bracket. \u00a0Note that a matching right square bracket needs to be added for syntactic reasons. \u00a0As with all Unix commands, spaces are a big deal and a space is required after the left square bracket and before the right square bracket.<\/span><\/p>\n
      \u00a0<\/span><\/p>\n
      \n
      \n
      Example 3: Synonym to the test command [<\/span><\/p>\n<\/header>\n
      \n
      $ [ -r myfile ]<\/strong> # note the space after the left bracket<\/span>\r\n$ echo $?<\/span>\r\n<\/strong>0<\/span>\u00a0<\/span><\/pre>\n<\/div>\n<\/div>\n
       <\/p>\n
      Control Structures<\/span><\/h1>\n
      if<\/span><\/h2>\n
      The if statement in Unix is the basic two-way branch.<\/span><\/p>\n
       <\/p>\n
      \n
      Syntax<\/span><\/p>\n
      if unix_statements<\/span>\r\nthen<\/span>\r\n  \u00a0actions_true<\/span>\r\nelse \u00a0# optional<\/span>\r\n  \u00a0actions_false<\/span>\r\nfi<\/span><\/pre>\n<\/div>\n
      How does the if statement work? \u00a0Here is the sequence of operations. \u00a0The if statement will:<\/span><\/p>\n
        \n
      1. Run all the unix_statements. \u00a0 <\/span><\/li>\n
      2. Check the return code ($?) of the last statement in the list (just prior to the keyword “then”. <\/span><\/li>\n
      3. If the return code is true. the “then” clause is executed (
        \nactions_true)<\/span>. \u00a0If the return code is false, the “else” clause is executed (actions_false)<\/span>. \u00a0The else clause is optional (can be left out if not needed).<\/span><\/li>\n<\/ol>\n
        \n
        \n
        Example of if<\/span><\/p>\n<\/header>\n
        \n
        #!\/bin\/bash<\/span>\r\ncomfort=20<\/span>\r\ntemperature=18<\/span>\r\nif echo The current temperature is $temperature<\/span>\r\n  \u00a0echo Temperature for comparison is $comfort<\/span>\r\n  \u00a0[ $temperature -lt $comfort ]<\/span>\r\nthen<\/span>\r\n  echo It is cold.<\/span>\r\nelse<\/span>\r\n  echo It is warm.<\/span>\r\nfi<\/span>\u00a0<\/span><\/pre>\n<\/div>\n<\/div>\n
        \n