Batch: Display & Redirect Output

Batch How To ...

Display & Redirect Output

http://www.robvanderwoude.com/battech_redirection.php

On this page I'll try to explain how redirection works.
To illustrate my story there are some examples you can try for yourself.

For an overview of redirection and piping, view my original redirection page.

Display text

To display a text on screen we have the ECHO command:

ECHO Hello world

This will show the following text on screen:

Hello world

When I say "on screen", I'm actually referring to the
"DOS Prompt", "console" or "command window", or
whatever other "alias" is used.

Streams

The output we see in this window may all look alike, but it can
actually be the result of 3 different "streams" of text, 3
"processes" that each sends their text to the same window.

Those of you familiar with one of the Unix/Linux shells probably
know what these streams are:

• Standard Output
• Standard Error
• Console

Standard Output is the stream where all, well, standard output of
commands is being sent to.
The ECHO command
sends all its output to Standard Output.

Standard Error is the stream where many (but not all)
commands send their error messages.

And some, not many, commands send their output to the screen
bypassing Standard Output and Standard Error, they use the Console. By
definition Console isn't a stream.

There is another stream, Standard Input: many commands
accept input at their Standard Input instead of directly from the keyboard.
Probably the most familiar example is MORE:

DIR /S | MORE

where the MORE command
accepts DIR's
Standard Output at its own Standar Input, chops the stream in blocks of 25
lines (or whatever screen size you may use) and sends it to its own Standard
Output.

(Since MORE's
Standard Input is used by DIR, MORE must catch its keyboard presses (the "Any Key")
directly from the keyboard buffer instead of from Standard Input.)

Redirection

You may be familiar with "redirection to NUL" to hide
command output:

ECHO Hello world>NUL

will show nothing on screen.
That's because >NUL redirects all
Standard Output to the NUL device, which does nothing but discard it.

Now try this (note the typo):

EHCO Hello world>NUL

The result may differ for different operating system versions, but
in Windows XP I get the following error message:

'EHCO' is not recognized as an internal or external command,
operable program or batch file.

This is a fine demonstration of only Standard
Output being redirected to the NUL device, but Standard Error still being
displayed.

Redirecting Standard Error in "true" MS-DOS (COMMAND.COM)
isn't possible (actually it is, by using the CTTY command, but that would redirect all output
including Console, and input, including keyboard).
In Windows NT 4 and later (CMD.EXE) and in OS/2 (also CMD.EXE) Standard
Error can be redirected by using 2> instead
of>

A short demonstration. Try this command:

ECHO Hello world 2>NUL

What you should get is:

Hello world

You see? The same result you got with ECHO Hello world without the
redirection.
That's because we redirected the Standard Error stream to the NUL device, but
the ECHO command sent its output to the Standard Output stream, which was not redirected.

Now make a typo again:

EHCO Hello world 2>NUL

What did you get? Nothing
That's because the error message was sent to the Standard Error stream, which
was in turn redirected to the NUL device by 2>NUL

When we use > to
redirect Standard Output, CMD.EXE interprets this as 1>, as can be seen by writing and running this one-line batch file
"test.bat":

DIR > NUL

Now run test.bat in CMD.EXE and watch the result:

C:\>test.bat

C:\>DIR  1>NUL

C:\>_

It looks like CMD.EXE uses 1 for Standard Output and 2 for Standard
Error. We'll see how we can use this later.

Ok, now that we get the idea of this concept of
"streams", let's play with it.
Copy the following code into Notepad and save it as "test.bat":

@ECHO OFF

ECHO This text goes to Standard Output

ECHO This text goes to Standard Error 1>&2

ECHO This text goes to the Console>CON

Run test.bat in CMD.EXE, and this is what you'll get:

C:\>test.bat

This text goes to Standard Output

This text goes to Standard Error

This text goes to the Console

C:\>_

Now let's see if we can separate the streams again.
Run:

test.bat > NUL

and you should see:

C:\>test.bat

This text goes to Standard Error

This text goes to the Console

C:\>_

We redirected Standard Output to the NUL device, and what was left
were Standard Error and Console.

Next, run:

test.bat 2> NUL

and you should see:

C:\>test.bat

This text goes to Standard Output

This text goes to the Console

C:\>_

We redirected Standard Error to the NUL device, and what was left
were Standard Output and Console.

Nothing new so far. But the next one is new:

test.bat > NUL 2>&1

and you should see:

C:\>test.bat

This text goes to the Console

C:\>_

This time we redirected both Standard Output and Standard
Error to the NUL device, and what was left was only Console.
It is said Console cannot be redirected, and I believe that's true. I can
assure you I did try!

To get rid of screen output
sent directly to the Console, either run the program in a separate window
(using the START command),
or clear the screen immediately afterwards (CLS).

In this case, we could also have used test.bat >NUL 2>NUL
This redirects Standard Output to the NUL device and Standard Error to the
same NUL device.
With the NUL device that's no problem, but when redirecting to a file one
of the redirections will lock the file for the other
redirection.
What 2>&1 does,
is merge Standard Error into the Standard Output stream, so
Standard output and Standard Error will continue as a single stream.

Redirect "all" output to a single file:

Run:

test.bat > test.txt 2>&1

and you'll get this text on screen (we'll never get rid of this line
on screen, as it is sent to the Console and cannot be redirected):

This text goes to the Console

You should also get a file named test.txt with the following
content:

This text goes to Standard Output

This text goes to Standard Error

Notes: The commands

The commands

test.bat  > test.txt 2>&1
test.bat 1> test.txt 2>&1
test.bat 2> test.txt 1>&2

all give identical results.

Redirect errors to a separate error log file:

Run:

test.bat > testlog.txt 2> testerrors.txt

and you'll get this text on screen (we'll never get rid of this
line on screen, as it is sent to the Console and cannot be redirected):

This text goes to the Console

You should also get a file named testlog.txt with the following
content:

This text goes to Standard Output

and another file named testerrors.txt with the following content:

This text goes to Standard Error

Nothing is impossible, not even redirecting the Console output.

Unfortunately, it can be done only in the old MS-DOS versions that
came with a CTTY command.

The general idea was this:

CTTY NUL

ECHO Echo whatever you want, it won't be displayed on screen no
matter what.

ECHO By the way, did I warn you that the keyboard doesn't work
either?

ECHO I suppose that's why CTTY is no longer available on Windows
systems.

ECHO The only way to get control over the computer again is a
cold reboot,

ECHO or the following command:

CTTY CON

A pause or prompt for input before the CTTY CON command meant one had to press the reset
button!

Besides being used for redirection to the NUL device, with CTTY COM1 the control could be passed on to a
terminal on serial port COM1.

Escaping Redirection (not to be interpreted as
"Avoiding Redirection")

Redirection always uses the main or first command's
streams:

START command > logfile

will redirect START's
Standard Output to logfile, not command's!
The result will be an empty logfile.

A workaround that may look a bit intimidating is grouping the
command line and escaping the redirection:

START CMD.EXE /C ^(command ^> logfile^)

What this does is turn the part between parentheses into a
"literal" (uninterpreted) string that is passed to the command
interpreter of the newly started process, which then in turn does interpret
it.
So the interpretation of the parenthesis and redirection is delayed, or
deferred.

Note:

Be careful when using workarounds like these, they may be broken in future (or even past) Windows versions.

A safer way to redirect STARTed
commands' output would be to create and run a "wrapper" batch file
that handles the redirection.
The batch file would look like this:

command > logfile

and the command line would be:

START batchfile

Some "best practices" when using redirection in batch files:

• Use >filename.txt 2>&1 to merge
  Standard Output and Standard Error and redirect them together to a single
  file.
  Make sure you place the redirection "commands" in this order.
• Use >logfile.txt 2>errorlog.txt to
  redirect success and error messages to separate log files.
• Use >CON to send text to the screen,
  no matter what, even if the batch file's output is redirected.
  This could be useful when prompting for input even if the batch file's
  output is being redirected to a file.
• Use 1>&2 to send text to Standard
  Error.
  This can be useful for error messages.
• It's ok to use
  spaces in redirection commands. Note however, that a space between an ECHO
  command and a > will be
  redirected too.
  DIR>filename.txt and DIR > filename.txt are
  identical, ECHO Hello world>filename.txt and ECHO Hello world > filename.txt are not,
  even though they are both valid.
  It is not ok to use spaces in >> or 2> or 2>&1 or 1>&2 (before or after is ok).
• In Windows
  NT 4, early Windows 2000 versions, and OS/2 there used to be some
  ambiguity with ECHOed lines ending with a 1 or 2, immediately followed by
  a >:
  ECHO Hello world2>file.txt would
  result in an empty file file.txt and the
  text Hello world (without the
  trailing "2") on screen (CMD.EXE would interpret it as ECHO Hello world 2>file.txt).
  In Windows XP the result is no text on screen and file.txt containing
  the line Hello world2, including the
  trailing "2" (CMD.EXE interprets it as ECHO Hello world2 >file.txt).
  To prevent this ambiguity, either use parentheses or insert an extra space
  yourself:
  ECHO Hello World2 >file.txt
  (ECHO Hello World2)>file.txt
• "Merging"
  Standard Output and Standard Error with 2>&1 can also be used to pipe a
  command's output to another command's Standard Input:
  somecommand 2>&1 | someothercommand