Home PC Games Linux Windows Database Network Programming Server Mobile  
           
  Home \ Linux \ Linux input and output redirection     - Git common skills (Linux)

- Manually generate AWR reports (Database)

- Use Observium to monitor your network and servers (Server)

- CentOS7 boot systemd introduction and use of management (Linux)

- Ruby and Python simple comparison (Programming)

- Install the Red Hat Container Development Kit on OSX (Server)

- Ubuntu users to install Xtreme Download Manager (Linux)

- C ++ Fundamentals study notes (Programming)

- Cancel Root Command History under Linux (Linux)

- Oracle 11g RAC manually playing GI PSU patch (11.2.0.4.8) (Database)

- Different versions of MongoDB achieve master-slave replication (Database)

- Github Getting Started Basic Course (Linux)

- Eclipse configuration GTK (Linux)

- PL / SQL how to make the program every few seconds to insert a data (Database)

- MySQL optimization of the relevant Group By (Database)

- Shell script on the variables with double quotation marks grep small problem (Programming)

- Bubble Sort Algorithms (Programming)

- Ubuntu install Avast antivirus software (Programming)

- Use mdadm tool to create software RAID 0 (Linux)

- Using Vagrant create cross-platform development environment (Linux)

 
         
  Linux input and output redirection
     
  Add Date : 2017-08-31      
         
         
         
  Linux Redirection is to modify some of the original default, the original system commands to change the default implementation, such as simple I do not want to see the output of the display but want to output to a file can be redirected through Linux To carry out this work.

Linux default input is the keyboard, the output is the display. You can use redirection to change these settings. For example, when using the wc command was to manually enter a text to calculate the number of characters, with a redirect can be directly after a written file with the '< ' point to this command, you can directly statistics on this file Characters and so on. Output is the same, you can redirect the output of the screen to a file, and then to the file to see the results. Redirection operator can be used to command input and output data stream from the default location to redirect to other locations, the location of the input or output data stream is called the handle; common handle there are three, of course, the handle can be extended, the general OS Provide similar functionality. Handle Handle Code handle Description

STDIN 0 Keyboard input

STDOUT 1 Outputs information to the prompt window

STDERR 2 Outputs an error message to the prompt window

The default < redirection input operator is 0, and the default> redirection output operator is 1. After you type the < or> operator, you must specify the location of the data to read or write, either a file name or another existing handle.

To specify redirection to an existing handle, use the & handle, followed by the & handle (which is the & handle number) to be redirected.

For example, the following command redirects handle 2 (that is, STDERR) to handle 1 (that is, STDOUT): 2> & 1

The following table lists the operators available for redirecting input and output data streams:

Linux redirection operator function description

> Write command output to a file or device, not a command prompt or handle

Read the command input from a file rather than from a keyboard or handle

>> Add the command output to the end of the file without deleting the information already in the file

> & Writes the output of one handle to the input of another handle

< & Reads an input from one handle and writes it to another handle output

| Read the output from a command and write it to the input of another command; also known as the pipe operator

Now we look back at the above phrase mysh> mylog.txt 2> & 1 can understand:

> Mylog.txt means that the standard output is redirected to mylog.txt, which is equivalent to mysh 1> mylog.txt;

2> & 1 means that the error output will be redirected to the standard output of a handle; Mysh command together is generated during the implementation of the standard output and error output will be redirected to mylog.txt;

Redirection function is very powerful, interested can go to try a variety of different combinations, look at the position before and after the change will have what results?

At some point we may not want to record what the standard output or error output, it can be used mysh> null 2> null or mysh> / dev / null 2> / dev / null;

Detailed I / O redirection

1, the basic concept (which is behind the understanding of the premise of knowledge, be sure to understand)

A, I / O redirection is usually related to FD, shell FD is usually 10, that is, 0 ~ 9;

B, commonly used FD 3, 0 (stdin, standard input), 1 (stdout, standard output), 2 (stderr, standard error output), default and keyboard, monitor, monitor;

C, use the < to change the read data channel (stdin), so that read from the specified file;

D, with the> to change the sent data channel (stdout, stderr), so that output to the specified file;

E, 0 is the default value of < , so < and 0 < are the same; Similarly,> and 1> is the same;

F, in the IO redirect, stdout and stderr pipeline will be ready before reading from the stdin data;

G, pipe "|" (pipe line): stdout on a command received the next command stdin;

H, tee command is not affect the original I / O, the stdout copy to a file to;

I, bash (ksh) The process of executing the command: Analysis command - Variable evaluation - Command substitution ( `` and $ ()) - Redirection - Wildcard expansion - Determine path - Execute command;

J, () will command group placed in the sub-shell to perform, also known as nested sub-shell, it is a very important feature is: inherit the parent shell's Standard input, output, and error plus any other open file descriptors.

K, exec command: commonly used to replace the current shell and restart a shell, in other words, there is no promoter sub-shell. Any existing environment will be cleared when using this command. Exec in the operation of the document descriptors, and only then, exec will not cover your current shell environment.

2, the basic IO

Cmd> file Redirect stdout to the file file;

Cmd >> file Redirect stdout to the file file (append);

Cmd 1> fiel to stdout redirect to the file file;

Cmd> file 2> & 1 stdout and stderr together to redirect to the file file;

Cmd 2> file to stderr redirect to the file file;

Cmd 2 >> file Redirect stderr to the file (append);

Cmd >> file 2> & 1 Redirect stderr and stderr to the file file (append);

Cmd < file> file2 cmd command to file the file as stdin to file2 file as stdout;

Cat < > file to read and write the way to open file;

Cmd < file cmd command to file file as stdin;

Cmd < < delimiter Here document, read from stdin until delimiter delimiters are encountered.

3, advanced IO

> & N uses the system call dup (2) to copy the file descriptor n and uses the result as standard output;

< & N Standard input copy from file descriptor n;

< & - Turns off standard input (keyboard);

> & - off the standard output;

N < & - that will be No. n input is turned off;

N> & - indicates that the output of No. n is turned off;

All of the above forms can be preceded by a number, the establishment of the document descriptors at this time designated by the figures instead of the default 0 or 1. Such as:

... 2> file Runs a command and directs the error output (file descriptor 2) to file.

... 2> & 1 Runs a command and combines its standard output and output. (Strictly speaking, file descriptor 2 is created by copying file descriptor 1, but the effect is usually to merge two streams.)

FD2 = FD1, FD2 does not mean that the value is equal to the value of FD1, because> is to change the data sent out of the channel, that is to say FD2 "data output channel", that is to say, To "data output channel" of FD1. If so, this change seems to have no effect, because FD2 default output and FD1 default output would have been monitor, the same! However, when FD1 is other files, or even other FD, this has a special purpose. Please be sure to understand this point.

Exec 0exec 1> outfilename # Open the file outfilename as stdout.

Exec 2> errfilename # Open the file errfilename as stderr.

Exec 0 < & - # Turn off FD0.

Exec 1> & - # to close FD1.

Exec 5> & - # Turn off FD5.

1 COMMAND_OUTPUT>
  2 # redirect stdout to a file.
  3 # If there is no document on the creation, or to cover.
  4
  5 ls -lR> dir-tree.list
  6 # Create a file that contains a list of directory trees.
  7
  8:> filename
  9 #> truncates the file "filename" to zero length.
  10 # If the file does not exist, then create a 0-length file (the same as 'touch').
  11 #: is a placeholder that does not produce any output.
  12
  13> filename
  14 #> will truncate the file "filename" to zero length.
  15 # If the file does not exist, then create a 0-length file (the same as 'touch').
  16 # (same as ":>" above, but may not work under some shells.)
  17
  18 COMMAND_OUTPUT >>
  19 # redirect stdout to a file.
  20 # If the file does not exist, then create it, if there is, then append to the file behind.
  twenty one
  twenty two
  23 # single-line redirection command (only affects the line they are in):
  twenty four # ------------------------------------------------ --------------------
  25
  26 1> filename
  27 # Redirect stdout to the file "filename".
  28 1 >> filename
  29 # Redirect and appends stdout to the file "filename".
  30 2> filename
  31 # Redirect stderr to the file "filename".
  32 2 >> filename
  33 # Redirect and append stderr to the file "filename".
  34 & gt; filename
  35 # redirect both stdout and stderr to the file "filename".
  36
  37 # ================================================ ===============================
  38 # redirect stdout, one line at a time.
  39 LOGFILE = script.log
  40
  41 echo "This statement is sent to the log file, \" $ LOGFILE \ "." 1> $ LOGFILE
  42 echo "This statement is appended to \" $ LOGFILE \ "." 1 >> $ LOGFILE
  43 echo "This statement is also appended to \" $ LOGFILE \ "." >> LOGFILE
  44 echo "This statement is echoed to stdout, and will not appear in \" $ LOGFILE \ ".
  45 # After each line, these redirection commands are automatically "reset".
  46
  Gt;
  48
  49 # redirect stderr, one line at a time.
  50 ERRORFILE = script.errors
  51
  52 bad_command1 2> $ ERRORFILE # Error message sent to the $ ERRORFILE.
  53 bad_command2 2 >> $ ERRORFILE # Error message added to $ ERRORFILE.
  54 bad_command3 # Error message echo to stderr,
  55 # + and does not appear in $ ERRORFILE.
  56 # After each line, these redirection commands will automatically "reset".
  57 # ================================================ ===============================
  58
  59
  60
  61 2> & 1
  62 # redirect stderr to stdout.
  63 # get the same error message as stdout and send it to one place.
  64
  65 & gt;
  66 # redirects the file descriptors i to j.
  67 # points to the output of all the documents are sent to j to j.
  68
  69> & j
  70 # Default, redirect file descriptor 1 (stdout) to j.
  71 # All the output passed to stdout is sent to j.
  72
  73 0 < FILENAME
  74 < FILENAME
  75 # Accept input from file.
  76 # and ">" are pairs of commands, and are usually used in combination.
  77 #
  78 # grep search-word < filename
  79
  80
  81 [j] < > filename
  To read and write "filename", the file "filename" is opened, and the file descriptor "j" is assigned to it.
  83 # If the file "filename" does not exist, create it.
  84 # If the file descriptor "j" is not specified, then the default is fd 0, stdin.
  85 #
  86 # This application is usually written to a file specified in the place.
  87 echo 1234567890> File # Write the string to "File".
  88 exec 3 < > File # Opens "File" and assigns fd 3 to it.
  89 read -n 4 < & 3 # Read only 4 characters.
  90 echo -n.> & 3 # Write a decimal point.
  91 exec 3> & - # Close fd 3.
  92 cat File # ==> 1234.67890
  93 # Random storage.
  94
  95
  96
  97 |
  98 # pipeline.
  Generic Purpose Handling and Command Chain Tools.
 100 # is very similar to ">", but is actually more generic.
 101 # is useful when trying to concatenate commands, scripts, files, and programs.
 102 cat * .txt | sort | uniq> result-file
 103 # For all the output of the. Txt file to sort, and delete duplicate rows,
 104 # Save the result to "result-file".

You can combine multiple instances of the input and output redirection and / or pipe together to write on a single line.

Command < input-file> output-file
Command1 | command2 | command3> output-file

Multiple output streams can be redirected to a single file.

  1 ls -yz >> command.log 2> & 1
  2 # Put the result of the error option "yz" in the file "command.log".
  3 # Because stderr is redirected to this file,
  4 # + All the error messages are also pointing there.
  5
  Note that the following example does not give the same result.
  7 ls -yz 2> & 1 >> command.log
  8 # prints an error message, but does not write to the file.
  9
  10 # If both stdout and stderr are redirected,
  11 # The order of the commands is slightly different.

The exec < filename command redirects stdin to a file, starting with the input from the file, rather than the standard input (usually the keyboard input). Read the file, and you can use sed and / or awk to analyze each line.

Use exec to redirect standard input


1 #! / Bin / bash
  2 # Use 'exec' to redirect the standard input.
  3
  4
  5 exec 6 < & 0 # The file descriptor # 6 and stdin link.
  6 # saved stdin.
  7
  8 exec < data-file # stdin is replaced by the file "data-file".
  9
  10 read a1 # Read the first line of the file "data-file".
  11 read a2 # Read the second line of the file "data-file".
  12
  13 echo
  14 echo "Following lines read from file."
  15 echo "-------------------------------"
  16 echo $ a1
  17 echo $ a2
  18
  19 echo; echo; echo
  20
  21 exec 0 < & 6 6 < & -
  22 # Now restore stdin from fd # 6, because we just redirect stdin to # 6,
  23 # + Then close fd # 6 (6 < & -), so that the descriptor continues to be used by other processes.
  twenty four #
  25 # < & 6 6 < & - This can be done.
  26
  27 echo -n "Enter data"
  28 read b1 # Now "read" has returned to normal, is read from the stdin.
  29 echo "Input read from stdin."
  30 echo "----------------------"
  31 echo "b1 = $ b1"
  32
  33 echo
  34
  35 exit 0 Use exec to redirect stdout 1 #! / Bin / bash
  2 # reassign-stdout.sh
  3
  4 LOGFILE = logfile.txt
  5
  6 exec 6> & 1 # Connect fd # 6 to stdout.
  7 # Save stdout.
  8
  9 exec> $ LOGFILE # stdout was replaced by the file "logfile.txt".
  10
  11 # ------------------------------------------------ ----------- #
  12 # In this block all the output of the command are sent to the file $ LOGFILE.
  13
  14 echo -n "Logfile:"
  15 date
  16 echo "-------------------------------------"
  17 echo
  18
  19 echo "Output of \" ls -al \ "command"
  20 echo
  21 ls-al
  22 echo; echo
  23 echo "Output of \" df \ "command"
  24 echo
  25 df
  26
  27 # ------------------------------------------------ ----------- #
  28
  29 exec 1> & 6 6> & - # restore stdout, and then close file descriptor # 6.
  30
  31 echo
  32 echo "== stdout now restored to default =="
  33 echo
  34 ls-al
  35 Echo
  36
  37 exit 0

-------------------------------------------------- ------------------------------


-------------------------------------------------- ------------------------------

Use exec to redirect stdin and stdout 1 #! / Bin / bash in the same script
  2 # upperconv.sh
  3 # Converts a specified input file to uppercase.
  4
  5 E_FILE_ACCESS = 70
  6 E_WRONG_ARGS = 71
  7
  8 if [! -r "$ 1"] # to determine the specified input file is readable?
  9 then
  10 echo "Can not read from input file!"
  11 echo "Usage: $ 0 input-file output-file"
  12 exit $ E_FILE_ACCESS
  13 fi # Even if the input file ($ 1) is not specified
  14 # + will still exit with the same error (why?).
  15
  16 if [-z "$ 2"]
  17 then
  18 echo "Need to specify output file."
  19 echo "Usage: $ 0 input-file output-file"
  20 exit $ E_WRONG_ARGS
  21 fi
  twenty two
  twenty three
  24 exec 4 < & 0
  25 exec < $ 1 # will be read from the input file.
  26
  27 exec 7> & 1
  28 exec> $ 2 # will be written to the output file.
  29 # Suppose the output file is writable (add check?).
  30
  31 # -----------------------------------------------
  32 cat - | tr a-z A-Z # Convert to uppercase.
  33 # ^^^^^ # Read from stdin. Reads from stdin.
  34 # ^^^^^^^^^^ # Writes to stdout.
  35 # However, both stdin and stdout are redirected.
  36 # -----------------------------------------------
  37
  38 exec 1> & 7 7> & - # Restore stout.
  39 exec 0 < & 4 4 < & - # Restore stdin.
  40
  41 # After recovery, the following line of code will print to stdout as expected.
  42 echo "File \" $ 1 \ "written to \" $ 2 \ "as uppercase conversion."
  43
  44 exit 0

-------------------------------------------------- ------------------------------


I / O redirection is a way to avoid awkward sub-shell inaccessible variable problem.


-------------------------------------------------- ------------------------------
Avoid sub-shell 1 #! / Bin / bash
  2 # avoid-subshell.sh
  3 # Matthew Walker's recommendations.
  4
  5 Lines = 0
  6
  7 echo
  8
  9 cat myfile.txt | while read line; # (Translator's Note: pipeline will produce sub-shell)
  10 do {
  11 echo $ line
  12 ((Lines ++)); # Increase the value of this variable
  13 # + but the external loop can not access.
  14 # Sub-shell problem.
  15}
  16 done
  17
  18 echo "Number of lines read = $ Lines" # 0
  19 # Error!
  20
  21 echo "------------------------"
  twenty two
  twenty three
  24 exec 3 < > myfile.txt
  25 while read line < & 3
  26 do {
  27 echo "$ line"
  28 ((Lines ++)); # Increase the value of this variable
  29 # + Now the external loop can be accessed.
  30 # No sub-shell, now no problem.
  31}
  32 done
  33 exec 3> & -
  34
  35 echo "Number of lines read = $ Lines" # 8
  36
  37 echo
  38
  39 exit 0
  40
  41 # The following line is the result of the script, the script will not come here.
  42
  43 $ cat myfile.txt
  44
  45 Line 1.
  46 Line 2.
  47 Line 3.
  48 Line
  49 Line 5.
  50 Line 6.
  51 Line 7.
  52 Line 8.
     
         
         
         
  More:      
 
- Detailed installation OpenCV2.3.1 under CentOS 6.5 (Linux)
- Snort build a secure Linux server (Linux)
- Oracle in the add & split partition on the impact of global & local index (Database)
- Ubuntu buffalo wzr-hp-300nh brush DD-WRT router system (Linux)
- Towards Docker (Server)
- Linux operating system ARP Spoofing Defense (Linux)
- Implicit conversion from Java type conversion compare MySQL and Oracle (Database)
- Android components save state series - Activity (Programming)
- Upgrade Goldengate 11.1.1.1.2 to 11.2.1.0.1 (Database)
- Java Concurrency -volatile keywords (Programming)
- Two alert log ORA Errors (Database)
- Android memory optimization of the disk cache (Linux)
- Linux system started to learn: how to view the contents of the seed on the Linux file (Linux)
- Classical sorting algorithm - Selection Sort (Linux)
- Linux FTP setting file description (Server)
- PostgreSQL Source Customization: Online global read only (Database)
- Learning OpenCV: (VS2010-openCV2.4.3-win7 configuration instructions) (Linux)
- Linux and hardware (Linux)
- Erlang concurrency and foundation (Programming)
- Ubuntu 14.04 Trusty Tahr User How to install Banshee 2.9.1 (Linux)
     
           
     
  CopyRight 2002-2022 newfreesoft.com, All Rights Reserved.