{"id":34,"date":"2022-03-04T15:11:16","date_gmt":"2022-03-04T20:11:16","guid":{"rendered":"https:\/\/pressbooks.library.ryerson.ca\/opsyshiraki\/chapter\/lecture-2-part-2-2\/"},"modified":"2025-04-29T14:16:22","modified_gmt":"2025-04-29T18:16:22","slug":"inputoutput","status":"publish","type":"chapter","link":"https:\/\/pressbooks.library.torontomu.ca\/opsyshiraki\/chapter\/inputoutput\/","title":{"raw":"Input and Output: Redirection and Pipes","rendered":"Input and Output: Redirection and Pipes"},"content":{"raw":"

By design most Unix commands are small and simple in their functionality. \u00a0To solve beyond the trivial requires the use of several steps or commands. \u00a0How to sequence and combine commands in Unix requires an understanding of how input and output is managed. \u00a0The next sections will introduce these concepts and show how more complex problems may be solved.<\/span><\/p>\r\n\r\n

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

One may think of a filter as a black box with an input and an output. Most Unix commands can be thought of as a filter. \u00a0The inputs and outputs have been given formal names. The input is named standard input <\/span>(STDIN); the output is named standard output <\/span>(STDOUT); and there is a secondary output named standard error <\/span>\u00a0(STDERR) which will be discussed in more detail later. \u00a0These inputs and outputs are associated with file descriptors or stream numbers 0, 1, and 2 respectively.<\/span><\/p>\r\n

By default, Unix commands read from standard input and print to standard output. \u00a0 Any error messages are sent to standard error.\r\n\r\n\"\r\n<\/span><\/p>\r\n\r\n

Examples of Unix commands as filters<\/span><\/h2>\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n
Command<\/span><\/th>\r\n\r\n

Description<\/span><\/p>\r\n<\/th>\r\n<\/tr>\r\n

\r\n
cut<\/span><\/pre>\r\n<\/th>\r\n
\r\n

reads from standard input and passes selected portions (columns, fields) to standard output<\/span><\/p>\r\n<\/th>\r\n<\/tr>\r\n

\r\n
grep<\/span><\/pre>\r\n<\/th>\r\n
\r\n

reads from standard input and prints matching lines to standard output<\/span><\/p>\r\n<\/th>\r\n<\/tr>\r\n

\r\n
head & tail<\/span><\/pre>\r\n<\/th>\r\n
\r\n

reads from standard input and prints the first (last) few lines to standard output<\/span><\/p>\r\n<\/th>\r\n<\/tr>\r\n

\r\n
cat <\/span><\/pre>\r\n<\/th>\r\n
\r\n

a transparent filter: reads from standard input and prints the same to standard output<\/span><\/p>\r\n<\/th>\r\n<\/tr>\r\n

\r\n
wc<\/span><\/pre>\r\n<\/th>\r\n
\r\n

reads from standard input and prints summary information to standard output<\/span><\/p>\r\n<\/th>\r\n<\/tr>\r\n

\r\n
...<\/span><\/pre>\r\n<\/th>\r\n
\r\n

not an exhaustive list<\/span><\/p>\r\n<\/th>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n

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

When working interactively in a Unix session, the default setup is to have standard input draw from the keyboard, and standard output (as well as standard error) directed at the screen. \u00a0In other words, a command reading from standard input will wait for keystrokes. A command printing to standard output will have its output appear on the terminal screen.<\/span><\/p>\r\n\r\n\r\n[caption id=\"\" align=\"alignnone\" width=\"939\"]\"arrow Default association of keyboard and screen to filter.[\/caption]\r\n

While this arrangement works well, there will come situations where the user will want to save the output of a command to a file, or substitute a file for keyboard input. \u00a0This is accomplished through the concept of redirection where one of the inputs or outputs is associated with a file.<\/span><\/p>\r\n\r\n

Redirection of standard output ( > operator)<\/span><\/h2>\r\n

\u00a0<\/span>The user can save the standard output of any Unix command by redirecting standard output to a file using the > operator. \u00a0Graphically, the concept is illustrated as follows.<\/span><\/p>\r\n\r\n\r\n[caption id=\"\" align=\"alignnone\" width=\"939\"]\"arrow Redirection of Standard Output[\/caption]\r\n\r\n\r\n\r\n\r\n\r\n
Operator syntax<\/span><\/th>\r\n\r\n

Examples and explanation<\/p>\r\n<\/td>\r\n<\/tr>\r\n

\r\n
cmd > some_file<\/span><\/pre>\r\n<\/th>\r\n
\r\n

e.g.<\/p>\r\n\r\n

cat chapter1 > book<\/span><\/pre>\r\n
    \r\n \t
  • \u00a0<\/span>if the file already exists it will overwrite it<\/span><\/li>\r\n<\/ul>\r\n<\/td>\r\n<\/tr>\r\n
\r\n
cmd >> some_file<\/span><\/pre>\r\n<\/th>\r\n
\r\n

e.g.<\/p>\r\n\r\n

cat chapter3 >> book<\/span><\/pre>\r\n
    \r\n \t
  • the >> operator appends an existing file<\/span><\/li>\r\n<\/ul>\r\n<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n
    Redirecting standard error ( 2> operator)<\/span><\/h2>\r\n
    The user can save the standard error of any Unix command by redirecting standard error to a file using the 2> operator. Graphically, the concept is illustrated as follows.<\/span><\/p>\r\n\r\n\r\n[caption id=\"\" align=\"alignnone\" width=\"939\"]\"arrow Redirection of Standard Error[\/caption]\r\n\r\n\r\n\r\n\r\n\r\n
    Operator syntax<\/span><\/th>\r\n\r\n
    Examples and explanation<\/p>\r\n<\/td>\r\n<\/tr>\r\n
    \r\n
    cmd 2> some_file<\/span><\/pre>\r\n<\/th>\r\n
    		\r\n
    e.g.\r\ncat chapter1 <\/span>chapter4 <\/span>2> errors<\/span><\/pre>\r\n
    \u00a0<\/span><\/p>\r\n\r\n
      \r\n \t
    • saves error messages in file errors but standard output is displayed on the screen<\/li>\r\n<\/ul>\r\n<\/td>\r\n<\/tr>\r\n
    \r\n
    cmd > some_file 2> another_file<\/span><\/pre>\r\n<\/th>\r\n
    		\r\n
    e.g.\r\ncat chapter1 > book 2> errors<\/span><\/pre>\r\n
    \u00a0<\/span><\/p>\r\n\r\n
      \r\n \t
    • saves standard output to file book, and saves standard error messages in file errors<\/span><\/li>\r\n<\/ul>\r\n<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n
      Merging two streams ( >& operator)<\/span><\/h2>\r\n
      \u00a0<\/span>The user can save both standard output and standard error of any Unix command.\u00a0 This is accomplished by first redirecting standard error to a file, and then merging standard error with standard output.\u00a0 The syntax of the merge operator is m>&n where stream m is merged with wherever stream n is already going.\u00a0 \u00a0Graphically, the concept is illustrated as follows.\u00a0 Here stream 2 (standard error) is merged with stream 1 (standard output).<\/span><\/p>\r\n
      \u00a0<\/span>\"arrow<\/p>\r\n
      Standard Output and Standard Error are merged (combined) and re-directed to a file<\/p>\r\n\r\n\r\n\r\n\r\n\r\n
      Operator syntax<\/span><\/th>\r\n\r\n
      Examples and explanation<\/p>\r\n<\/td>\r\n<\/tr>\r\n
      \r\n
      cmd > out_file 2>&1<\/span><\/pre>\r\n<\/td>\r\n
      		\r\n
      e.g.\r\ncat text1 junk text3 > both 2>&1<\/span><\/pre>\r\n
        \r\n \t
      • saves standard output and standard error to file both<\/span><\/li>\r\n \t
      • Explanation: Unix parses left to right. \u00a0First standard output is redirected to file \"both\". \u00a0Then the merge operator (>&) merges (blends) standard error (stream 2) with where standard output (stream 1) is already going (to file \"both\").<\/span><\/li>\r\n \t
      • Caution: How about\r\n
        cat text1 junk text3 > both 2> both<\/span><\/pre>\r\n<\/li>\r\n<\/ul>\r\n
          \r\n \t
        • This is an incorrect method of trying to merge two streams. \u00a0This causes a race condition (two streams competing for the same file) and correct results are not guaranteed.<\/span><\/li>\r\n<\/ul>\r\n<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n
          Redirecting standard input ( < operator)<\/span><\/h2>\r\n
          The user can redirect standard input from a file instead of the keyboard to any Unix command using the < operator. \u00a0Graphically, the concept is illustrated as follows.<\/span><\/p>\r\n\r\n\r\n[caption id=\"\" align=\"alignnone\" width=\"939\"]\"arrow Redirection of Standard Input from a file[\/caption]\r\n\r\n\r\n\r\n\r\n
          Operator syntax<\/span><\/th>\r\n\r\n
          Examples and explanation<\/p>\r\n<\/td>\r\n<\/tr>\r\n
          \r\n
          cmd < some_file<\/span><\/pre>\r\n<\/td>\r\n
          		\r\n
          cat < appendix<\/span><\/pre>\r\n
          While it may appear that the \"<\" in the above command does not seem to do anything (works the same without the \"<\"), the reason is that the cat command is smart and knows to look for input on the command line. \u00a0Unless a command is specifically designed to inspect the command line for input arguments, it is necessary to use the \"<\" for redirection of standard input. \u00a0<\/span><\/p>\r\n
          Consider a more basic example of a simple script requesting input from the keyboard. \u00a0To substitute a file, it would be necessary to issue the following command, where the file \"keystrokes\" contains what the user would have typed.<\/span><\/p>\r\n\r\n
          myscript < keystrokes<\/span><\/pre>\r\n
          Here \"myscript\" represents a user-written Unix script (program), not a Unix command.<\/span><\/p>\r\n<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n
          Pipes<\/span><\/h1>\r\n
          It is often the case that a problem in Unix is solved with multiple commands.\u00a0 Typically the output of the first command is saved in a file which is then used as input to a subsequent command. \u00a0The use of a pipe is considered a refinement of this approach potentially simplifying the solution.<\/span><\/p>\r\n\r\n
          Problem: To determine the number of entries in a directory<\/span><\/h2>\r\n
          Method 1<\/h3>\r\n\r\n\r\n\r\n\r\n\r\n
          \r\n
          Graphical view<\/span><\/p>\r\n<\/th>\r\n
          		\r\n
          code<\/span><\/p>\r\n<\/th>\r\n
          		\r\n
          explanation<\/span><\/p>\r\n<\/th>\r\n<\/tr>\r\n<\/thead>\r\n
          \r\n
          ls ->\r\nfile_list <\/span>\r\n-> wc<\/span><\/p>\r\n<\/td>\r\n
          		\r\n
          ls \/etc > file_list<\/span>\r\nwc -l file_list<\/span>\r\nrm file_list<\/pre>\r\n<\/td>\r\n
          		\r\n
            \r\n \t
          • save output of ls command in file_list<\/span><\/li>\r\n \t
          • run wc command to count lines<\/span><\/li>\r\n \t
          • delete temporary file file_list<\/span><\/li>\r\n<\/ul>\r\n<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n
            Method 2<\/h3>\r\n\r\n\r\n\r\n\r\n\r\n
            \r\n
            Graphical view<\/span><\/p>\r\n<\/th>\r\n
            		\r\n
            code<\/span><\/p>\r\n<\/th>\r\n
            		\r\n
            explanation<\/span><\/p>\r\n<\/th>\r\n<\/tr>\r\n<\/thead>\r\n
            \r\n
            ls ->\r\n\r\n\"\"\r\n<\/span>\r\n\u00a0-> wc <\/span>\r\n\r\n\u00a0<\/span><\/pre>\r\n<\/td>\r\n
            		\r\n
            ls \/etc | wc -l<\/span><\/pre>\r\n<\/td>\r\n
            		\r\n
              \r\n \t
            • save output of ls command is sent directly to input of wc command<\/span><\/li>\r\n \t
            • no temporary file needed<\/span><\/li>\r\n<\/ul>\r\n<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n
              \u00a0<\/span><\/p>\r\n\r\n
              \r\n
              Definition:<\/span><\/h2>\r\n
              A pipe connects STDOUT of previous command to STDIN of next command<\/span><\/p>\r\n\r\n<\/div>\r\n
              You can use a pipe multiple times creating a pipeline.<\/span><\/p>\r\n\r\n
              e.g.\r\ncmd1 | cmd2 | cmd3 | cmd4<\/span><\/pre>\r\n
              Building a pipeline should be an iterative process. Condense stepwise as you know the solutions work, otherwise there might be errors that might be difficult to detect from a single pipeline<\/span><\/p>\r\n
              Start out like this:<\/span><\/p>\r\n\r\n
              \r\ncmd1 > out1<\/span>\r\ncmd2 < out1 > out2\r\ncmd3 < out2<\/pre>\r\n...\r\n
              \u00a0<\/span><\/p>\r\n\r\n
              \r\n
              Key Takeaways<\/p>\r\n\r\n<\/header>\r\n
              \r\n
                \r\n \t
              1. \u00a0<\/span>Redirection<\/span>: Use between a command and a file<\/span><\/li>\r\n \t
              2. \u00a0Pipe: Use between commands<\/span><\/li>\r\n<\/ol>\r\n<\/div>\r\n<\/div>\r\n\r\n
                \r\n\r\n
                \u00a0<\/span>Making your script executable<\/span><\/h1>\r\n
                  \r\n \t
                1. create file containing unix commands<\/span><\/li>\r\n \t
                2. Once per file, type either:<\/span>\r\n
                    \r\n \t
                  • chmod u+x myscript<\/span><\/li>\r\n \t
                  • chmod 700 myscript<\/span><\/li>\r\n<\/ul>\r\n<\/li>\r\n \t
                  • To run, type .\/myscript<\/span><\/li>\r\n<\/ol>\r\n
                    \u00a0<\/span><\/p>\r\n ","rendered":"
                    By design most Unix commands are small and simple in their functionality. \u00a0To solve beyond the trivial requires the use of several steps or commands. \u00a0How to sequence and combine commands in Unix requires an understanding of how input and output is managed. \u00a0The next sections will introduce these concepts and show how more complex problems may be solved.<\/span><\/p>\n
                    Filters<\/span><\/h1>\n
                    One may think of a filter as a black box with an input and an output. Most Unix commands can be thought of as a filter. \u00a0The inputs and outputs have been given formal names. The input is named standard input <\/span>(STDIN); the output is named standard output <\/span>(STDOUT); and there is a secondary output named standard error <\/span>\u00a0(STDERR) which will be discussed in more detail later. \u00a0These inputs and outputs are associated with file descriptors or stream numbers 0, 1, and 2 respectively.<\/span><\/p>\n
                    By default, Unix commands read from standard input and print to standard output. \u00a0 Any error messages are sent to standard error.
                    \n
                    \n\"arrow
                    \n<\/span><\/p>\n
                    Examples of Unix commands as filters<\/span><\/h2>\n\n\n\n\n\n\n\n\n\n
                    Command<\/span><\/th>\n\n
                    Description<\/span><\/p>\n<\/th>\n<\/tr>\n
                    \n
                    cut<\/span><\/pre>\n<\/th>\n
                    		\n
                    reads from standard input and passes selected portions (columns, fields) to standard output<\/span><\/p>\n<\/th>\n<\/tr>\n
                    \n
                    grep<\/span><\/pre>\n<\/th>\n
                    		\n
                    reads from standard input and prints matching lines to standard output<\/span><\/p>\n<\/th>\n<\/tr>\n
                    \n
                    head & tail<\/span><\/pre>\n<\/th>\n
                    		\n
                    reads from standard input and prints the first (last) few lines to standard output<\/span><\/p>\n<\/th>\n<\/tr>\n
                    \n
                    cat <\/span><\/pre>\n<\/th>\n
                    		\n
                    a transparent filter: reads from standard input and prints the same to standard output<\/span><\/p>\n<\/th>\n<\/tr>\n
                    \n
                    wc<\/span><\/pre>\n<\/th>\n
                    		\n
                    reads from standard input and prints summary information to standard output<\/span><\/p>\n<\/th>\n<\/tr>\n
                    \n
                    ...<\/span><\/pre>\n<\/th>\n
                    		\n
                    not an exhaustive list<\/span><\/p>\n<\/th>\n<\/tr>\n<\/tbody>\n<\/table>\n
                    Redirection<\/span><\/h1>\n
                    When working interactively in a Unix session, the default setup is to have standard input draw from the keyboard, and standard output (as well as standard error) directed at the screen. \u00a0In other words, a command reading from standard input will wait for keystrokes. A command printing to standard output will have its output appear on the terminal screen.<\/span><\/p>\n
                    \"arrow
                    Default association of keyboard and screen to filter.<\/figcaption><\/figure>\n
                    While this arrangement works well, there will come situations where the user will want to save the output of a command to a file, or substitute a file for keyboard input. \u00a0This is accomplished through the concept of redirection where one of the inputs or outputs is associated with a file.<\/span><\/p>\n
                    Redirection of standard output ( > operator)<\/span><\/h2>\n
                    \u00a0<\/span>The user can save the standard output of any Unix command by redirecting standard output to a file using the > operator. \u00a0Graphically, the concept is illustrated as follows.<\/span><\/p>\n
                    \"arrow
                    Redirection of Standard Output<\/figcaption><\/figure>\n\n\n\n\n\n
                    Operator syntax<\/span><\/th>\n\n
                    Examples and explanation<\/p>\n<\/td>\n<\/tr>\n
                    \n
                    cmd > some_file<\/span><\/pre>\n<\/th>\n
                    		\n
                    e.g.<\/p>\n
                    cat chapter1 > book<\/span><\/pre>\n
                      \n
                    • \u00a0<\/span>if the file already exists it will overwrite it<\/span><\/li>\n<\/ul>\n<\/td>\n<\/tr>\n
                    \n
                    cmd >> some_file<\/span><\/pre>\n<\/th>\n
                    		\n
                    e.g.<\/p>\n
                    cat chapter3 >> book<\/span><\/pre>\n
                      \n
                    • the >> operator appends an existing file<\/span><\/li>\n<\/ul>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                      Redirecting standard error ( 2> operator)<\/span><\/h2>\n
                      The user can save the standard error of any Unix command by redirecting standard error to a file using the 2> operator. Graphically, the concept is illustrated as follows.<\/span><\/p>\n
                      \"arrow
                      Redirection of Standard Error<\/figcaption><\/figure>\n\n\n\n\n\n
                      Operator syntax<\/span><\/th>\n\n
                      Examples and explanation<\/p>\n<\/td>\n<\/tr>\n
                      \n
                      cmd 2> some_file<\/span><\/pre>\n<\/th>\n
                      		\n
                      e.g.\r\ncat chapter1 <\/span>chapter4 <\/span>2> errors<\/span><\/pre>\n
                      \u00a0<\/span><\/p>\n
                        \n
                      • saves error messages in file errors but standard output is displayed on the screen<\/li>\n<\/ul>\n<\/td>\n<\/tr>\n
                      \n
                      cmd > some_file 2> another_file<\/span><\/pre>\n<\/th>\n
                      		\n
                      e.g.\r\ncat chapter1 > book 2> errors<\/span><\/pre>\n
                      \u00a0<\/span><\/p>\n
                        \n
                      • saves standard output to file book, and saves standard error messages in file errors<\/span><\/li>\n<\/ul>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                        Merging two streams ( >& operator)<\/span><\/h2>\n
                        \u00a0<\/span>The user can save both standard output and standard error of any Unix command.\u00a0 This is accomplished by first redirecting standard error to a file, and then merging standard error with standard output.\u00a0 The syntax of the merge operator is m>&n where stream m is merged with wherever stream n is already going.\u00a0 \u00a0Graphically, the concept is illustrated as follows.\u00a0 Here stream 2 (standard error) is merged with stream 1 (standard output).<\/span><\/p>\n
                        \u00a0<\/span>\"arrow<\/p>\n
                        Standard Output and Standard Error are merged (combined) and re-directed to a file<\/p>\n\n\n\n\n
                        Operator syntax<\/span><\/th>\n\n
                        Examples and explanation<\/p>\n<\/td>\n<\/tr>\n
                        \n
                        cmd > out_file 2>&1<\/span><\/pre>\n<\/td>\n
                        		\n
                        e.g.\r\ncat text1 junk text3 > both 2>&1<\/span><\/pre>\n
                          \n
                        • saves standard output and standard error to file both<\/span><\/li>\n
                        • Explanation: Unix parses left to right. \u00a0First standard output is redirected to file “both”. \u00a0Then the merge operator (>&) merges (blends) standard error (stream 2) with where standard output (stream 1) is already going (to file “both”).<\/span><\/li>\n
                        • Caution: How about\n
                          cat text1 junk text3 > both 2> both<\/span><\/pre>\n<\/li>\n<\/ul>\n
                            \n
                          • This is an incorrect method of trying to merge two streams. \u00a0This causes a race condition (two streams competing for the same file) and correct results are not guaranteed.<\/span><\/li>\n<\/ul>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                            Redirecting standard input ( < operator)<\/span><\/h2>\n
                            The user can redirect standard input from a file instead of the keyboard to any Unix command using the < operator. \u00a0Graphically, the concept is illustrated as follows.<\/span><\/p>\n
                            \"arrow
                            Redirection of Standard Input from a file<\/figcaption><\/figure>\n\n\n\n\n
                            Operator syntax<\/span><\/th>\n\n
                            Examples and explanation<\/p>\n<\/td>\n<\/tr>\n
                            \n
                            cmd < some_file<\/span><\/pre>\n<\/td>\n
                            		\n
                            cat < appendix<\/span><\/pre>\n
                            While it may appear that the “<” in the above command does not seem to do anything (works the same without the “<“), the reason is that the cat command is smart and knows to look for input on the command line. \u00a0Unless a command is specifically designed to inspect the command line for input arguments, it is necessary to use the “<” for redirection of standard input. \u00a0<\/span><\/p>\n
                            Consider a more basic example of a simple script requesting input from the keyboard. \u00a0To substitute a file, it would be necessary to issue the following command, where the file “keystrokes” contains what the user would have typed.<\/span><\/p>\n
                            myscript < keystrokes<\/span><\/pre>\n
                            Here “myscript” represents a user-written Unix script (program), not a Unix command.<\/span><\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                            Pipes<\/span><\/h1>\n
                            It is often the case that a problem in Unix is solved with multiple commands.\u00a0 Typically the output of the first command is saved in a file which is then used as input to a subsequent command. \u00a0The use of a pipe is considered a refinement of this approach potentially simplifying the solution.<\/span><\/p>\n
                            Problem: To determine the number of entries in a directory<\/span><\/h2>\n
                            Method 1<\/h3>\n\n\n\n\n\n
                            \n
                            Graphical view<\/span><\/p>\n<\/th>\n
                            		\n
                            code<\/span><\/p>\n<\/th>\n
                            		\n
                            explanation<\/span><\/p>\n<\/th>\n<\/tr>\n<\/thead>\n
                            \n
                            ls ->
                            \nfile_list <\/span>
                            \n-> wc<\/span><\/p>\n<\/td>\n
                            		\n
                            ls \/etc > file_list<\/span>\r\nwc -l file_list<\/span>\r\nrm file_list<\/pre>\n<\/td>\n
                            		\n
                              \n
                            • save output of ls command in file_list<\/span><\/li>\n
                            • run wc command to count lines<\/span><\/li>\n
                            • delete temporary file file_list<\/span><\/li>\n<\/ul>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                              Method 2<\/h3>\n\n\n\n\n\n
                              \n
                              Graphical view<\/span><\/p>\n<\/th>\n
                              		\n
                              code<\/span><\/p>\n<\/th>\n
                              		\n
                              explanation<\/span><\/p>\n<\/th>\n<\/tr>\n<\/thead>\n
                              \n
                              ls ->\r\n\r\n\"\"\r\n<\/span>\r\n\u00a0-> wc <\/span>\r\n\r\n\u00a0<\/span><\/pre>\n<\/td>\n
                              		\n
                              ls \/etc | wc -l<\/span><\/pre>\n<\/td>\n
                              		\n
                                \n
                              • save output of ls command is sent directly to input of wc command<\/span><\/li>\n
                              • no temporary file needed<\/span><\/li>\n<\/ul>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                \u00a0<\/span><\/p>\n
                                \n
                                Definition:<\/span><\/h2>\n
                                A pipe connects STDOUT of previous command to STDIN of next command<\/span><\/p>\n<\/div>\n
                                You can use a pipe multiple times creating a pipeline.<\/span><\/p>\n
                                e.g.\r\ncmd1 | cmd2 | cmd3 | cmd4<\/span><\/pre>\n
                                Building a pipeline should be an iterative process. Condense stepwise as you know the solutions work, otherwise there might be errors that might be difficult to detect from a single pipeline<\/span><\/p>\n
                                Start out like this:<\/span><\/p>\n
                                \r\ncmd1 > out1<\/span>\r\ncmd2 < out1 > out2\r\ncmd3 < out2<\/pre>\n
                                …<\/p>\n
                                \u00a0<\/span><\/p>\n
                                \n
                                \n
                                Key Takeaways<\/p>\n<\/header>\n
                                \n
                                  \n
                                1. \u00a0<\/span>Redirection<\/span>: Use between a command and a file<\/span><\/li>\n
                                2. \u00a0Pipe: Use between commands<\/span><\/li>\n<\/ol>\n<\/div>\n<\/div>\n
                                  \n
                                  \u00a0<\/span>Making your script executable<\/span><\/h1>\n
                                    \n
                                  1. create file containing unix commands<\/span><\/li>\n
                                  2. Once per file, type either:<\/span>\n
                                      \n
                                    • chmod u+x myscript<\/span><\/li>\n
                                    • chmod 700 myscript<\/span><\/li>\n<\/ul>\n<\/li>\n
                                    • To run, type .\/myscript<\/span><\/li>\n<\/ol>\n
                                      \u00a0<\/span><\/p>\n
                                       <\/p>\n","protected":false},"author":2,"menu_order":3,"template":"","meta":{"pb_show_title":"on","pb_short_title":"","pb_subtitle":"","pb_authors":[],"pb_section_license":""},"chapter-type":[],"contributor":[],"license":[],"class_list":["post-34","chapter","type-chapter","status-publish","hentry"],"part":23,"_links":{"self":[{"href":"https:\/\/pressbooks.library.torontomu.ca\/opsyshiraki\/wp-json\/pressbooks\/v2\/chapters\/34","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/pressbooks.library.torontomu.ca\/opsyshiraki\/wp-json\/pressbooks\/v2\/chapters"}],"about":[{"href":"https:\/\/pressbooks.library.torontomu.ca\/opsyshiraki\/wp-json\/wp\/v2\/types\/chapter"}],"author":[{"embeddable":true,"href":"https:\/\/pressbooks.library.torontomu.ca\/opsyshiraki\/wp-json\/wp\/v2\/users\/2"}],"version-history":[{"count":20,"href":"https:\/\/pressbooks.library.torontomu.ca\/opsyshiraki\/wp-json\/pressbooks\/v2\/chapters\/34\/revisions"}],"predecessor-version":[{"id":104,"href":"https:\/\/pressbooks.library.torontomu.ca\/opsyshiraki\/wp-json\/pressbooks\/v2\/chapters\/34\/revisions\/104"}],"part":[{"href":"https:\/\/pressbooks.library.torontomu.ca\/opsyshiraki\/wp-json\/pressbooks\/v2\/parts\/23"}],"metadata":[{"href":"https:\/\/pressbooks.library.torontomu.ca\/opsyshiraki\/wp-json\/pressbooks\/v2\/chapters\/34\/metadata\/"}],"wp:attachment":[{"href":"https:\/\/pressbooks.library.torontomu.ca\/opsyshiraki\/wp-json\/wp\/v2\/media?parent=34"}],"wp:term":[{"taxonomy":"chapter-type","embeddable":true,"href":"https:\/\/pressbooks.library.torontomu.ca\/opsyshiraki\/wp-json\/pressbooks\/v2\/chapter-type?post=34"},{"taxonomy":"contributor","embeddable":true,"href":"https:\/\/pressbooks.library.torontomu.ca\/opsyshiraki\/wp-json\/wp\/v2\/contributor?post=34"},{"taxonomy":"license","embeddable":true,"href":"https:\/\/pressbooks.library.torontomu.ca\/opsyshiraki\/wp-json\/wp\/v2\/license?post=34"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}