Anzeigen der Windows-Eingabeaufforderungsausgabe und Umleiten in eine Datei

Wie kann ich eine Befehlszeilenanwendung an der Windows-Eingabeaufforderung ausführen und die Ausgabe gleichzeitig anzeigen und in eine Datei umleiten lassen?

Wenn ich zum Beispiel den Befehl ausführen dir > test.txtwürde, würde dies die Ausgabe in eine aufgerufene Datei umleitentest.txt ohne die Ergebnisse anzuzeigen.

Wie kann ich einen Befehl schreiben, um die Ausgabe anzuzeigen und die Ausgabe in eine Datei an der Windows-Eingabeaufforderung umzuleiten, ähnlich dem teeBefehl unter Unix?

Um die Antwort von davor zu erweitern , können Sie PowerShell folgendermaßen verwenden:

powershell "dir | tee test.txt"

Wenn Sie versuchen, die Ausgabe einer Exe im aktuellen Verzeichnis umzuleiten, müssen Sie .\den Dateinamen verwenden, z.

powershell ".\something.exe | tee test.txt"

Ich konnte eine Lösung / Problemumgehung für die Umleitung der Ausgabe in eine Datei und dann in die Konsole finden:

dir > a.txt | type a.txt

Dabei ist dir der Befehl, dessen Ausgabe umgeleitet werden muss, a.txt eine Datei, in der die Ausgabe gespeichert werden soll.

Es gibt einen Win32-Port des Unix- teeBefehls, der genau das tut. Siehe http://unxutils.sourceforge.net/ oder http://getgnuwin32.sourceforge.net/

Schauen Sie sich das an: wintee

Keine Notwendigkeit für Cygwin.

Ich bin jedoch auf einige Probleme gestoßen und habe sie gemeldet.

Sie können auch Unxutils überprüfen, da es Tee enthält (und kein Cygwin erforderlich ist). Beachten Sie jedoch, dass die Ausgabe-EOLs hier UNIX-ähnlich sind.

Zu guter Letzt können Sie Tee-Object ausprobieren, wenn Sie über PowerShell verfügen. Geben Sie die get-help tee-objectPowerShell-Konsole ein, um weitere Informationen zu erhalten.

@ tori3852

ich habe das gefunden

dir > a.txt | type a.txt

hat nicht funktioniert (nur die ersten paar Zeilen der Verzeichnisliste - Verdacht auf eine Art Prozessgabelung und der zweite Teil, der Befehl 'type' wurde beendet, bevor die Verzeichnisliste abgeschlossen wurde?), also habe ich stattdessen Folgendes verwendet:

dir > z.txt && type z.txt

was tat - sequentielle Befehle, die man abschließt, bevor der zweite startet.

Leider gibt es so etwas nicht.

Windows-Konsolenanwendungen haben nur ein einziges Ausgabehandle. (Nun, es gibt zwei STDOUT, STDERRaber das spielt hier keine Rolle.) Der >leitet die normalerweise in das Konsolenhandle geschriebene Ausgabe in ein Dateihandle um.

Wenn Sie eine Art Multiplexing wünschen, müssen Sie eine externe Anwendung verwenden, zu der Sie die Ausgabe umleiten können. Diese Anwendung kann dann erneut in eine Datei und in die Konsole schreiben.

Eine einfache C # -Konsolenanwendung würde den Trick machen:

using System;
using System.Collections.Generic;
using System.IO;

namespace CopyToFiles
{
    class Program
    {
        static void Main(string[] args)
        {
            var buffer = new char[100];
            var outputs = new List<TextWriter>();

            foreach (var file in args)
                outputs.Add(new StreamWriter(file));

            outputs.Add(Console.Out);

            int bytesRead;
            do
            {
                bytesRead = Console.In.ReadBlock(buffer, 0, buffer.Length);
                outputs.ForEach(o => o.Write(buffer, 0, bytesRead));
            } while (bytesRead == buffer.Length);

            outputs.ForEach(o => o.Close());
        }
    }
}

Um dies zu verwenden, leiten Sie einfach den Quellbefehl in das Programm ein und geben den Pfad aller Dateien an, in die Sie die Ausgabe duplizieren möchten. Zum Beispiel:

dir | CopyToFiles files1.txt files2.txt 

Zeigt die Ergebnisse von dir an und speichert die Ergebnisse sowohl in files1.txt als auch in files2.txt.

Beachten Sie, dass die oben beschriebene Fehlerbehandlung nicht viel (irgendetwas!) Hält und die Unterstützung mehrerer Dateien möglicherweise nicht erforderlich ist.

Das funktioniert, obwohl es ein bisschen hässlich ist:

dir >_ && type _ && type _ > a.txt

Es ist etwas flexibler als einige der anderen Lösungen, da es Anweisung für Anweisung funktioniert, sodass Sie es auch zum Anhängen verwenden können. Ich verwende dies ziemlich oft in Batch-Dateien, um Nachrichten zu protokollieren und anzuzeigen:

ECHO Print line to screen and log to file.  >_ && type _ && type _ >> logfile.txt

Ja, Sie können die ECHO-Anweisung einfach wiederholen (einmal für den Bildschirm und zum zweiten Mal zur Umleitung in die Protokolldatei), aber das sieht genauso schlecht aus und ist ein kleines Wartungsproblem. Zumindest auf diese Weise müssen Sie an zwei Stellen keine Änderungen an Nachrichten vornehmen.

Beachten Sie, dass _ nur ein kurzer Dateiname ist. Sie müssen ihn daher am Ende Ihrer Batchdatei löschen (wenn Sie eine Batchdatei verwenden).

mtee ist ein kleines Dienstprogramm, das für diesen Zweck sehr gut funktioniert. Es ist kostenlos, die Quelle ist offen und es funktioniert einfach.

Sie finden es unter http://www.commandline.co.uk .

Wird in einer Batchdatei verwendet, um die Ausgabe anzuzeigen UND gleichzeitig eine Protokolldatei zu erstellen. Die Syntax sieht folgendermaßen aus:

    someprocess | mtee /+ mylogfile.txt

Wobei / + bedeutet, die Ausgabe anzuhängen.

Dies setzt voraus, dass Sie mtee in einen Ordner kopiert haben, der sich natürlich im PATH befindet.

Ich möchte die ausgezeichnete Antwort von Saxon Druce etwas näher erläutern .

Wie bereits erwähnt, können Sie die Ausgabe einer ausführbaren Datei im aktuellen Verzeichnis wie folgt umleiten:

powershell ".\something.exe | tee test.txt"

Dies protokolliert jedoch nur stdoutbei test.txt. Es wird auch nicht protokolliert stderr.

Die naheliegende Lösung wäre, so etwas zu verwenden:

powershell ".\something.exe 2>&1 | tee test.txt"

Dies funktioniert jedoch nicht für alle something.exes. Einige something.exes werden das 2>&1als Argument interpretieren und scheitern. Die richtige Lösung besteht darin, stattdessen nur Apostrophe um das something.exeund seine Schalter und Argumente zu haben, wie folgt :

powershell ".\something.exe --switch1 --switch2 … arg1 arg2 …" 2>&1 | tee test.txt

Ich stimme Brian Rasmussen zu, der Unxutils-Port ist der einfachste Weg, dies zu tun. Im Batch - Dateien Abschnitt seines Scripting Pages Rob van der Woude bietet eine Fülle von Informationen über die Verwendung von MS-DOS und CMD - Befehlen. Ich dachte, er könnte eine native Lösung für Ihr Problem haben, und nachdem ich mich dort umgesehen hatte , fand ich TEE.BAT , was genau das zu sein scheint, eine MS-DOS-Batch- Sprachimplementierung von tee. Es ist eine ziemlich komplex aussehende Batch-Datei und meine Neigung wäre immer noch, den unxutils-Port zu verwenden.

Wenn Sie Cygwin in Ihrem Windows-Umgebungspfad haben, können Sie Folgendes verwenden:

 dir > a.txt | tail -f a.txt

dir 1>a.txt 2>&1 | type a.txt

Dies hilft, sowohl STDOUT als auch STDERR umzuleiten

Ich weiß, dass dies ein sehr altes Thema ist, aber in früheren Antworten gibt es keine vollständige Implementierung eines in Batch geschriebenen Echtzeit-T-Stücks. Meine Lösung unten ist ein Batch-JScript-Hybridskript, das den JScript-Abschnitt verwendet, um nur die Ausgabe des Piped-Befehls abzurufen. Die Verarbeitung der Daten erfolgt jedoch im Batch-Abschnitt. Dieser Ansatz hat den Vorteil, dass jeder Batch-Programmierer dieses Programm an bestimmte Anforderungen anpassen kann. Dieses Programm verarbeitet auch die Ausgabe des CLS-Befehls, der von anderen Batch-Dateien erzeugt wird, korrekt, dh es löscht den Bildschirm, wenn die Ausgabe des CLS-Befehls erkannt wird.

@if (@CodeSection == @Batch) @then


@echo off
setlocal EnableDelayedExpansion

rem APATee.bat: Asynchronous (real time) Tee program, Batch-JScript hybrid version
rem Antonio Perez Ayala

rem The advantage of this program is that the data management is written in Batch code,
rem so any Batch programmer may modify it to fit their own needs.
rem As an example of this feature, CLS command is correctly managed

if "%~1" equ "" (
   echo Duplicate the Stdout output of a command in the screen and a disk file
   echo/
   echo anyCommand ^| APATee teeFile.txt [/A]
   echo/
   echo If /A switch is given, anyCommand output is *appended* to teeFile.txt
   goto :EOF
)

if "%2" equ ":TeeProcess" goto TeeProcess

rem Get the output of CLS command
for /F %%a in ('cls') do set "cls=%%a"

rem If /A switch is not provided, delete the file that receives Tee output
if /I "%~2" neq "/A" if exist %1 del %1

rem Create the semaphore-signal file and start the asynchronous Tee process
echo X > Flag.out
if exist Flag.in del Flag.in
Cscript //nologo //E:JScript "%~F0" | "%~F0" %1 :TeeProcess
del Flag.out
goto :EOF

:TeeProcess
   rem Wait for "Data Available" signal
   if not exist Flag.in goto TeeProcess
   rem Read the line sent by JScript section
   set line=
   set /P line=
   rem Set "Data Read" acknowledgement
   ren Flag.in Flag.out
   rem Check for the standard "End Of piped File" mark
   if "!line!" equ ":_EOF_:" exit /B
   rem Correctly manage CLS command
   if "!line:~0,1!" equ "!cls!" (
      cls
      set "line=!line:~1!"
   )
   rem Duplicate the line in Stdout and the Tee output file
   echo(!line!
   echo(!line!>> %1
goto TeeProcess


@end


// JScript section

var fso = new ActiveXObject("Scripting.FileSystemObject");
// Process all lines of Stdin
while ( ! WScript.Stdin.AtEndOfStream ) {
   // Read the next line from Stdin
   var line = WScript.Stdin.ReadLine();
   // Wait for "Data Read" acknowledgement
   while ( ! fso.FileExists("Flag.out") ) {
      WScript.Sleep(10);
   }
   // Send the line to Batch section
   WScript.Stdout.WriteLine(line);
   // Set "Data Available" signal
   fso.MoveFile("Flag.out", "Flag.in");
}
// Wait for last "Data Read" acknowledgement
while ( ! fso.FileExists("Flag.out") ) {
      WScript.Sleep(10);
}
// Send the standard "End Of piped File" mark
WScript.Stdout.WriteLine(":_EOF_:");
fso.MoveFile("Flag.out", "Flag.in");

Ich suchte auch nach der gleichen Lösung. Nach einem kleinen Versuch konnte ich dies in der Eingabeaufforderung erfolgreich erreichen. Hier ist meine Lösung:

@Echo off
for /f "Delims=" %%a IN (xyz.bat) do (
%%a > _ && type _ && type _ >> log.txt
)
@Echo on

Es erfasst sogar jeden PAUSE-Befehl.

Hier ist ein Beispiel von dem, was ich basierend auf einer der anderen Antworten verwendet habe

@echo off
REM SOME CODE
set __ERROR_LOG=c:\errors.txt
REM set __IPADDRESS=x.x.x.x

REM Test a variable
if not defined __IPADDRESS (
     REM Call function with some data and terminate
     call :TEE %DATE%,%TIME%,IP ADDRESS IS NOT DEFINED
     goto :EOF
)

REM If test happens to be successful, TEE out a message and end script.
call :TEE Script Ended Successful
goto :EOF


REM THE TEE FUNCTION
:TEE
for /f "tokens=*" %%Z in ("%*") do (
     >  CON ECHO.%%Z
     >> "%__ERROR_LOG%" ECHO.%%Z
     goto :EOF
)

So etwas sollte tun, was Sie brauchen?

%DATE%_%TIME% > c:\a.txt & type c:\a.txt
ipconfig >> c:\a.txt & type c:\a.txt
ping localhost >> c:\a.txt & type c:\a.txt
pause

Ausgabe an Konsole senden, an Konsolenprotokoll anhängen, Ausgabe aus aktuellem Befehl löschen

dir  >> usb-create.1 && type usb-create.1 >> usb-create.log | type usb-create.1 && del usb-create.1

Dies ist eine Variation einer früheren Antwort von MTS, fügt jedoch einige Funktionen hinzu, die für andere nützlich sein könnten. Hier ist die Methode, die ich verwendet habe:

• Ein Befehl wird als Variable festgelegt, die später im gesamten Code verwendet werden kann, um im Befehlsfenster auszugeben und mithilfe von an eine Protokolldatei anzuhängen set _Temp_Msg_Cmd=
  • Der Befehl ist der Umleitung mit dem Karottenzeichen entkommen , ^sodass die Befehle zunächst nicht ausgewertet werden
• Eine temporäre Datei wird mit einem Dateinamen erstellt, der der ausgeführten Batchdatei ähnelt und die Syntax der Befehlszeilenparametererweiterung%~n0_temp.txt verwendet , um den Namen der Batchdatei abzurufen. %~n0
• Die Ausgabe wird an eine separate Protokolldatei angehängt %~n0_log.txt

Hier ist die Reihenfolge der Befehle:

1. Die Ausgabe- und Fehlermeldungen werden an die temporäre Datei gesendet ^> %~n0_temp.txt 2^>^&1
2. Der Inhalt der temporären Datei ist dann beides:
   • an die Protokolldatei angehängt ^& type %~n0_temp.txt ^>^> %~n0_log.txt
   • Ausgabe in das Befehlsfenster ^& type %~n0_temp.txt
3. Die temporäre Datei mit der Nachricht wird gelöscht ^& del /Q /F %~n0_temp.txt

Hier ist das Beispiel:

set _Temp_Msg_Cmd= ^> %~n0_temp.txt 2^>^&1 ^& type %~n0_temp.txt ^>^> %~n0_log.txt ^& type %~n0_temp.txt ^& del /Q /F %~n0_temp.txt

Auf diese Weise kann der Befehl einfach nach späteren Befehlen in einer Batch-Datei angehängt werden, die viel sauberer aussieht:

echo test message %_Temp_Msg_Cmd%

Dies kann auch am Ende anderer Befehle hinzugefügt werden. Soweit ich das beurteilen kann, funktioniert es, wenn Nachrichten mehrere Zeilen haben. Der folgende Befehl gibt beispielsweise zwei Zeilen aus, wenn eine Fehlermeldung angezeigt wird:

net use M: /D /Y %_Temp_Msg_Cmd%

@echo on

set startDate=%date%
set startTime=%time%

set /a sth=%startTime:~0,2%
set /a stm=1%startTime:~3,2% - 100
set /a sts=1%startTime:~6,2% - 100


fullprocess.bat > C:\LOGS\%startDate%_%sth%.%stm%.%sts%.LOG | fullprocess.bat

Dadurch wird eine Protokolldatei mit der aktuellen Datums- und Uhrzeitangabe erstellt, und Sie können die Konsolenzeilen während des Vorgangs erstellen

Ich verwende eine Batch-Subroutine mit einer "for" -Anweisung, um den Befehl zeilenweise auszugeben, und beide schreiben diese Zeile in eine Datei und geben sie an die Konsole aus.

@echo off
set logfile=test.log

call :ExecuteAndTee dir C:\Program Files

Exit /B 0

:ExecuteAndTee
setlocal enabledelayedexpansion
echo Executing '%*'
  for /f "delims=" %%a in ('%* 2^>^&1') do (echo.%%a & echo.%%a>>%logfile%)
endlocal
Exit /B 0

Wenn Sie sich in der CLI befinden, können Sie mit einer FOR-Schleife tun, was Sie wollen:

for /F "delims=" %a in ('dir') do @echo %a && echo %a >> output.txt

Ressource unter Windows CMD für Schleifen: https://ss64.com/nt/for_cmd.html Der Schlüssel hier ist, die Begrenzer (Begrenzungen), die jede Ausgabezeile aufteilen würden, auf nichts zu setzen. Auf diese Weise wird die Standardeinstellung für Leerzeichen nicht unterbrochen. % A ist ein beliebiger Buchstabe, wird jedoch im Abschnitt "do" verwendet, um ... etwas mit den Zeichen zu tun, die in jeder Zeile analysiert wurden. In diesem Fall können wir das kaufmännische Und (&&) verwenden, um den 2. Echo-Befehl auszuführen, um eine Datei unserer Wahl zu erstellen oder an diese anzuhängen (>>). Es ist sicherer, diese Reihenfolge der DO-Befehle beizubehalten, falls beim Schreiben der Datei ein Problem auftritt. Zumindest wird das Echo zuerst an die Konsole gesendet. Das at-Zeichen (@) vor dem ersten Echo verhindert, dass die Konsole den Echo-Befehl selbst anzeigt, und zeigt stattdessen nur das Ergebnis des Befehls an, der die Zeichen in% a anzeigt. Sonst würden Sie sehen:

echo Lautstärke in Laufwerk [x] ist Windows
Lautstärke in Laufwerk [x] ist Windows

UPDATE: / F überspringt leere Zeilen und behebt nur die Vorfilterung der Ausgabe, indem jeder Zeile ein Zeichen hinzugefügt wird (möglicherweise mit Zeilennummern über den Befehl find). Das Lösen in CLI ist nicht schnell oder hübsch. Außerdem habe ich STDERR nicht eingeschlossen, daher werden hier auch Fehler erfasst:

for /F "delims=" %a in ('dir 2^>^&1') do @echo %a & echo %a >> output.txt

Fehlermeldungen umleiten

Die Carets (^) dienen dazu, den Symbolen nach ihnen zu entkommen, da der Befehl eine Zeichenfolge ist, die interpretiert wird, anstatt sie direkt in die Befehlszeile einzugeben.

Genau wie Unix.

dir | tee a.txt

Funktioniert Unter Windows XP muss es mksntinstalliert sein.

Es wird an der Eingabeaufforderung angezeigt und an die Datei angehängt.

Das Folgende hilft, wenn Sie möchten, dass etwas wirklich auf dem Bildschirm angezeigt wird - auch wenn die Batchdatei in eine Datei umgeleitet wurde. Das Gerät CON kann auch verwendet werden, wenn es in eine Datei umgeleitet wird

Beispiel:

ECHO first line on normal stdout. maybe redirected
ECHO second line on normal stdout again. maybe redirected
ECHO third line is to ask the user. not redirected  >CON
ECHO fourth line on normal stdout again. maybe redirected

Siehe auch eine gute Umleitungsbeschreibung: http://www.p-dd.com/chapter7-page14.html

Wie zeige ich die Ausgabe an und leite sie in eine Datei um? Angenommen, wenn ich den Befehl dos, dir> test.txt, verwende, leitet dieser Befehl die Ausgabe in die Datei test.txt um, ohne die Ergebnisse anzuzeigen. Schreiben eines Befehls zum Anzeigen der Ausgabe und Umleiten der Ausgabe in eine Datei unter DOS, dh Windows-Eingabeaufforderung, nicht unter UNIX / LINUX.

Sie können diese Befehle in biterscripting ( http://www.biterscripting.com ) nützlich finden.

var str output
lf > $output
echo $output                            # Will show output on screen.
echo $output > "test.txt"               # Will write output to file test.txt.
system start "test.txt"                 # Will open file test.txt for viewing/editing.

Dies funktioniert in Echtzeit, ist aber auch ziemlich hässlich und die Leistung ist langsam. Auch nicht gut getestet:

@echo off
cls
SET MYCOMMAND=dir /B
ECHO File called 'test.bat' > out.txt
for /f "usebackq delims=" %%I in (`%MYCOMMAND%`) do (
  ECHO %%I
  ECHO %%I >> out.txt
) 
pause

Eine Alternative besteht darin, stdout zu stderr innerhalb Ihres Programms zu tippen:

in Java:

System.setOut(new PrintStream(new TeeOutputStream(System.out, System.err)));

Dann in Ihrer Dos-Batchdatei: java program > log.txt

Das stdout wird in die Protokolldatei verschoben und das stderr (dieselben Daten) wird auf der Konsole angezeigt.

Ich installiere Perl auf den meisten meiner Computer, daher eine Antwort mit Perl: tee.pl.

my $file = shift || "tee.dat";
open $output, ">", $file or die "unable to open $file as output: $!";
while(<STDIN>)
{
    print $_;
    print $output $_;
}
close $output;

dir | perl tee.pl oder dir | perl tee.pl dir.bat

roh und ungetestet.

Eine andere Variante besteht darin, die Pipe zu teilen und die Ausgabe dann nach Belieben umzuleiten.

    @echo off
    for /f "tokens=1,* delims=:" %%P in ('findstr /n "^"') do (
      echo(%%Q
      echo(%%Q>&3
    )
    @exit/b %errorlevel%

Speichern Sie das oben genannte in einer .bat-Datei. Es teilt die Textausgabe von Filestream 1 auch in Filestream 3 auf, die Sie nach Bedarf umleiten können. In meinen Beispielen unten habe ich das obige Skript splitPipe.bat aufgerufen ...

    dir | splitPipe.bat  1>con  2>&1  3>my_stdout.log

    splitPipe.bat 2>nul < somefile.txt

1. https://cygwin.com/install
2. Klicken Sie auf den Link für "setup-x86_.exe".
3. Führen Sie das Installationsprogramm aus
4. Wählen Sie auf der 2. Seite einen "Spiegel" zum Herunterladen aus (ich habe nach einer .edu-Domain gesucht).
5. Ich sagte ok zu den Standardoptionen
6. Cygwin beendete die Installation schnell
7. Öffnen Sie cmd
8. Geben Sie ein c:\cygwin64\bin\script.exeund geben Sie ein
9. Geben Sie ein cmdund geben Sie ein
10. Führen Sie Ihr Programm aus
11. Geben Sie ein exitund geben Sie ein (beendet Cygwins cmd.exe)
12. Geben Sie exitund geben Sie (Ausfahrten Cygwin script.exe)
13. Sehen Sie sich die Bildschirmausgabe Ihres Programms in einer Textdatei mit dem Namen "Typoskript" an.