Example 16-1. Redirecting with exec

#!/bin/bash # Redirect stdin using "exec". exec 6<&0 # Связать дескр. #6 со стандартным вводом (stdin). # Сохраняя stdin. exec < data-file # stdin заменяется файлом "data-file" read a1 # Читается первая строка из "data-file". read a2 # Читается вторая строка из "data-file." echo echo "Следующие строки были прочитаны из файла." echo "——————————————" echo $a1 echo $a2 echo; echo; echo exec 0<&6 6<&- # Восстанавливается stdin из дескр. #6, где он был предварительно сохранен, #+ и дескр. #6 закрывается (6<&-) освобождая его для других процессов. # # <&6 6<&- дает тот же результат. echo -n "Введите строку " read b1 # Теперь функция "read", как и следовало ожидать, принимает данные с обычного stdin. echo "Строка, принятая со stdin." echo "—————————" echo "b1 = $b1" echo exit 0

Likewise, the design exec >filename redirects output to the specified file. After this, all output from commands that would normally be directed to is now output to this file.

Example 16-2. Redirecting with exec

#!/bin/bash # reassign-stdout.sh LOGFILE=logfile.txt exec 6>&1 # Link desc. #6 with stdout. # Storing stdout. exec > $LOGFILE # stdout is replaced by the file "logfile.txt". # ———————————————————— # # All output from the commands in this block is written to the $LOGFILE file. echo -n "Logfile: " date echo "————————————-" echo echo "Output of \"ls -al\"" echo ls -al echo; echo echo "Output of the command \"df\"" echo df # ———————————————————— # exec 1>&6 6>&- # Restore stdout and close the file. #6. echo echo "== stdout restored to default == " echo ls -al echo exit 0

Example 16-3. Simultaneous redirection of devices, and, using the exec command

#!/bin/bash # upperconv.sh # Convert characters in the input file to uppercase. E_FILE_ACCESS=70 E_WRONG_ARGS=71 if [ ! -r "$1" ] # Is the file readable? then echo "Unable to read due to of this file!" echo "Usage: $0 input-file output-file" exit $E_FILE_ACCESS fi # In case the input file ($1) is not specified #+ the exit code will be the same. if [ -z "$2" ] then echo " An output file must be specified." echo "Usage: $0 input-file output-file" exit $E_WRONG_ARGS fi exec 4<&0 exec < $1 # Назначить ввод из входного файла. exec 7>&1 exec > $2 # Assign output to an output file. # Assuming the output file is writable # (add check?). # ———————————————— cat — | tr a-z A-Z # Convert to uppercase # ^^^^^ # Read from stdin. # ^^^^^^^^^^ # Write to stdout. # However, both stdin and stdout were redirected. # ———————————————— exec 1>&7 7>&- # Restore stdout. exec 0<&4 4<&- # Восстановить stdin. # После восстановления, следующая строка выводится на stdout, чего и следовало ожидать. echo "Символы из \"$1\" преобразованы в верхний регистр, результат записан в \"$2\"." exit 0

Next: Redirecting errors to a file Up: I/O redirection Previous: Redirecting input from a file Contents Index

Redirecting output to a file

To redirect standard output to a file, use the `>' operator.

I/O redirection in Linux

Follow the command name with the > operator, followed by the name of the file that will serve as the destination for the output. For example, to write the output of a program to a file, enter:

If you redirect standard output to an already existing file, it will be overwritten from the beginning. To append standard output to the contents of an existing file, you must use the `"' operator. For example, to add the results of the work when running the program again to a file, enter:

Alex Otwagin 2002-12-16

A program is usually valuable because it can process data: accept one thing, produce another as output, and almost anything can act as data: text, numbers, sound, video... The input and output data streams for a command are called input And conclusion. Each program can have several input and output streams. In each process, when created in mandatory receives so-called standard input(standard input, stdin) and standard output(standard output, stdout) and standard error output(standard error, stderr).

Standard input/output streams are intended primarily for exchanging text information. It doesn’t even matter who communicates via texts: a person with a program or programs between themselves - the main thing is that they have a data transmission channel and that they speak “the same language.”

The textual principle of working with the machine allows you to escape from specific parts of the computer, such as system keyboard and video cards with a monitor, considering a single terminal device, through which the user enters text (commands) and transmits it to the system, and the system outputs necessary for the user data and messages (diagnostics and errors). Such a device is called terminal. IN general case terminal is the user's entry point into the system and has the ability to transmit text information. The terminal can be a separate external device, connected to a computer via a serial data port (in personal computer it is called "COM port"). A program (for example, xterm or ssh) can also work as a terminal (with some support from the system). Finally, virtual consoles- also terminals, only organized programmatically using suitable devices modern computer.

When working at the command line, the shell's standard input is associated with the keyboard, and standard output and error output are associated with the monitor screen (or terminal emulator window). Let's show with an example the simplest command-cat. Usually the team cat reads data from all files that are specified as its parameters and sends the read directly to standard output (stdout). Therefore the command

/home/larry/papers# cat history-final masters-thesis

will display the contents of the file first, and then the file.

However, if the file name is not specified, the program cat reads input from stdin and immediately returns it to stdout (without modifying it in any way). Data passes through cat like through a pipe. Let's give an example:

/home/larry/papers# cat Hello there. Hello there. Bye. Bye. Ctrl—D/home/larry/papers#

Every line entered from the keyboard is immediately returned to the screen by the cat program. When entering information from standard input, the end of the text is signaled by entering special combination keys, usually Ctrl—D.

Let's give another example. Team sort reads lines of input text (also from stdin if no file name is specified) and outputs a set of these lines in an ordered form on stdout. Let's check its action.

/home/larry/papers# sort bananas carrots apples Ctrl+D apples bananas carrots /home/larry/papers#

As you can see, after pressing Ctrl—D, sort output the lines ordered in alphabetical order.

Standard input and standard output

Let's say you want to route output sort commands to some file to save the alphabetically ordered list on disk. The command shell allows you to redirect the standard output of a command to a file using a symbol. Let's give an example:

/home/larry/papers# sort > shopping-list bananas carrots apples Ctrl—D/home/larry/papers#

You can see that the output of the sort command is not printed on the screen, but it is saved in a file named. Let's display the contents of this file:

/home/larry/papers# cat shopping-list apples bananas carrots /home/larry/papers#

Now let the original unordered list be in a file. This list can be sorted using the command sort, by telling it that it should read from a given file rather than from its standard input, and in addition redirecting the standard output to a file, as was done above. Example:

/home/larry/papers# sort items shopping-list /home/larry/papers# cat shopping-list apples bananas carrots /home/larry/papers#

However, you can do it differently by redirecting not only the standard output, but also standard input utilities from the file using the symbol:

/home/larry/papers# sort< items apples bananas carrots /home/larry/papers#

Command result sort< items equivalent to the command sort items, however the first one demonstrates the following: when issuing the command sort< items the system behaves as if the data contained in the file had been entered from standard input. Redirection is done by the command shell. Team sort the file name was not reported: this command read data from its standard input as if we had entered it from the keyboard.

Let's introduce the concept filter. A filter is a program that reads data from standard input, processes it in some way, and sends the result to standard output. When redirection is applied, files can be used as standard input and output. As stated above, by default, stdin and stdout refer to the keyboard and screen, respectively. The sort program is a simple filter - it sorts the input data and sends the result to standard output. A very simple filter is the program cat- it does nothing with the input data, but simply sends it to the output.

We've already demonstrated how to use the sort program as a filter above. These examples assumed that the source data was in some file or that the source data would be entered from the keyboard (standard input). However, what if you want to sort data that is the result of some other command, for example, ls?

We will sort the data in reverse alphabetical order; this is done by the command option sort. If you wanted to list the files in the current directory in reverse alphabetical order, one way to do it would be like this.

I/O redirection

Let's first use the command ls:

/home/larry/papers# ls english-list history-final masters-thesis notes /home/larry/papers#

Now we redirect the command output ls to a file named file-list

/home/larry/papers# ls > file-list /home/larry/papers# sort -r file-list notes masters-thesis history-final english-list /home/larry/papers#

Here is the command output ls saved in a file, and after that this file was processed by the command sort. However, this path is inelegant and requires the use temporary file to store program output ls.

A solution to this situation could be to create docked commands(pipelines). The docking is carried out by the command shell, which directs the stdout of the first command to the stdin of the second command. In this case we want to send commands to stdout ls to stdin commands sort. A symbol is used for docking, as shown in the following example:

/home/larry/papers# ls | sort -r notes masters-thesis history-final english-list /home/larry/papers#

This command is shorter than a collection of commands and is easier to type.

Let's consider another useful example. Team

/home/larry/papers# ls /usr/bin

returns a long list of files. Most of this list flies across the screen too quickly for the contents of this list to be read. Let's try to use the more command to display this list in parts:

/home/larry/papers# ls /usr/bin | more

Now you can “turn through” this list.

You can go further and dock more than two teams. Consider the team head, which is a filter with the following property: it outputs the first lines from the input stream (in our case, the input will be the output from several concatenated commands). If we want to display the last alphabetical file name in the current directory, we can use the following long command:

/home/larry/papers# ls | sort -r | head -1 notes /home/larry/papers\#

where is the team head displays the first line of the input stream of lines it receives (in our case, the stream consists of data from the command ls), sorted in reverse alphabetical order.

Using stacked commands (pipeline)

The effect of using a symbol to redirect file output is destructive; in other words, the team

/home/larry/papers# ls > file-list

will destroy the contents of the file if the file previously existed and create a new file in its place.

If the redirection is done using symbols instead, the output will be appended to the end of the specified file without destroying the original contents of the file. For example, the command

/home/larry/papers# ls >> file-list

attributes the output of the command ls to the end of the file.

Please note that input and output redirection and command splicing are performed command shells, which support the use of symbols, and. The teams themselves are not able to perceive and interpret these symbols.

Non-destructive output redirection

Something like this should do what you need?

Check it out: wintee

No need for cygwin.

However, I have encountered and reported some issues.

Also you might want to check out http://unxutils.sourceforge.net/ because it contains tee (and doesn't need cygwin), but be careful that EOL output is UNIX-like.

Last but not least, if you have PowerShell, you can try Tee-Object. Type in PowerShell console for more information.

This works, although it's a little ugly:

It's a little more flexible than some other solutions in that it works in its own way so you can use it to add.

I use this quite a lot in batch files to log and display messages:

Yes, you could simply repeat the ECHO statement (once for the screen and a second time redirecting to the log file), but that looks just as bad and is a maintenance issue.

Redirecting input and output

At least this way you don't have to make changes to messages in two places.

Note that _ is just short name file, so you will need to remove it at the end of your batch file (if you are using batch file).

This will create a log file with current time and time, and you can use console lines during the process

If you have cygwin in your path Windows environment, you can use:

Simple console application C# would do the trick:

To use this, you simply pass the source command to the program and specify the path to any files for which you want to duplicate the output. For example:

Will display search results and also save the results in files1.txt and files2.txt.

Note that there is not much in the way of error handling (nothing!) and support for multiple files may not be necessary.

I was also looking for the same solution, after a little try I was able to successfully do this on the command line. Here's my solution:

It even hijacks any PAUSE command.

An alternative is to tee stdout to stderr in your program:

Then in your dos batchfile:

Stdout will go to the log file and stderr (same data) will be shown on the console.

How to display and redirect output to a file. Suppose if I use dos command, dir> test.txt, this command redirects the output to the test.txt file without displaying the results. how to write a command to print the output and redirect the output to a file with using DOS, i.e. command Windows strings, not UNIX/LINUX.

You may find these commands in biterscripting (http://www.biterscripting.com) useful.

This is a variation of MTS's previous answer, however it adds some features that may be useful to others. Here is the method I used:

• The command is set as a variable that can be used later in the code to be output to the command window and added to the log file using
  • the command avoids redirection using the carrot symbol so that commands are not evaluated initially
• A temporary file is created with a file name similar to a batch file with a name that uses the parameter extension syntax command line to get the name of the batch file.
• The result is added to a separate log file

Here is the sequence of commands:

1. Output and error messages are sent to a temporary file
2. The contents of the temporary file are then:
   • added to log file
   • output to command window
3. The temporary file with the message is deleted

Here's an example:

This way the command can simply be added after later commands in a batch file, which looks much cleaner:

This can be added at the end of other commands as well. As far as I can tell this will work when messages have multiple lines. For example, next command prints two lines if there is an error message:

I agree with Brian Rasmussen, the unxutils port is the easiest way to do this. In the Batch Files section of his Scripting pages, Rob van der Woude provides a wealth of information about using MS-DOS and CMD commands. I thought he might have own solution your problem, and after I did some digging around in TEE.BAT, I found TEE.BAT, which seems to be just that, a batch language pack MS-DOS. This is a fairly complex batch file and I would be inclined to use the unxutils port.

I install perl on most of my machines, so the answer is using perl: tee.pl

dir | perl tee.pl or catalog | perl tee.pl dir.bat

raw and untested.

One of the most interesting and useful topics for system administrators and new users who are just starting to understand how to work with the terminal - this is redirection of Linux input/output streams. This terminal feature allows you to redirect the output of commands to a file, or the contents of a file to command input, to combine commands together, and to form command pipelines.

In this article, we will look at how I/O stream redirection is performed in Linux, what operators are used for this, and where all this can be used.

All the commands we execute return us three types of data:

• The result of the command, usually text data requested by the user;
• Error messages - inform about the process of command execution and unexpected circumstances that have arisen;
• The return code is a number that allows you to evaluate whether the program worked correctly.

In Linux, all substances are considered files, including input streams linux output- files. Each distribution has three main stream files that programs can use, these are defined by the shell and identified by their file descriptor number:

• STDIN or 0- this file is associated with the keyboard and most commands receive data to work from here;
• STDOUT or 1- this is the standard output; the program sends all the results of its work here. It is associated with the screen, or to be more precise, with the terminal in which the program is running;
• STDERR or 2- all error messages are output to this file.

I/O redirection allows you to replace one of these files with your own. For example, you can have a program read data from a file in file system, rather than the keyboard, you can also output errors to a file rather than to the screen, etc. All this is done using symbols "<" And ">" .

Redirect output to file

Everything is very simple. You can redirect output to a file using the > symbol. For example, let's save the output of the top command:

top -bn 5 > top.log

The -b option causes the program to run in non-interactive batch mode, and n - repeats the operation five times to obtain information about all processes. Now let's see what happened with cat:

Symbol ">" overwrites information from a file if there is already something there. To append data to the end use ">>" . For example, redirect output to linux file also for top:

top -bn 5 >> top.log

By default, the standard output file descriptor is used for redirection. But you can specify this explicitly. This command will give the same result:

top -bn 5 1>top.log

Redirect errors to file

To redirect error output to a file, you need to explicitly specify the file descriptor you are going to redirect. For errors, this is number 2. For example, when trying to gain access to the superuser directory, ls will throw an error:

You can redirect standard error to a file like this:

ls -l /root/ 2> ls-error.log
$ cat ls-error.log

To append data to the end of the file, use the same symbol:

ls -l /root/ 2>>ls-error.log

Redirect standard output and errors to file

You can also redirect all output, errors, and standard output to a single file. There are two ways to do this. The first, older one, is to pass both handles:

ls -l /root/ >ls-error.log 2>&1

First, the output of the ls command will be sent to the ls-error.log file using the first redirection character. Then all errors will be sent to the same file. The second method is simpler:

ls -l /root/ &> ls-error.log

You can also use appending instead of rewriting:

ls -l /root/ &>> ls-error.log

Standard input from file

Most programs, except services, receive data for their work through standard input. By default, standard input expects input from the keyboard. But you can force the program to read data from a file using the operator "<" :

cat

You can also immediately redirect the output to a file too. For example, let's re-sort the list:

sort sort.output

Thus, we redirect input/output to linux in one command.

Use of tunnels

You can work not only with files, but also redirect the output of one command as the input of another. This is very useful for performing complex operations. For example, let's display five recently modified files:

ls -lt | head -n 5

With the xargs utility, you can combine commands so that standard input is passed as parameters. For example, let's copy one file to several folders:

echo test/tmp/ | xargs -n 1 cp -v testfile.sh

Here the -n 1 option specifies that only one parameter should be supplied per command, and the -v option to cp allows detailed information about movements to be printed. Another useful command in such cases is tee. It reads data from standard input and writes to standard output or files. For example:

echo "Tee operation test" | tee file1

In combination with other commands, these can be used to create complex multi-command instructions.

conclusions

In this article, we covered the basics of Linux I/O stream redirection. Now you know how to redirect output to a linux file or output from a file. It's very simple and convenient. If you have any questions, ask in the comments!

Linux's built-in redirection capabilities provide you with a wide range of simplified tools for all kinds of tasks. The ability to manage various I/O streams will significantly increase productivity, both when developing complex software and when managing files using the command line.

I/O threads

Input and output in a Linux environment is distributed among three threads:

• Standard input (standard input, stdin, thread number 0)
• Standard output (stdout, number 1)
• Standard error, or diagnostic stream (standard error, stderr, number 2)

When a user interacts with a terminal, standard input is transmitted through the user's keyboard. The standard output and standard error are displayed as text on the user's terminal. All these three streams are called standard streams.

Standard input

The standard input stream typically passes data from the user to the program. Programs that expect standard input typically receive input from a device (such as a keyboard). Standard input stops when it reaches EOF (end-of-file). EOF indicates that there is no more data to read.

To see how standard input works, run the cat program. The name of this tool means “concatenate” (to connect or combine something). Typically this tool is used to combine the contents of two files. When run without arguments, cat opens a command prompt and accepts the contents of standard input.

Now enter some numbers:

1
2
3
ctrl-d

By entering a number and pressing enter, you send standard input to the running cat program, which accepts the data. In turn, the cat program displays the received input on standard output.

The user can set EOF by pressing ctrl-d, which will cause the cat program to stop.

Standard output

Standard output records the data generated by the program. If standard output has not been redirected, it will output text to the terminal. Try running the following command as an example:

echo Sent to the terminal through standard output

The echo command, without any additional options, displays on the screen all the arguments passed to it on the command line.

Now run echo without any arguments:

The command will return an empty string.

Standard error

This standard stream records errors generated by a program that has crashed. Like standard output, this stream sends data to the terminal.

Let's look at an example of an ls command error stream. The ls command displays the contents of directories.

Without arguments, this command returns the contents of the current directory. If you specify a directory name as an argument to ls, the command will return its contents.

Since directory % does not exist, the command will return the standard error:

ls: cannot access %: No such file or directory

Stream redirection

Linux provides special commands to redirect each thread. These commands write standard output to a file. If the output is redirected to a non-existent file, the command will create a new file with that name and save the redirected output to it.

Commands with one angle bracket overwrite the existing content of the target file:

• > - standard output
• < — стандартный ввод
• 2> - standard error

Commands with double angle brackets do not overwrite the contents of the target file:

• >> - standard output
• << — стандартный ввод
• 2>> - standard error

Consider the following example:

cat > write_to_me.txt
a
b
c
ctrl-d

This example uses the cat command to write the output to a file.

Review the contents of write_to_me.txt:

cat write_to_me.txt

The command should return:

Redirect cat to write_to_me.txt again and enter three numbers.

cat > write_to_me.txt
1
2
3
ctrl-d

Now check the contents of the file.

cat write_to_me.txt

The command should return:

As you can see, the file only contains the latest output because the command that redirected the output used a single angle bracket.

Now try running the same command with two angle brackets:

cat >> write_to_me.txt
a
b
c
ctrl-d

Open write_to_me.txt:

1
2
3
a
b
c

Commands with double angle brackets do not overwrite existing content, but rather append to it.

Conveyors

Pipes redirect the output of one command to the input of another. In this case, the data transferred to the second program is not displayed in the terminal. The data will appear on the screen only after processing by the second program.

Pipelines in Linux are represented by a vertical bar.

For example:

This command will pass the output of ls (the contents of the current directory) to less, which will display the data passed to it line by line. Typically, ls displays the contents of directories consecutively, without breaking them into lines. If you redirect ls output to less, the latter command will split the output into lines.

As you can see, a pipeline can redirect the output of one command to the input of another, unlike > and >>, which only redirect data to files.

Filters

Filters are commands that can change the redirection and output of a pipeline.

Note: Filters are also standard Linux commands that can be used without a pipeline.

• find – searches for a file by name.
• grep – searches for text using a given pattern.
• tee – redirects standard input to standard output and one or more files.
• tr – search and replace strings.
• wc – counting characters, lines and words.

Examples of I/O redirection

Now that you are familiar with the basic concepts and mechanisms of redirection, let's look at some basic examples of their use.

command > file

This pattern redirects the command's standard output to a file.

ls ~> root_dir_contents.txt

This command passes the contents of the system's root directory as standard output and writes the output to the file root_dir_contents. This will delete all previous content in the file since the command uses a single angle bracket.

command > /dev/null

/dev/null is a special file (called a "null device") that is used to suppress standard output or diagnostics to avoid unwanted console output. All data that ends up in /dev/null is discarded. Redirection to /dev/null is commonly used in shell scripts.

ls > /dev/null

This command resets the standard output returned by ls to /dev/null.

command 2 > file

This pattern redirects the command's standard error stream to a file, overwriting its current contents.

mkdir "" 2> mkdir_log.txt

This command will redirect the error caused by an invalid directory name and write it to log.txt. Please note: the error still appears in the terminal.

command >> file

This pattern redirects the standard output of a command to a file without overwriting the current contents of the file.

echo Written to a new file > data.txt
echo Appended to an existing file"s contents >> data.txt

This pair of commands first redirects user input to a new file and then pastes it into an existing file without overwriting its contents.

command 2>>file

This pattern redirects the command's standard error stream to a file without overwriting the file's existing contents. It is suitable for creating program or service error logs, since the log contents will not be constantly updated.

find "" 2> stderr_log.txt
wc "" 2>> stderr_log.txt

The above command redirects the error message caused by the invalid find argument to the stderr_log.txt file and then appends the error message caused by the invalid wc argument to the stderr_log.txt file.

team | team

This template redirects the standard output of the first command to standard input second team.

find /var lib | grep deb

This command searches the /var directory and its subdirectories for file names and deb extensions and returns the file paths, highlighting the search pattern in red.

team | tee file

This pattern redirects the command's standard output to a file and overwrites its contents, then displays the redirected output in the terminal. If the specified file does not exist, it creates a new file.

IN this template The tee command is typically used to view the output of a program and save it to a file at the same time.

wc /etc/magic | tee magic_count.txt

This command passes the number of characters, lines and words in magic file(Linux uses this to determine file types) to the tee command, which sends this data to the terminal and to the magic_count.txt file.

team | team | command >> file

This template redirects the standard output of the first command and filters it through the next two commands, then appends the final result to a file.

ls ~ | grep *tar | tr e E >> ls_log.txt

This command sends the output of ls for the root directory to grep. In turn, grep searches the received data tar files. After this, the result of grep is passed to the tr command, which will replace all e characters with the character E. The resulting result will be added to the file ls_log.txt (if such a file does not exist, the command will create it automatically).

Conclusion

Linux I/O redirection functions seem overly complex at first. However, working with redirection is one of the most important skills of a system administrator.

To find out more about a particular command, use:

man command | less

For example:

This command will return full list commands for tee.

Learning Linux, 101

Streams, program channels and redirects

Learning the Basics of Linux Pipelines

Content Series:

Short review

In this article, you will learn the basic techniques for redirecting standard I/O streams in Linux. You will learn:

• Redirect standard input/output streams: standard input, standard output, and standard error.
• Direct the output of one command to the input of another command.
• Send output simultaneously to standard device output (stdout) and to a file.
• Use the output of a command as arguments to another command.

This article will help you prepare to take the LPI 101 Administrator exam entry level(LPIC-1) and contains materials from Objective 103.4 of Topic 103. The Objective has a weight of 4.

About this series

This series of articles will help you master administration tasks operating system Linux. You can also use the material in these articles to prepare for.

To view descriptions of articles in this series and get links to them, please refer to our. This list is continually updated with new articles as they become available and contains the most current (as of April 2009) LPIC-1 certification exam objectives. If any article is missing from the list, you can find it more earlier version, consistent with previous LPIC-1 goals (prior to April 2009), by referring to our .

The necessary conditions

To extract greatest benefit from our articles, you need to have basic knowledge of Linux and have a working Linux computer on which you can execute all the commands you encounter. Sometimes different versions Programs produce results differently, so the contents of the listings and figures may differ from what you see on your computer.

Preparing to Run the Examples

How to contact Ian

Ian is one of our most popular and prolific authors. Check out (EN) published on developerWorks. You can find contact information at and connect with him and other My developerWorks contributors and contributors.

To run the examples in this article, we will use some of the files created earlier in the " " article. If you haven't read this article or saved these files, don't worry! Let's start by creating a new directory lpi103-4 and all necessary files. To do this, open a text window and navigate to your home directory. Copy the contents of Listing 1 into the text box; as a result of executing commands in your home directory The lpi103-4 subdirectory will be created and all the necessary files in it, which we will use in our examples.

Listing 1. Creating the files needed for this article's examples

Your window should look like Listing 2, and your current working directory should be the newly created lpi103-4 directory.

Listing 2. Results of creating the necessary files

Redirecting standard input/output

A Linux shell, such as Bash, receives input and sends output in the form of sequences or streams characters. Any character is independent of either previous or subsequent characters. Symbols are not organized into structured entries or fixed-size blocks. Streams are accessed using I/O mechanisms regardless of where the character streams come from or are sent to (a file, keyboard, window, screen, or other I/O device). Command interpreters Linux uses three standard I/O streams, each of which is assigned a specific file descriptor.

1. stdout – standard output, displays command output and has handle 1.
2. stderr – standard error stream, displays command errors and has descriptor 2.
3. stdin – standard input, passes input to commands and has handle 0.

Input streams provide input (usually from the keyboard) to commands. Output streams provide printing text characters, usually to the terminal. The terminal was originally an ASCII printing device or display terminal, but now it is usually just a window on the computer desktop.

If you have already read the "" guide, then some of the material in this article will be familiar to you.

Output redirection

There are two ways to redirect output to a file:

Symbol n in operators n> or n>> is file descriptor. If it is not specified, the standard output device is assumed to be used. Listing 3 demonstrates the redirection operation to separate the standard output and standard error of the ls command, using files that were created earlier in the lpi103-4 directory. Adding command output to existing files is also demonstrated.

Listing 3. Output redirection

We've already said that redirecting output using the n> operator usually results in overwriting existing files. You can control this property using the noclobber option of the set built-in command. If this option is defined, you can override it using the n>| operator, as shown in Listing 4.

Listing 4. Redirecting output using the noclobber option

Sometimes you may want to redirect both standard output and standard error to a file. This is often used in automated processes or background jobs so that you can view the results of your work later. To redirect standard output and standard error to the same location, use the &> or &>> operator. Alternative option– redirect file descriptor n and then the file descriptor m to the same place using the construction m>&n or m>>&n. In this case, the order in which the threads are redirected is important. For example, the command
command 2>&1 >output.txt
it's not the same as a command
command >output.txt 2>&1
In the first case, the error stream stderr is redirected to the current location of the stdout stream, and then the stdout stream is redirected to the output.txt file; however, the second redirection only affects stdout and not stderr. In the second case, the stderr stream is redirected to the current location of the stdout stream, that is, to the output.txt file. These redirections are illustrated in Listing 5. Notice in the last command that the standard output was redirected after the standard error stream, and as a result, the error stream continues to be output to the terminal window.

Listing 5. Redirecting two streams to one file

In other situations, you may want to ignore standard output or standard error entirely. To do this, redirect the corresponding thread to empty file/dev/null. Listing 6 shows how to ignore the ls command error stream and how to use cat commands make sure that the /dev/null file is actually empty.

Listing 6. Ignoring standard error by using /dev/null

Input redirection

Just like we can redirect stdout and stderr, we can redirect stdin from a file using the operator<. Если вы прочли руководство " ", то должны помнить, что в разделе была использована команда tr для замены пробелов в файле text1 на символы табуляции. В том примере мы использовали вывод команды cat чтобы создать стандартный поток ввода для команды tr . Теперь для преобразования пробелов в символы табуляции вместо бесполезного вызова команды cat мы можем использовать перенаправление ввода, как показано в листинге 7.

Listing 7. Input redirection