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

371

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?

Edward Thomson
fonte
63
E por favor, pare de chamá-lo de MSDOS! As semelhanças entre o cmd.exe e o braindead command.com são minúsculas e cada vez menores.
28409
Nenhuma delas funciona se alguém tiver um aplicativo de console que carrega uma dll que gera texto. O texto principal do aplicativo é redirecionado para um arquivo, mas a saída da dll não é e continua sendo exibida na janela do console. Não encontrei nenhuma maneira de capturar o texto da DLL.
Brian Reinhold
11
um poderia ainda apenas tubulação em um rabo de arquivo e uso ( stackoverflow.com/questions/187587/... ) nesse arquivo
x29a
E se eu estiver usando um utilitário de linha de comando e quiser redirecionar a saída para um arquivo exatamente no mesmo formato exibido na tela, usei o youtube-dl para extrair links e poderia redirecionar a saída para um arquivo txt, mas não está formatado como você receberá o prompt, no arquivo está chegando como uma única linha.
beastboy

Respostas:

153

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"
Saxon Druce
fonte
8
Essa é a resposta mais próxima: funciona na instalação padrão, pois o PS já existe na maioria das máquinas e, principalmente, nos servidores.
Stoleg
11
Esta é a melhor resposta! Simples e obras "fora da caixa"
Josh Werts
3
COMO ELE :) de qualquer maneira { "ping -n 10 localhost | tee test.txt" powershell} iria demonstrar melhor o que está acontecendo no tee do partido
grenix
4
note que dirno powershell existe um alias para o Get-ChildItemqual não é como o dircomando interno do cmd . Você precisa powershell "cmd /c dir | tee test.txt"se quiser que o cmd interno versão
phuclv
8
para ver toda a saída, não se esqueça de redirecionar STDERR para STDOUT com 2>&1, por exemplonode 2>&1 | tee debug_log.txt
Zhe Hu
132

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.

NSPKUWCExi2pr8wVoGNk
fonte
100
Isso satisfaz a resposta, mas gera os dados após a conclusão do comando dir, e não quando os dados são produzidos.
21430 Leigh Riffel
10
funcionará, mas você ficará preso se o comando aguardar uma entrada de stdin.
Vitim.us
5
Eu gosto desta resposta simples! Descobri que um &em vez de um |é necessário para a saída de alguns comandos, como pingou7z.exe
Wes Larson
Não está funcionando para comandos interativos em vez de dir. Exemplo: chkdsk /f c: > c:\Temp.txt | c:\Temp.txt. O arquivo de relatório do sistema está bloqueado por outro processo.
Sopalajo de Arrierez 08/07
4
@lii re: handle output to stderr- Adicione o 2>&1redirecionamento para que fique assim: dir 2>&1 > a.txt & type a.txte você deve ter stderr misturado com stdout.
Jesse Chisholm
97

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

Brian Rasmussen
fonte
17
O link aponta para uma implementação do comando Unix no Windows, por isso funciona no Windows.
Brian Rasmussen
3
Sim, votando na resposta e no comentário. Na verdade, eu prefiro o CygWin, pois ele tem tudo, mas algumas pessoas preferem ferramentas não DLL que podem escolher.
28409
3
Muitos utilitários Unix também são portados pelo projeto GnuWin32, consulte gnuwin32.sourceforge.net .
VladV
2
O UnxUtils foi atualizado pela última vez em 2003; O GnuWin32 é um pouco mais atualizado.
quack quixote
9
Se você, como eu, lutou para encontrar o teepacote do GnuWin32 , poderá encontrá-lo em gnuwin32.sourceforge.net/packages/coreutils.htm .
Nigel Touch
49

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.

Davor Josipovic
fonte
4
Por que o voto negativo? 95% das respostas aqui têm uma coisa em comum: a saída é redirecionada somente após a conclusão do comando inicial: leia os comentários. O utilitário UNIX teeproduz em tempo real. wteetem a mesma funcionalidade. Se você não se importa com os bugs, tudo ficará bem.
Davor Josipovic
Essa é a única solução que funciona para mim, sem o PowerShell> 4.0. Afirmativo!
2028 Alex
46

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

Andy Welch
fonte
17
Você deve usar, em &vez de, &&se quiser garantir que o typecomando seja executado, mesmo se o dircomando falhar. Isso é útil quando houve alguma forma de erro em seu comando e você ainda deseja ver o arquivo de log no console. Veja o artigo da Microsoft sobre isso . No entanto, isso tem o problema de %errorlevel%ser definido como o nível de erro de type(que seria 0).
ADTC
25

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.

Daniel Rikowski
fonte
3
teeem * nix também é um aplicativo separado, e não algum redirecionamento no shell
phuclv
22

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.

Richard
fonte
5
Hmm, faça o download do tee / cygwin por nada ou compre o MSVS com meu dinheiro suado para um pequeno programa como esse? Essa é uma pergunta difícil :-) #
2800
19
Você não precisa do visual studio para compilar isso, as ferramentas de linha de comando são realmente gratuitas. apenas google ".net sdk download" para o link (o link direto parece mudar, mas o google sempre parece funcionar).
Kris
13
O Visual Studio Express também é gratuito, mas eu ainda usaria o tee para isso.
Brian Rasmussen
7
O cygwin é uma tarefa difícil de instalar. Votos positivos para você, porque era isso que eu estava procurando.
Samaursa
11
Eu não acho que isso gera para o console e os arquivos ao mesmo tempo?
Mjaggard 7/11
20

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

MTS
fonte
2
Isso só é útil se você deseja exibir o conteúdo APÓS o processo ter sido executado. E isso não é um problema difícil de resolver.
25411 Christopher Christopher Pintor
11
Sim, acho que isso resolve um problema ligeiramente diferente do que o pôster original estava perguntando.
MTS
11
+1 É assim que eu sempre faço. Acredito que esta é a resposta correta para a pergunta original e deve ser marcada como tal. O truque, como o @MTS sugere, é que você realmente escreve em dois arquivos: um que é criado por cada comando / linha (portanto, um único ">" que sobrescreve cada vez) e, em seguida, você digita essa linha na tela ( type ) e, finalmente, você digita novamente e redireciona sua saída, por todo o longo ANEXO, para o seu arquivo de log com ">>". É assim que eu faço isso há anos, apesar de adorar o simples " " arquivo temp. Eu sempre fiz "tmp.txt" ou algo assim. Sim, exclua depois.
eduncan911
Essa é uma boa abordagem, mas tive problemas com alguns erros ao não serem capturados. Colocar os typecomandos em linhas separadas (em uma sub-rotina) corrigiu isso.
Nate Cook
Apenas o que eu precisava para a minha aplicação.
Alan
16

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.

Marca
fonte
11
Isso parece esperar até que a saída seja concluída também antes de gerar saída para o arquivo ou console.
precisa saber é o seguinte
14

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
ア リ ス タ
fonte
Eu tentei isso ao criar pyqt5.7 no windows 10, é bastante lento, a saída do console não é em tempo real, talvez esteja em buffer? o arquivo de log parece correto embora
Shuman
3
Tudo isso está completamente errado. Isso não funciona para mim. O último comando fornece 'tee' is not recognized as an internal or external commandpor razões óbvias. Com a 2>&1linha cmd interna, qualquer saída para stderr causa erros no PowerShell.
Pavel P
Poderia ser uma referência para o cmdlet Tee-Object PowerShell - technet.microsoft.com/en-us/library/ee177014.aspx
Bernd
9

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.

Steve Crane
fonte
Essa coisa tee.bat parece legal. Espero que o OP verifique isso.
Jay Jay
10
Observe que o uso de TEE.BAT será gerado após a conclusão do comando, assim como o exemplo "dir> a.txt | type a.txt" publicado nas proximidades.
adzm
8

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

 dir > a.txt | tail -f a.txt
jkdba
fonte
7
Se você vai usar o Cygwin, ele vem com o tee.
Mr. Llama
7

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

Isso ajudará a redirecionar STDOUT e STDERR

rashok
fonte
Isso não funciona. Tentei usar isso para iniciar o JBoss run.bat e ele engasga durante a inicialização e o servidor congela. Há problemas com este método ...
djangofan
@ Raja Ashok, não funciona para mim. Eu tentei python.exe 1> arquivo.txt 2> & 1 | tipo file.txt
neo
4

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");
Aacini
fonte
De alguma forma isso poderia capturar a saída stderr? Eu tenho um exe irritante que gera tudo no fluxo de erro padrão (ou seja, para gerar um arquivo normalmente, você fariafile.exe 2>output.txt
Mark Deven
Eu descobri. Você pode fazê-lo usando o file.exe 2>&1|tee.batque é encontrado aqui: superuser.com/questions/452763/…
Mark Deven
4

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.

Koder101
fonte
3

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
)
Ed Radke
fonte
3

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
Richard K
fonte
Quase, mas não é exibido simultaneamente - se você tiver uma tarefa de longa execução, não obterá resultados por muito tempo.
JustAMartin
3

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
Dennis
fonte
8
gostaria de explicar o que está acontecendo aqui?
John Demetriou
2

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%

ClearBlueSky85
fonte
1
@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

7thSphere
fonte
11
você não está chamando o mesmo programa duas vezes com isso?
elcool
1

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
Cody Barnes
fonte
Eu faço o mesmo ao tentar capturar a saída de um comando (o IE coloca dentro de um for), mas depois chamo minha subfunção padrão para ecoar na tela e gravar no log porque a uso em todo o script em vez de usar echo . Não sei por que isso recebeu um voto negativo de outros, então eu o votei.
quer
1

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.

Tinha que perguntar
fonte
1

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.

user2346926
fonte
0

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


fonte
0

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.
PM
fonte
0

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
djangofan
fonte
6
Não, não é em tempo real, ele espera até %MYCOMMAND%terminar e falha em muitos casos. Ela ignora as linhas em branco, as linhas começando com ;falha com conteúdo como <space>/<TAB>, ON, OFFou /?. Mas o resto às vezes pode funcionar :-)
jeb
0

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.

O coordenador
fonte
0

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.

DannyK
fonte
0

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
user3726414
fonte
-1
  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"
Joseph Hansen
fonte