{"id":35,"date":"2022-03-04T15:11:16","date_gmt":"2022-03-04T20:11:16","guid":{"rendered":"https:\/\/pressbooks.library.ryerson.ca\/opsyshiraki\/chapter\/shellvariables\/"},"modified":"2023-09-01T13:25:15","modified_gmt":"2023-09-01T17:25:15","slug":"shellvariables","status":"publish","type":"chapter","link":"https:\/\/pressbooks.library.torontomu.ca\/opsyshiraki\/chapter\/shellvariables\/","title":{"raw":"Shell Variables, Quotes, Command Substitution","rendered":"Shell Variables, Quotes, Command Substitution"},"content":{"raw":"

Shell Variables<\/h1>\r\n

Unix is an operating system but also the name given to its scripting (programming) language. In order to be useful, a computer language needs to be able to store data. Unix supports this capability with shell variables. <\/span><\/p>\r\n

There are three kinds of shell variables:<\/span><\/p>\r\n\r\n

    \r\n \t
  1. special<\/span><\/li>\r\n \t
  2. environment<\/span><\/li>\r\n \t
  3. program<\/span><\/li>\r\n<\/ol>\r\n

    Special variables<\/span><\/h2>\r\n

    Special variables are unlike what you may have seen in other programming languages. Rather special variables are created and set by the operating system automatically. Consider the following examples:<\/span><\/p>\r\n

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

    Positional parameters ($1, $2, \u2026)<\/span><\/h3>\r\n

    Recall that the cat program allows the user to specify inputs as command-line arguments:\u00a0 (In the following examples, the leading dollar sign represents the command prompt; do not type the leading dollar sign.)<\/span><\/p>\r\n\r\n

    $ cat ch1 ch2 ch3<\/strong><\/span><\/pre>\r\n
    Imagine that you would like to write your own script allowing the user to specify inputs as command-line arguments as in. <\/span><\/p>\r\n \r\n
    $ myscript apple cherry<\/strong><\/span><\/pre>\r\n
    \r\n
    Example<\/p>\r\n\r\n<\/header>\r\n
    \r\n
    $ cat arg_demo<\/strong><\/span>\r\n#!\/bin\/bash<\/span>\r\necho The 1st argument is $1<\/span>\r\necho The 2nd argument is $2<\/span>\r\n$\r\n$ .\/arg_demo apple cherry<\/strong><\/span>\r\nThe 1st argument is apple<\/span>\r\nThe 2nd argument is cherry<\/span>\r\n\r\n<\/pre>\r\n<\/div>\r\n<\/div>\r\n
    number of command line arguments ($#)<\/span><\/h3>\r\n
    The special variable $# holds the number of command-line arguments specified when your script was run.<\/span><\/p>\r\n\r\n
    \r\n
    Examples<\/p>\r\n\r\n<\/header>\r\n
    \r\n
    $ cat numeg<\/strong>\r\n#!\/bin\/bash\r\n<\/span>echo The number of command line arguments is $#\r\n$\r\n$ .\/numeg apple<\/strong><\/span> cherry\r\n<\/span><\/strong>The number of command line arguments is 2\r\n<\/span>$<\/pre>\r\n<\/div>\r\n<\/div>\r\n \r\n
    return code of previous command ($?)<\/span><\/h3>\r\n
    Every Unix command generates a return code typically indicating success or failure. The value of this return code is stored in the special variable $?. Thus each time a Unix command is run the $? variable is updated automatically to hold the return code of the most recently executed Unix command. \u00a0The use of the return code is important and will become apparent in the chapter on control structures. <\/span><\/p>\r\n\r\n
    Environment <\/span>variables<\/span><\/h2>\r\n
    Environment variables hold information about the users's current settings and configuration. By convention, they are typically all UPPERCASE. To display them, type \u2018env\u2019<\/span><\/p>\r\n\r\n
    \r\n
    Example<\/p>\r\n\r\n<\/header>\r\n
    \r\n
    lhiraki@metis:~$ env<\/strong>\r\nSHELL=\/bin\/bash\r\nPATH=\/usr\/local\/bin:\/usr\/bin:\/bin:\/usr\/local\/games:\/usr\/games:\/snap\/bin:\/usr\/courses\/bin\/x86_64\r\nJAVA_HOME=\/usr\/lib\/jvm\/java-8-openjdk-amd64\r\nEDITOR=vi\r\nLANGUAGE=en_CA:en\r\nLPDEST=eng206c\r\nlhiraki@metis:~$\r\n<\/span><\/pre>\r\nHere is an abridged list of environment variables.\u00a0 Some of the typical environment variables include SHELL (current shell), PATH (list of directories the operating system will search in order to find a command), EDITOR (preferred editor), LANGUAGE (preferred display language), LPDEST (preferred printer destination).\r\n\r\n<\/div>\r\n<\/div>\r\n \r\n
    Program <\/span>variables<\/span><\/h2>\r\n
    Program variables are the type of variable that typically come to mind when one thinks of variables in a computer programming language. Program variables are variables which you as the programmer create and set. As Unix is a prototyping language, it is common to dispense with many of the formalities required for variable declarations, etc. <\/span><\/p>\r\n
    \u00a0<\/span><\/p>\r\n
    Program variables hold a string, i.e. text, and can be used anywhere text could appear in a program such as a filename, part of the file name, or even a Unix command itself. \u00a0A variable can hold only one value at a time. <\/span><\/p>\r\n
    \u00a0<\/span><\/p>\r\n
    The naming convention for program variables is to use lowercase. Specifically uppercase program variable names should be avoided so as to prevent confusion with environment variables and accidentally overwriting an environment variable.<\/span><\/p>\r\n
    \u00a0<\/span><\/p>\r\n
    \u00a0<\/span><\/p>\r\n
    \u00a0<\/span><\/p>\r\n\r\n
    \r\n
    Eg. 1 \u00a0An easy way to create and set a program variable is using an assignment statement.<\/span><\/p>\r\n\r\n<\/header>\r\n
    \r\n
    temp_name=\/usr\/temp<\/span>\r\ncp myfile $temp_name<\/span><\/pre>\r\n<\/div>\r\n<\/div>\r\n
    \u00a0<\/span><\/p>\r\n
    Assignment statements copy the value to the right of the equal sign to the variable on the left. \u00a0Important: \u00a0Assignment statements must not contain spaces, especially around the equal sign.<\/span><\/p>\r\n
    \u00a0<\/span><\/p>\r\n\r\n
    \r\n
    Eg. 2<\/p>\r\n\r\n<\/header>\r\n
    \r\n
    month=september <\/span>\r\necho the current month is $month<\/span><\/pre>\r\n<\/div>\r\n<\/div>\r\n
    When to use $ with variables<\/span><\/h3>\r\n
    When writing to a variable, i.e. setting or changing its contents, do not use the dollar sign. When reading a variable, i.e. accessing its contents, you must use the dollar sign.<\/span><\/p>\r\n
    \u00a0<\/span><\/p>\r\n\r\n
    \r\n
    Key Takeaway - When to use $ with variables:<\/span><\/p>\r\n\r\n<\/header>\r\n
    \r\n
    Writing<\/strong> to a variable: no<\/strong> dollar sign<\/span><\/p>\r\n
    Reading<\/strong> from a variable: use<\/strong> dollar sign<\/span><\/p>\r\n\r\n<\/div>\r\n<\/div>\r\n
    \r\n
    Editorial Remark:<\/p>\r\nOne of the key factors affected software maintenance costs is code readability.\u00a0 Most of the time (cost) of maintaining software is spent in having designers read and understand existing code.\u00a0 One way to control and reduce costs (business competitiveness) is to ease readability.\u00a0 By choosing variables which reflect their contents, it makes it easier to understand the code.\r\n
    Choose self-describing variable names:<\/span><\/strong><\/p>\r\n\r\n\r\n\r\n\r\n\r\n\r\n
    Good variable names:<\/span><\/th>\r\nBad variable names:<\/span><\/th>\r\n<\/tr>\r\n<\/thead>\r\n
    \r\n
      \r\n \t
    • sum <\/span><\/li>\r\n \t
    • total<\/span><\/li>\r\n \t
    • x_value<\/span><\/li>\r\n \t
    • length <\/span><\/li>\r\n \t
    • count<\/span><\/li>\r\n<\/ul>\r\n<\/td>\r\n
    		\r\n
      \r\n \t
    • a,b,c\u2026.<\/span><\/li>\r\n \t
    • var1, var2, var3\u2026.<\/span><\/li>\r\n<\/ul>\r\n<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n\u00a0<\/span>\r\n\r\n<\/div>\r\n
      read<\/span><\/h1>\r\n
      The read command collects characters from standard input (STDIN) and stores them in a variable. \u00a0The read command is typically used in an interactive script to collect user input after an appropriate prompt message. \u00a0As the read command draws from standard input, and standard input can be redirected from a file, it is possible to prepare inputs (answers) in a file and run the script in a non-interactive fashion.<\/span><\/p>\r\n
      \u00a0<\/span><\/p>\r\n\r\n
      \r\n
      Example using read command<\/p>\r\n\r\n<\/header>\r\n
      \r\n
      $ cat readeg<\/strong><\/span>\r\necho -n 'What is your name? '<\/span>\r\nread name<\/span>\r\necho Hello $name, pleased to meet you!<\/span>\r\n$<\/span>\r\n$ .\/readeg<\/strong><\/span>\r\nWhat is your name? Mohammed<\/strong><\/span>\r\nHello Mohammed, pleased to meet you!<\/span>\r\n$<\/span><\/pre>\r\n<\/div>\r\n<\/div>\r\n
      \r\n\r\nWhat does the option \"-n\" do in the echo command above?\r\n\r\nHint: type \"man echo\".\u00a0 To exit the manual, press \"q\".\r\n\r\n<\/div>\r\n
      <\/div>\r\n
      \r\n
      Key Takeaways<\/p>\r\n\r\n<\/header>\r\n
      \r\n
      read vs. command line arguments<\/span><\/p>\r\n\r\n
        \r\n \t
      • Both are ways the user can supply input to a program.\u00a0 Command line arguments are placed on the command line before pressing <ENTER> to run the program.\u00a0 The values are accessed within one's program using $1, $2, etc.<\/span><\/li>\r\n \t
      • The \"read\" command causes the program to wait for keyboard input (if STDIN has not been redirected from a file).\u00a0 The input is stored in and later accessed from a program variable.<\/span><\/li>\r\n<\/ul>\r\n
        Which method should you use?\u00a0 Refer first to any program requirements. (Does it say, \"Prompt the user to enter ...\" or \"specify as a command line argument\"?)<\/span><\/p>\r\n\r\n<\/div>\r\n<\/div>\r\n \r\n
        Quotes<\/span><\/h1>\r\n
        Single quotes:<\/span><\/h2>\r\n
        Problem:<\/span><\/p>\r\n\r\n
        $ grep Al Shaji employee_list<\/strong><\/span>\r\ngrep: can\u2019t open Shaji<\/span><\/pre>\r\n
        Solution: <\/span><\/p>\r\n\r\n
        $ grep 'Al Shaji' employee_list\r\n\r\n<\/strong><\/span><\/pre>\r\nSingle quotes causes Unix to take everything within the single quotes literally.\u00a0 This is how you would prevent interpretation of characters which would normally have special meaning, for example the space character separating command line arguments.\r\n
        Double quotes<\/span><\/h2>\r\n
          \r\n \t
        • Recognize $, \\, ` (backtick or backquote) <\/span><\/li>\r\n<\/ul>\r\n \r\n
          \r\n
          Exercise 1:\u00a0 Try this out and see the difference double quotes makes<\/p>\r\n\r\n<\/header>\r\n
          \r\n
          heading=' \u00a0 \u00a0Name \u00a0 \u00a0 Addr \u00a0 \u00a0 Phone'<\/span>\r\necho $heading<\/span>\r\necho \"$heading\"<\/span><\/pre>\r\n<\/div>\r\n<\/div>\r\n \r\n
          \r\n
          Exercise 2: Try this out and see the difference double quotes makes<\/span><\/p>\r\n\r\n<\/header>\r\n
          \r\n
          read operator # enter asterisk *<\/span>\r\necho $operator<\/span>\r\necho \"$operator\"<\/span><\/pre>\r\n<\/div>\r\n<\/div>\r\n
          The double quotes are similar to single quotes in that Unix takes what is within the quotes literally.\u00a0 However, double quotes are \"smarter\" in that variables and selected meta-characters are interpreted and expanded in spite of the usual literal nature of quotes.\u00a0 <\/span><\/p>\r\n \r\n
          Home directory potential tricky issue (tilde is protected i.e. not expanded within quotes).<\/span><\/h3>\r\n
          Instead of:<\/span><\/p>\r\n\r\n
          datafile=\"~jasmin\/rawdata\"<\/span>\r\ncat $datafile \u00a0# produces \"No such file or directory\" error<\/span><\/pre>\r\n
          Say (solution 1):<\/span><\/p>\r\n\r\n
          datafile=~jasmin\/rawdata<\/span>\r\ncat $datafile<\/span><\/pre>\r\n
          Say (solution 2):<\/span><\/p>\r\n\r\n
          datafile=\"~jasmin\/rawdata\"<\/span>\r\neval cat $datafile<\/span><\/pre>\r\n
          \u00a0<\/span><\/p>\r\n\r\n
          Command substitution<\/span><\/h1>\r\n
          Sometimes a programmer wishes to run a command and use its output at some point within a program. \u00a0While it is possible to redirect output to a temporary file, load the contents of the file, and then promptly delete it, for small tasks, it is more convenient and efficient to use the technique of command substitution <\/span><\/em>\u00a0and avoid extra disc access. <\/span><\/p>\r\n
          \u00a0<\/span><\/p>\r\n\r\n
          \r\n
          Eg. 1 \u00a0Newbie's first guess<\/span><\/p>\r\n\r\n<\/header>\r\n
          \r\n
          today=date<\/span>\r\necho $today<\/span><\/pre>\r\n<\/div>\r\n<\/div>\r\n \r\n
          \u00a0<\/span><\/p>\r\n\r\n
          \r\n
          Eg. 2 This is the way to do it.<\/span><\/p>\r\n\r\n<\/header>\r\n
          \r\n
          today=$(date) \u00a0(old version today=`date`)<\/span>\r\necho $today<\/span><\/pre>\r\n<\/div>\r\n<\/div>\r\n \r\n
          \u00a0<\/span><\/p>\r\n\r\n
          \r\n
          Syntax:<\/span><\/p>\r\n\r\n
          $(unix_command)<\/span><\/pre>\r\n<\/div>\r\n
          The mechanics of command substitution works as follows:<\/span><\/p>\r\n\r\n
            \r\n \t
          1. Unix will run the command within the parentheses as if it were typed at the keyboard. \u00a0The command may include options, command line arguments, or even be a script.<\/span><\/li>\r\n \t
          2. Instead of being displayed on the screen, the standard output (STDOUT) of the command is substituted at the exact position of the call ($(unix_command)). \u00a0<\/span><\/li>\r\n<\/ol>\r\n
            \u00a0<\/span><\/p>\r\n
            The command substitution may be made anywhere in a program; however, it is often used on the right-hand side of an assignment statement (to save the output in a variable), or within an echo statement.<\/span><\/p>\r\n \r\n\r\n[h5p id=\"10\"]<\/span>\r\n\r\n ","rendered":"
            Shell Variables<\/h1>\n
            Unix is an operating system but also the name given to its scripting (programming) language. In order to be useful, a computer language needs to be able to store data. Unix supports this capability with shell variables. <\/span><\/p>\n
            There are three kinds of shell variables:<\/span><\/p>\n
              \n
            1. special<\/span><\/li>\n
            2. environment<\/span><\/li>\n
            3. program<\/span><\/li>\n<\/ol>\n
              Special variables<\/span><\/h2>\n
              Special variables are unlike what you may have seen in other programming languages. Rather special variables are created and set by the operating system automatically. Consider the following examples:<\/span><\/p>\n
              \u00a0<\/span><\/p>\n
              Positional parameters ($1, $2, \u2026)<\/span><\/h3>\n
              Recall that the cat program allows the user to specify inputs as command-line arguments:\u00a0 (In the following examples, the leading dollar sign represents the command prompt; do not type the leading dollar sign.)<\/span><\/p>\n
              $ cat ch1 ch2 ch3<\/strong><\/span><\/pre>\n
              Imagine that you would like to write your own script allowing the user to specify inputs as command-line arguments as in. <\/span><\/p>\n
               <\/p>\n
              $ myscript apple cherry<\/strong><\/span><\/pre>\n
              \n
              \n
              Example<\/p>\n<\/header>\n
              \n
              $ cat arg_demo<\/strong><\/span>\r\n#!\/bin\/bash<\/span>\r\necho The 1st argument is $1<\/span>\r\necho The 2nd argument is $2<\/span>\r\n$\r\n$ .\/arg_demo apple cherry<\/strong><\/span>\r\nThe 1st argument is apple<\/span>\r\nThe 2nd argument is cherry<\/span>\r\n\r\n<\/pre>\n<\/div>\n<\/div>\n
              number of command line arguments ($#)<\/span><\/h3>\n
              The special variable $# holds the number of command-line arguments specified when your script was run.<\/span><\/p>\n
              \n
              \n
              Examples<\/p>\n<\/header>\n
              \n
              $ cat numeg<\/strong>\r\n#!\/bin\/bash\r\n<\/span>echo The number of command line arguments is $#\r\n$\r\n$ .\/numeg apple<\/strong><\/span> cherry\r\n<\/span><\/strong>The number of command line arguments is 2\r\n<\/span>$<\/pre>\n<\/div>\n<\/div>\n
               <\/p>\n
              return code of previous command ($?)<\/span><\/h3>\n
              Every Unix command generates a return code typically indicating success or failure. The value of this return code is stored in the special variable $?. Thus each time a Unix command is run the $? variable is updated automatically to hold the return code of the most recently executed Unix command. \u00a0The use of the return code is important and will become apparent in the chapter on control structures. <\/span><\/p>\n
              Environment <\/span>variables<\/span><\/h2>\n
              Environment variables hold information about the users’s current settings and configuration. By convention, they are typically all UPPERCASE. To display them, type \u2018env\u2019<\/span><\/p>\n
              \n
              \n
              Example<\/p>\n<\/header>\n
              \n
              lhiraki@metis:~$ env<\/strong>\r\nSHELL=\/bin\/bash\r\nPATH=\/usr\/local\/bin:\/usr\/bin:\/bin:\/usr\/local\/games:\/usr\/games:\/snap\/bin:\/usr\/courses\/bin\/x86_64\r\nJAVA_HOME=\/usr\/lib\/jvm\/java-8-openjdk-amd64\r\nEDITOR=vi\r\nLANGUAGE=en_CA:en\r\nLPDEST=eng206c\r\nlhiraki@metis:~$\r\n<\/span><\/pre>\n
              Here is an abridged list of environment variables.\u00a0 Some of the typical environment variables include SHELL (current shell), PATH (list of directories the operating system will search in order to find a command), EDITOR (preferred editor), LANGUAGE (preferred display language), LPDEST (preferred printer destination).<\/p>\n<\/div>\n<\/div>\n
               <\/p>\n
              Program <\/span>variables<\/span><\/h2>\n
              Program variables are the type of variable that typically come to mind when one thinks of variables in a computer programming language. Program variables are variables which you as the programmer create and set. As Unix is a prototyping language, it is common to dispense with many of the formalities required for variable declarations, etc. <\/span><\/p>\n
              \u00a0<\/span><\/p>\n
              Program variables hold a string, i.e. text, and can be used anywhere text could appear in a program such as a filename, part of the file name, or even a Unix command itself. \u00a0A variable can hold only one value at a time. <\/span><\/p>\n
              \u00a0<\/span><\/p>\n
              The naming convention for program variables is to use lowercase. Specifically uppercase program variable names should be avoided so as to prevent confusion with environment variables and accidentally overwriting an environment variable.<\/span><\/p>\n
              \u00a0<\/span><\/p>\n
              \u00a0<\/span><\/p>\n
              \u00a0<\/span><\/p>\n
              \n
              \n
              Eg. 1 \u00a0An easy way to create and set a program variable is using an assignment statement.<\/span><\/p>\n<\/header>\n
              \n
              temp_name=\/usr\/temp<\/span>\r\ncp myfile $temp_name<\/span><\/pre>\n<\/div>\n<\/div>\n
              \u00a0<\/span><\/p>\n
              Assignment statements copy the value to the right of the equal sign to the variable on the left. \u00a0Important: \u00a0Assignment statements must not contain spaces, especially around the equal sign.<\/span><\/p>\n
              \u00a0<\/span><\/p>\n
              \n
              \n
              Eg. 2<\/p>\n<\/header>\n
              \n
              month=september <\/span>\r\necho the current month is $month<\/span><\/pre>\n<\/div>\n<\/div>\n
              When to use $ with variables<\/span><\/h3>\n
              When writing to a variable, i.e. setting or changing its contents, do not use the dollar sign. When reading a variable, i.e. accessing its contents, you must use the dollar sign.<\/span><\/p>\n
              \u00a0<\/span><\/p>\n
              \n
              \n
              Key Takeaway – When to use $ with variables:<\/span><\/p>\n<\/header>\n
              \n
              Writing<\/strong> to a variable: no<\/strong> dollar sign<\/span><\/p>\n
              Reading<\/strong> from a variable: use<\/strong> dollar sign<\/span><\/p>\n<\/div>\n<\/div>\n
              \n
              Editorial Remark:<\/p>\n
              One of the key factors affected software maintenance costs is code readability.\u00a0 Most of the time (cost) of maintaining software is spent in having designers read and understand existing code.\u00a0 One way to control and reduce costs (business competitiveness) is to ease readability.\u00a0 By choosing variables which reflect their contents, it makes it easier to understand the code.<\/p>\n
              Choose self-describing variable names:<\/span><\/strong><\/p>\n\n\n\n\n\n
              Good variable names:<\/span><\/th>\nBad variable names:<\/span><\/th>\n<\/tr>\n<\/thead>\n
              \n
                \n
              • sum <\/span><\/li>\n
              • total<\/span><\/li>\n
              • x_value<\/span><\/li>\n
              • length <\/span><\/li>\n
              • count<\/span><\/li>\n<\/ul>\n<\/td>\n
              		\n
                \n
              • a,b,c\u2026.<\/span><\/li>\n
              • var1, var2, var3\u2026.<\/span><\/li>\n<\/ul>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                \u00a0<\/span><\/p>\n<\/div>\n
                read<\/span><\/h1>\n
                The read command collects characters from standard input (STDIN) and stores them in a variable. \u00a0The read command is typically used in an interactive script to collect user input after an appropriate prompt message. \u00a0As the read command draws from standard input, and standard input can be redirected from a file, it is possible to prepare inputs (answers) in a file and run the script in a non-interactive fashion.<\/span><\/p>\n
                \u00a0<\/span><\/p>\n
                \n
                \n
                Example using read command<\/p>\n<\/header>\n
                \n
                $ cat readeg<\/strong><\/span>\r\necho -n 'What is your name? '<\/span>\r\nread name<\/span>\r\necho Hello $name, pleased to meet you!<\/span>\r\n$<\/span>\r\n$ .\/readeg<\/strong><\/span>\r\nWhat is your name? Mohammed<\/strong><\/span>\r\nHello Mohammed, pleased to meet you!<\/span>\r\n$<\/span><\/pre>\n<\/div>\n<\/div>\n
                \n
                What does the option “-n” do in the echo command above?<\/p>\n
                Hint: type “man echo”.\u00a0 To exit the manual, press “q”.<\/p>\n<\/div>\n
                <\/div>\n
                \n
                \n
                Key Takeaways<\/p>\n<\/header>\n
                \n
                read vs. command line arguments<\/span><\/p>\n
                  \n
                • Both are ways the user can supply input to a program.\u00a0 Command line arguments are placed on the command line before pressing <ENTER> to run the program.\u00a0 The values are accessed within one’s program using $1, $2, etc.<\/span><\/li>\n
                • The “read” command causes the program to wait for keyboard input (if STDIN has not been redirected from a file).\u00a0 The input is stored in and later accessed from a program variable.<\/span><\/li>\n<\/ul>\n
                  Which method should you use?\u00a0 Refer first to any program requirements. (Does it say, “Prompt the user to enter …” or “specify as a command line argument”?)<\/span><\/p>\n<\/div>\n<\/div>\n
                   <\/p>\n
                  Quotes<\/span><\/h1>\n
                  Single quotes:<\/span><\/h2>\n
                  Problem:<\/span><\/p>\n
                  $ grep Al Shaji employee_list<\/strong><\/span>\r\ngrep: can\u2019t open Shaji<\/span><\/pre>\n
                  Solution: <\/span><\/p>\n
                  $ grep 'Al Shaji' employee_list\r\n\r\n<\/strong><\/span><\/pre>\n
                  Single quotes causes Unix to take everything within the single quotes literally.\u00a0 This is how you would prevent interpretation of characters which would normally have special meaning, for example the space character separating command line arguments.<\/p>\n
                  Double quotes<\/span><\/h2>\n
                    \n
                  • Recognize $, \\, ` (backtick or backquote) <\/span><\/li>\n<\/ul>\n
                     <\/p>\n
                    \n
                    \n
                    Exercise 1:\u00a0 Try this out and see the difference double quotes makes<\/p>\n<\/header>\n
                    \n
                    heading=' \u00a0 \u00a0Name \u00a0 \u00a0 Addr \u00a0 \u00a0 Phone'<\/span>\r\necho $heading<\/span>\r\necho \"$heading\"<\/span><\/pre>\n<\/div>\n<\/div>\n
                     <\/p>\n
                    \n
                    \n
                    Exercise 2: Try this out and see the difference double quotes makes<\/span><\/p>\n<\/header>\n
                    \n
                    read operator # enter asterisk *<\/span>\r\necho $operator<\/span>\r\necho \"$operator\"<\/span><\/pre>\n<\/div>\n<\/div>\n
                    The double quotes are similar to single quotes in that Unix takes what is within the quotes literally.\u00a0 However, double quotes are “smarter” in that variables and selected meta-characters are interpreted and expanded in spite of the usual literal nature of quotes.\u00a0 <\/span><\/p>\n
                     <\/p>\n
                    Home directory potential tricky issue (tilde is protected i.e. not expanded within quotes).<\/span><\/h3>\n
                    Instead of:<\/span><\/p>\n
                    datafile=\"~jasmin\/rawdata\"<\/span>\r\ncat $datafile \u00a0# produces \"No such file or directory\" error<\/span><\/pre>\n
                    Say (solution 1):<\/span><\/p>\n
                    datafile=~jasmin\/rawdata<\/span>\r\ncat $datafile<\/span><\/pre>\n
                    Say (solution 2):<\/span><\/p>\n
                    datafile=\"~jasmin\/rawdata\"<\/span>\r\neval cat $datafile<\/span><\/pre>\n
                    \u00a0<\/span><\/p>\n
                    Command substitution<\/span><\/h1>\n
                    Sometimes a programmer wishes to run a command and use its output at some point within a program. \u00a0While it is possible to redirect output to a temporary file, load the contents of the file, and then promptly delete it, for small tasks, it is more convenient and efficient to use the technique of command substitution <\/span><\/em>\u00a0and avoid extra disc access. <\/span><\/p>\n
                    \u00a0<\/span><\/p>\n
                    \n
                    \n
                    Eg. 1 \u00a0Newbie’s first guess<\/span><\/p>\n<\/header>\n
                    \n
                    today=date<\/span>\r\necho $today<\/span><\/pre>\n<\/div>\n<\/div>\n
                     <\/p>\n
                    \u00a0<\/span><\/p>\n
                    \n
                    \n
                    Eg. 2 This is the way to do it.<\/span><\/p>\n<\/header>\n
                    \n
                    today=$(date) \u00a0(old version today=`date`)<\/span>\r\necho $today<\/span><\/pre>\n<\/div>\n<\/div>\n
                     <\/p>\n
                    \u00a0<\/span><\/p>\n
                    \n
                    Syntax:<\/span><\/p>\n
                    $(unix_command)<\/span><\/pre>\n<\/div>\n
                    The mechanics of command substitution works as follows:<\/span><\/p>\n
                      \n
                    1. Unix will run the command within the parentheses as if it were typed at the keyboard. \u00a0The command may include options, command line arguments, or even be a script.<\/span><\/li>\n
                    2. Instead of being displayed on the screen, the standard output (STDOUT) of the command is substituted at the exact position of the call ($(unix_command)). \u00a0<\/span><\/li>\n<\/ol>\n
                      \u00a0<\/span><\/p>\n
                      The command substitution may be made anywhere in a program; however, it is often used on the right-hand side of an assignment statement (to save the output in a variable), or within an echo statement.<\/span><\/p>\n
                       <\/p>\n
                      <\/p>\n
                      \n