Exibindo a saída do prompt de comando do Windows e redirecionando-a para um arquivo

Como posso executar um aplicativo de linha de comando no prompt de comando do Windows e ter a saída exibida e redirecionada para um arquivo ao mesmo tempo?

Se, por exemplo, eu executasse o comando dir > test.txt, isso redirecionaria a saída para um arquivo chamado test.txtsem exibir os resultados.

Como eu poderia escrever um comando para exibir a saída e redirecionar a saída para um arquivo no prompt de comando do Windows, semelhante ao teecomando no Unix?

Para expandir a resposta da davor , você pode usar o PowerShell assim:

powershell "dir | tee test.txt"

Se você está tentando redirecionar a saída de um exe no diretório atual, você precisa usar .\o nome do arquivo, por exemplo:

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

Consegui encontrar uma solução / solução alternativa de redirecionar a saída para um arquivo e depois para o console:

dir > a.txt | type a.txt

onde dir é o comando cuja saída precisa ser redirecionada, a.txt é um arquivo para armazenar a saída.

Há uma porta Win32 do teecomando Unix , que faz exatamente isso. Consulte http://unxutils.sourceforge.net/ ou http://getgnuwin32.sourceforge.net/

Confira: wintee

Não há necessidade de cygwin.

Eu encontrei e relatei alguns problemas.

Além disso, você pode verificar unxutils porque contém tee (e não há necessidade de cygwin), mas cuidado com o fato de que as EOLs de saída são semelhantes ao UNIX aqui.

Por último, mas não menos importante, é que, se você possui o PowerShell, pode experimentar o Tee-Object. Digite get-help tee-objectno console do PowerShell para obter mais informações.

@ tori3852

eu achei aquilo

dir > a.txt | type a.txt

não funcionou (apenas algumas linhas de listagem de diretórios - suspeite de algum tipo de processo de bifurcação e, na segunda parte, o comando 'type' foi encerrado antes da conclusão da listagem de diretórios?), então usei:

dir > z.txt && type z.txt

que fez - comandos seqüenciais, um é concluído antes do início do segundo.

Infelizmente não existe.

Os aplicativos de console do Windows têm apenas um identificador de saída único. (Bem, existem dois STDOUT, STDERRmas isso não importa aqui). O >redireciona a saída normalmente gravada no identificador do console para um identificador de arquivo.

Se você quiser ter algum tipo de multiplexação, use um aplicativo externo para o qual possa desviar a saída. Esse aplicativo pode gravar em um arquivo e no console novamente.

Um simples aplicativo de console em C # faria o truque:

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

Para usar isso, basta inserir o comando de origem no programa e fornecer o caminho de todos os arquivos nos quais você deseja duplicar a saída. Por exemplo:

dir | CopyToFiles files1.txt files2.txt 

Irá exibir os resultados de dir, bem como armazenar os resultados em files1.txt e files2.txt.

Observe que não há muito (nada!) No caminho do tratamento de erros acima, e o suporte a vários arquivos pode não ser realmente necessário.

Isso funciona, embora seja um pouco feio:

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

É um pouco mais flexível do que algumas das outras soluções, pois funciona declaração por declaração para que você possa usá-lo para acrescentar também. Eu uso isso bastante em arquivos em lotes para registrar e exibir mensagens:

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

Sim, você pode repetir a instrução ECHO (uma vez para a tela e a segunda vez redirecionando para o arquivo de log), mas isso parece igualmente ruim e é um problema de manutenção. Pelo menos dessa maneira, você não precisa fazer alterações nas mensagens em dois lugares.

Observe que _ é apenas um nome de arquivo curto, portanto, você deve excluí-lo no final do seu arquivo em lotes (se estiver usando um arquivo em lotes).

mtee é um pequeno utilitário que funciona muito bem para esse fim. É grátis, a fonte está aberta e funciona.

Você pode encontrá-lo em http://www.commandline.co.uk .

Usada em um arquivo em lotes para exibir a saída E criar um arquivo de log simultaneamente, a sintaxe é assim:

    someprocess | mtee /+ mylogfile.txt

Onde / + significa anexar a saída.

Isso pressupõe que você copiou o mtee para uma pasta que está no PATH, é claro.

Eu gostaria de expandir um pouco a excelente resposta de Saxon Druce .

Como afirmado, você pode redirecionar a saída de um executável no diretório atual da seguinte maneira:

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

No entanto, isso só faz logon stdoutno test.txt. Também não registra stderr.

A solução óbvia seria usar algo como isto:

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

No entanto, isso não funcionará para todos os something.exes. Alguns something.exes interpretam o 2>&1argumento como um argumento e falham. A solução correta é ter apenas apóstrofos ao redor do something.exee seus comutadores e argumentos, da seguinte maneira:

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

Concordo com Brian Rasmussen, a porta unxutils é a maneira mais fácil de fazer isso. Na seção Arquivos em lote de suas páginas de script, Rob van der Woude fornece muitas informações sobre o uso de comandos do MS-DOS e CMD. Eu pensei que ele poderia ter uma solução nativa para o seu problema e, depois de procurar por lá, encontrei o TEE.BAT , que parece ser exatamente isso, uma implementação em lote do tee do MS-DOS. É um arquivo em lotes de aparência bastante complexa e minha inclinação ainda seria usar a porta unxutils.

Se você tiver o cygwin no caminho do ambiente do Windows, poderá usar:

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

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

Isso ajudará a redirecionar STDOUT e STDERR

Eu sei que esse é um tópico muito antigo, mas nas respostas anteriores não há uma implementação completa de um Tee em tempo real escrito em Lote. Minha solução abaixo é um script híbrido Batch-JScript que usa a seção JScript apenas para obter a saída do comando canalizado, mas o processamento dos dados é feito na seção Lote. Essa abordagem tem a vantagem de que qualquer programador em lote pode modificar esse programa para atender a necessidades específicas. Este programa também processa corretamente a saída do comando CLS produzido por outros arquivos em lote, ou seja, limpa a tela quando a saída do comando CLS é detectada.

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

Eu também estava procurando a mesma solução, depois de uma pequena tentativa, consegui isso no Prompt de Comando. Aqui está a minha solução:

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

Ele também captura qualquer comando PAUSE.

Aqui está uma amostra do que eu usei com base em uma das outras respostas

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

Algo assim deve fazer o que você precisa?

%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

enviar saída para o console, anexar ao log do console, excluir saída do comando atual

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

Essa é uma variação de uma resposta anterior do MTS, mas adiciona algumas funcionalidades que podem ser úteis para outras pessoas. Aqui está o método que eu usei:

• Um comando é definido como uma variável, que pode ser usada posteriormente em todo o código, para saída na janela de comando e anexada a um arquivo de log, usando set _Temp_Msg_Cmd=
  • o comando escapou do redirecionamento usando o ^caractere cenoura para que os comandos não sejam avaliados inicialmente
• Um arquivo temporário é criado com um nome de arquivo semelhante ao arquivo em lote que está sendo chamado e %~n0_temp.txtque usa a sintaxe de extensão de parâmetro da linha de comando %~n0 para obter o nome do arquivo em lotes.
• A saída é anexada a um arquivo de log separado %~n0_log.txt

Aqui está a sequência de comandos:

1. As mensagens de saída e erro são enviadas para o arquivo temporário ^> %~n0_temp.txt 2^>^&1
2. O conteúdo do arquivo temporário é então ambos:
   • anexado ao arquivo de log ^& type %~n0_temp.txt ^>^> %~n0_log.txt
   • saída para a janela de comando ^& type %~n0_temp.txt
3. O arquivo temporário com a mensagem é excluído ^& del /Q /F %~n0_temp.txt

Aqui está o exemplo:

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

Dessa forma, o comando pode ser simplesmente acrescentado após comandos posteriores em um arquivo em lotes que parece muito mais limpo:

echo test message %_Temp_Msg_Cmd%

Isso pode ser adicionado ao final de outros comandos também. Tanto quanto posso dizer, funcionará quando as mensagens tiverem várias linhas. Por exemplo, o comando a seguir gera duas linhas se houver uma mensagem de erro:

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

Isso criará um arquivo de log com a data e hora atuais e você poderá usar as linhas do console durante o processo

Eu uso uma sub-rotina em lote com uma instrução "for" para obter a saída do comando, uma linha de cada vez, e ambas gravamos essa linha em um arquivo e a saída no 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 você estiver na CLI, por que não usar um loop FOR para "FAZER" o que quiser:

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

Grande recurso no Windows CMD para loops: https://ss64.com/nt/for_cmd.html A chave aqui é definir os delímetros (delims), que quebrariam cada linha de saída, para nada. Dessa forma, ele não quebrará o padrão de espaço em branco. O% a é uma letra arbitrária, mas é usada na seção "do" para, bem ... fazer algo com os caracteres que foram analisados ​​em cada linha. Nesse caso, podemos usar o "e comercial" (&&) para executar o segundo comando echo para criar-ou-acrescentar (>>) a um arquivo de nossa escolha. Mais seguro para manter essa ordem de comandos DO, caso haja um problema ao escrever o arquivo, pelo menos obteremos o eco no console primeiro. O sinal de arroba (@) na frente do primeiro eco impede o console de mostrar o próprio comando echo e, em vez disso, apenas exibe o resultado do comando que deve exibir os caracteres em% a. Caso contrário, você verá:

eco Volume na unidade [x] é Windows
Volume na unidade [x] é Windows

UPDATE: / F ignora as linhas em branco e a única solução é pré-filtrar a saída, adicionando um caractere a cada linha (talvez com números de linha por meio do comando find). Resolver isso na CLI não é rápido ou bonito. Além disso, eu não incluí o STDERR, então aqui também está capturando erros:

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

Redirecionando mensagens de erro

Os sinais de intercalação (^) estão lá para escapar dos símbolos após eles, porque o comando é uma sequência que está sendo interpretada, ao contrário de dizer, inserindo-a diretamente na linha de comando.

Assim como o unix.

dir | tee a.txt

Funciona No Windows XP, ele requer mksntinstalado.

Ele é exibido no prompt e também é anexado ao arquivo.

A seguir, ajuda se você deseja algo realmente visto na tela - mesmo se o arquivo em lotes foi redirecionado para um arquivo. O dispositivo CON também pode ser usado se for redirecionado para um arquivo

Exemplo:

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

Consulte também uma boa descrição de redirecionamento: http://www.p-dd.com/chapter7-page14.html

Como exibir e redirecionar a saída para um arquivo. Suponha que, se eu usar o comando dos, dir> test.txt, esse comando redirecione a saída para o arquivo test.txt sem exibir os resultados. como escrever um comando para exibir a saída e redirecionar a saída para um arquivo usando o DOS, isto é, prompt de comando do Windows, não no UNIX / LINUX.

Você pode encontrar esses comandos em biterscripting ( http://www.biterscripting.com ) úteis.

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.

Isso funciona em tempo real, mas também é meio feio e o desempenho é lento. Também não foi bem testado:

@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

Uma alternativa é tee stdout para stderr dentro do seu programa:

em java:

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

Em seguida, no seu arquivo de lote dos: java program > log.txt

O stdout irá para o arquivo de log e o stderr (os mesmos dados) será exibido no console.

Eu instalo o perl na maioria das minhas máquinas para obter uma resposta usando o 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 ou dir | perl tee.pl dir.bat

bruto e não testado.

Outra variação é dividir o tubo e redirecionar a saída como desejar.

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

Salve o acima em um arquivo .bat. Ele divide a saída de texto no fluxo de arquivos 1 para o fluxo 3 também, que você pode redirecionar conforme necessário. Nos meus exemplos abaixo, chamei o script acima 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. Clique no link para "setup-x86_.exe"
3. Execute o instalador
4. Na ~ 2ª página, escolha um "espelho" para baixar (procurei um domínio .edu)
5. Eu disse ok para as opções padrão
6. Cygwin terminou rapidamente a instalação
7. Cmd aberto
8. Digite c:\cygwin64\bin\script.exee digite
9. Digite cmde digite
10. Execute seu programa
11. Digite exite digite (sai do cmd.exe do Cygwin)
12. Digite exite digite (sai do script.exe do Cygwin)
13. Veja a saída da tela do seu programa no arquivo de texto chamado "typescript"