Visualizzazione dell'output del prompt dei comandi di Windows e reindirizzamento a un file

Come posso eseguire un'applicazione da riga di comando nel prompt dei comandi di Windows e avere l'output visualizzato e reindirizzato contemporaneamente a un file?

Se, ad esempio, dovessi eseguire il comando dir > test.txt, questo reindirizzerebbe l'output su un file chiamato test.txtsenza visualizzare i risultati.

Come potrei scrivere un comando per visualizzare l'output e reindirizzare l'output su un file nel prompt dei comandi di Windows, in modo simile al teecomando su Unix?

Per espandere la risposta di David , puoi usare PowerShell in questo modo:

powershell "dir | tee test.txt"

Se stai cercando di reindirizzare l'output di un exe nella directory corrente, devi utilizzare .\il nome file, ad esempio:

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

Sono stato in grado di trovare una soluzione / soluzione alternativa per reindirizzare l'output su un file e quindi sulla console:

dir > a.txt | type a.txt

dove dir è il comando di cui è necessario reindirizzare l' output , a.txt un file in cui archiviare l'output.

C'è una porta Win32 del teecomando Unix , che fa esattamente questo. Vedi http://unxutils.sourceforge.net/ o http://getgnuwin32.sourceforge.net/

Controllalo: Dai wintee

Non c'è bisogno di Cygwin.

Tuttavia, ho riscontrato e segnalato alcuni problemi.

Inoltre potresti controllare unxutils perché contiene tee (e non c'è bisogno di cygwin), ma attenzione che qui le EOL di output sono come UNIX.

Ultimo, ma non meno importante, è che se si dispone di PowerShell, è possibile provare Tee-Object. Digitare la get-help tee-objectconsole di PowerShell per ulteriori informazioni.

@ tori3852

l'ho trovato

dir > a.txt | type a.txt

non ha funzionato (solo le prime righe dell'elenco dir - sospetti una sorta di biforcazione del processo e la seconda parte, il comando 'type' è stato terminato prima che l'elenco terribile fosse completato?), quindi invece ho usato:

dir > z.txt && type z.txt

che ha fatto - comandi sequenziali, uno completa prima dell'inizio del secondo.

Purtroppo non esiste nulla del genere.

Le applicazioni console Windows hanno un solo handle di output. (Bene, ce ne sono due STDOUT, STDERRma non importa qui)> reindirizza l'output normalmente scritto sull'handle della console su un handle di file.

Se vuoi avere un qualche tipo di multiplexing devi usare un'applicazione esterna a cui puoi deviare l'output. Questa applicazione può quindi scrivere nuovamente su un file e sulla console.

Una semplice applicazione console C # farebbe il trucco:

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());
        }
    }
}

Per usarlo basta semplicemente inserire il comando source nel programma e fornire il percorso di tutti i file in cui si desidera duplicare l'output. Per esempio:

dir | CopyToFiles files1.txt files2.txt 

Visualizzerà i risultati di dir e memorizzerà i risultati in files1.txt e files2.txt.

Nota che non c'è molto (niente!) Nel modo di gestione degli errori sopra, e il supporto di più file potrebbe non essere effettivamente richiesto.

Funziona, anche se è un po 'brutto:

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

È un po 'più flessibile di alcune delle altre soluzioni, in quanto funziona dichiarazione per dichiarazione in modo da poterlo usare anche per aggiungere. Lo uso abbastanza nei file batch per registrare e visualizzare i messaggi:

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

Sì, potresti semplicemente ripetere l'istruzione ECHO (una volta per lo schermo e la seconda volta il reindirizzamento al file di registro), ma sembra altrettanto male ed è un po 'un problema di manutenzione. Almeno in questo modo non è necessario apportare modifiche ai messaggi in due punti.

Nota che _ è solo un breve nome di file, quindi devi assicurarti di eliminarlo alla fine del tuo file batch (se stai usando un file batch).

mtee è una piccola utility che funziona molto bene per questo scopo. È gratuito, la fonte è aperta e funziona.

Puoi trovarlo su http://www.commandline.co.uk .

Utilizzata in un file batch per visualizzare l'output E creare contemporaneamente un file di registro, la sintassi è simile alla seguente:

    someprocess | mtee /+ mylogfile.txt

Dove / + significa aggiungere output.

Ciò presuppone che tu abbia copiato mtee in una cartella che si trova nel PERCORSO, ovviamente.

Vorrei ampliare un po 'l' eccellente risposta di Saxon Druce .

Come detto, puoi reindirizzare l'output di un eseguibile nella directory corrente in questo modo:

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

Tuttavia, questo accede solo stdouta test.txt. Inoltre non registra stderr.

La soluzione ovvia sarebbe usare qualcosa del genere:

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

Tuttavia, questo non funzionerà per tutti gli utenti something.exe. Alcuni something.exes lo interpreteranno 2>&1come argomento e falliranno. La soluzione corretta è invece avere solo apostrofi attorno al something.exee ai suoi switch e argomenti, in questo modo:

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

Sono d'accordo con Brian Rasmussen, la porta di unxutils è il modo più semplice per farlo. Nella sezione File batch delle sue pagine di scripting Rob van der Woude fornisce molte informazioni sull'uso dei comandi MS-DOS e CMD. Ho pensato che potesse avere una soluzione nativa al tuo problema e dopo aver scavato lì ho trovato TEE.BAT , che sembra essere proprio questo, un'implementazione in linguaggio batch MS-DOS di tee. È un file batch dall'aspetto piuttosto complesso e la mia inclinazione sarebbe comunque quella di utilizzare la porta unxutils.

Se hai cygwin nel percorso del tuo ambiente Windows puoi usare:

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

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

Ciò contribuirà a reindirizzare sia STDOUT che STDERR

So che questo è un argomento molto vecchio, ma nelle risposte precedenti non c'è una piena implementazione di una Tee in tempo reale scritta in Batch. La mia soluzione di seguito è uno script ibrido Batch-JScript che utilizza la sezione JScript solo per ottenere l'output dal comando piped, ma l'elaborazione dei dati viene eseguita nella sezione Batch. Questo approccio ha il vantaggio che qualsiasi programmatore di Batch può modificare questo programma per soddisfare esigenze specifiche. Questo programma inoltre elabora correttamente l'output del comando CLS prodotto da altri file Batch, ovvero cancella lo schermo quando viene rilevato l'output del comando CLS.

@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");

Stavo anche cercando la stessa soluzione, dopo un piccolo tentativo, sono stato in grado di riuscirci con successo nel prompt dei comandi. Ecco la mia soluzione:

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

Cattura anche qualsiasi comando PAUSE.

Ecco un esempio di ciò che ho usato sulla base di una delle altre risposte

@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
)

Qualcosa del genere dovrebbe fare quello che ti serve?

%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

invia l'output alla console, aggiungi al registro della console, elimina l'output dal comando corrente

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

Questa è una variante di una precedente risposta di MTS, tuttavia aggiunge alcune funzionalità che potrebbero essere utili ad altri. Ecco il metodo che ho usato:

• Un comando viene impostato come variabile, che può essere utilizzato in seguito in tutto il codice, per l'output nella finestra di comando e aggiungere a un file di registro, utilizzando set _Temp_Msg_Cmd=
  • il comando ha evitato il reindirizzamento utilizzando il ^carattere carota in modo che i comandi non vengano valutati inizialmente
• Viene creato un file temporaneo con un nome file simile al file batch in esecuzione chiamato %~n0_temp.txtche utilizza la sintassi dell'estensione dei parametri della riga di comando %~n0 per ottenere il nome del file batch.
• L'output viene aggiunto a un file di registro separato %~n0_log.txt

Ecco la sequenza dei comandi:

1. I messaggi di output e di errore vengono inviati al file temporaneo ^> %~n0_temp.txt 2^>^&1
2. Il contenuto del file temporaneo è quindi entrambi:
   • aggiunto al file di registro ^& type %~n0_temp.txt ^>^> %~n0_log.txt
   • output nella finestra di comando ^& type %~n0_temp.txt
3. Il file temporaneo con il messaggio viene eliminato ^& del /Q /F %~n0_temp.txt

Ecco l'esempio:

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

In questo modo il comando può essere semplicemente aggiunto dopo i comandi successivi in ​​un file batch che sembra molto più pulito:

echo test message %_Temp_Msg_Cmd%

Questo può essere aggiunto anche alla fine di altri comandi. Per quanto ne so, funzionerà quando i messaggi hanno più righe. Ad esempio, il seguente comando genera due righe se è presente un messaggio di errore:

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

Ciò creerà un file di registro con il datetime corrente e sarà possibile utilizzare le linee della console durante il processo

Uso una subroutine batch con un'istruzione "for" per ottenere l'output del comando una riga alla volta ed entrambi scrivo quella riga in un file e lo emetto sulla console.

@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

Se sei sulla CLI, perché non utilizzare un ciclo FOR per "DO" quello che vuoi:

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

Grande risorsa su Windows CMD per loop: https://ss64.com/nt/for_cmd.html la chiave qui è impostare i delimitatori (delim), che spezzerebbero ogni linea di output, a nulla. In questo modo non si romperà il valore predefinito di white-space. % A è una lettera arbitraria, ma viene utilizzata nella sezione "do" per, beh ... fare qualcosa con i caratteri che sono stati analizzati su ogni riga. In questo caso possiamo usare le e commerciali (&&) per eseguire il secondo comando echo per creare-o-aggiungere (>>) a un file di nostra scelta. È più sicuro mantenere questo ordine di comandi DO nel caso in cui si verifichi un problema durante la scrittura del file, almeno avremo prima l'eco sulla console. Il segno at (@) davanti alla prima eco impedisce alla console di mostrare il comando echo stesso, e invece mostra solo il risultato del comando che è quello di visualizzare i caratteri in% a.

echo Il volume nell'unità [x] è Windows Il
volume nell'unità [x] è Windows

AGGIORNAMENTO: / F salta le righe vuote e l'unica soluzione è quella di pre-filtrare l'output aggiungendo un carattere ad ogni riga (forse con i numeri di riga tramite il comando find). Risolvere questo problema nella CLI non è veloce o carino. Inoltre, non ho incluso STDERR, quindi ecco anche gli errori di acquisizione:

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

Reindirizzamento dei messaggi di errore

I carets (^) sono lì per sfuggire ai simboli dopo di loro, perché il comando è una stringa che viene interpretata, al contrario di dirlo, inserendola direttamente nella riga di comando.

Proprio come unix.

dir | tee a.txt

Funziona su Windows XP, richiede l' mksntinstallazione.

Viene visualizzato sul prompt e viene aggiunto al file.

Seguire aiuta se vuoi qualcosa di veramente visto sullo schermo, anche se il file batch è stato reindirizzato a un file. Il dispositivo CON potrebbe essere utilizzato anche se reindirizzato a un file

Esempio:

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

Vedi anche una buona descrizione del reindirizzamento: http://www.p-dd.com/chapter7-page14.html

Come posso visualizzare e reindirizzare l'output su un file. Supponiamo che se utilizzo il comando dos, dir> test.txt, questo comando reindirizzerà l'output sul file test.txt senza visualizzare i risultati. come scrivere un comando per visualizzare l'output e reindirizzare l'output su un file utilizzando DOS, ad esempio il prompt dei comandi di Windows, non in UNIX / LINUX.

Puoi trovare questi comandi in biterscripting ( http://www.biterscripting.com ) utili.

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.

Funziona in tempo reale ma è anche brutto e le prestazioni sono lente. Non ben testato neanche:

@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

Un'alternativa è quella di collegare stdout a stderr all'interno del programma:

a java:

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

Quindi, nel tuo file batch dos: java program > log.txt

Lo stdout andrà al file di log e lo stderr (stessi dati) verrà mostrato sulla console.

Installo perl sulla maggior parte dei miei computer, quindi una risposta usando 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 o dir | perl tee.pl dir.bat

grezzo e non testato.

Un'altra variante è quella di dividere il tubo e quindi reindirizzare l'output come preferisci.

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

Salvare quanto sopra in un file .bat. Suddivide l'output del testo su filestream 1 e filestream 3, che è possibile reindirizzare secondo necessità. Nei miei esempi seguenti, ho chiamato lo script sopra splitPipe.bat ...

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

    splitPipe.bat 2>nul < somefile.txt

1. https://cygwin.com/install
2. Fare clic sul collegamento per "setup-x86_.exe"
3. Esegui il programma di installazione
4. Nella ~ seconda pagina, scegli un "mirror" da cui scaricare (ho cercato un dominio .edu)
5. Ho detto ok alle opzioni standard
6. Cygwin ha terminato rapidamente l'installazione
7. Apri cmd
8. genere c:\cygwin64\bin\script.exe e inserisci
9. genere cmd e inserisci
10. Esegui il tuo programma
11. Digita exite inserisci (esce da cmd.exe di Cygwin)
12. Digita exite inserisci (esce da Cygwin's script.exe)
13. Guarda l'output dello schermo del tuo programma nel file di testo chiamato "dattiloscritto"