Mostrar el resultado del símbolo del sistema de Windows y redirigirlo a un archivo

¿Cómo puedo ejecutar una aplicación de línea de comandos en el símbolo del sistema de Windows y hacer que la salida se muestre y se redirija a un archivo al mismo tiempo?

Si, por ejemplo, ejecutara el comando dir > test.txt, esto redirigiría la salida a un archivo llamado test.txtsin mostrar los resultados.

¿Cómo podría escribir un comando para mostrar la salida y redirigir la salida a un archivo en el símbolo del sistema de Windows, similar al teecomando en Unix?

Para ampliar la respuesta de davor , puede usar PowerShell de esta manera:

powershell "dir | tee test.txt"

Si está intentando redirigir la salida de un exe en el directorio actual, debe usar .\el nombre del archivo, por ejemplo:

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

Pude encontrar una solución / solución alternativa para redirigir la salida a un archivo y luego a la consola:

dir > a.txt | type a.txt

donde dir es el comando cuya salida necesita ser redirigida, a.txt un archivo donde almacenar la salida.

Hay un puerto Win32 del teecomando Unix , que hace exactamente eso. Ver http://unxutils.sourceforge.net/ o http://getgnuwin32.sourceforge.net/

Mira esto: invierno

No hay necesidad de cygwin.

Sin embargo, encontré e informé algunos problemas.

También puede verificar unxutils porque contiene tee (y no necesita cygwin), pero tenga en cuenta que los EOL de salida son como UNIX aquí.

Por último, pero no menos importante, si tiene PowerShell, puede probar Tee-Object. Escriba get-help tee-objecten la consola de PowerShell para obtener más información.

@ tori3852

encontre eso

dir > a.txt | type a.txt

no funcionó (solo las primeras líneas de la lista de directorios: sospecha algún tipo de bifurcación de proceso y la segunda parte, ¿el comando 'tipo' terminó antes de que se completara la lista de direcciones?), así que en su lugar utilicé:

dir > z.txt && type z.txt

que hizo - comandos secuenciales, uno completa antes de que comience el segundo.

Lamentablemente no existe tal cosa.

Las aplicaciones de consola de Windows solo tienen un único controlador de salida. (Bueno, hay dos STDOUT, STDERRpero no importa aquí) >Redirige la salida que normalmente se escribe en el controlador de la consola a un controlador de archivo.

Si desea tener algún tipo de multiplexación, debe usar una aplicación externa a la que pueda desviar la salida. Esta aplicación puede volver a escribir en un archivo y en la consola.

Una simple aplicación de consola C # haría el truco:

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 esto, simplemente canalice el comando de origen en el programa y proporcione la ruta de los archivos a los que desea duplicar la salida. Por ejemplo:

dir | CopyToFiles files1.txt files2.txt 

Mostrará los resultados de dir y almacenará los resultados tanto en files1.txt como en files2.txt.

Tenga en cuenta que no hay mucho (¡nada!) En la forma de manejo de errores anterior, y es posible que no sea necesario admitir múltiples archivos.

Esto funciona, aunque es un poco feo:

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

Es un poco más flexible que algunas de las otras soluciones, ya que funciona declaración por declaración, por lo que también puede usarlo para agregar. Lo uso bastante en los archivos por lotes para registrar y mostrar mensajes:

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

Sí, podría repetir la declaración de ECHO (una vez para la pantalla y la segunda redirigiendo al archivo de registro), pero eso parece igual de malo y es un problema de mantenimiento. Al menos de esta manera, no tiene que realizar cambios en los mensajes en dos lugares.

Tenga en cuenta que _ es solo un nombre de archivo corto, por lo que deberá asegurarse de eliminarlo al final de su archivo por lotes (si está utilizando un archivo por lotes).

mtee es una pequeña utilidad que funciona muy bien para este propósito. Es gratis, la fuente está abierta y simplemente funciona.

Puede encontrarlo en http://www.commandline.co.uk .

Utilizado en un archivo por lotes para mostrar la salida Y crear un archivo de registro simultáneamente, la sintaxis se ve así:

    someprocess | mtee /+ mylogfile.txt

Donde / + significa agregar salida.

Esto supone que ha copiado mtee en una carpeta que está en la RUTA, por supuesto.

Me gustaría ampliar un poco la excelente respuesta de Saxon Druce .

Como se indicó, puede redirigir la salida de un ejecutable en el directorio actual de esta manera:

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

Sin embargo, esto sólo se registra stdouta test.txt. Tampoco registra stderr.

La solución obvia sería usar algo como esto:

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

Sin embargo, esto no funcionará para todos los something.exes. Algunos something.exes interpretarán el 2>&1argumento como un argumento y fallarán. La solución correcta es, en cambio, solo tener apóstrofos alrededor de something.exey sus interruptores y argumentos, así:

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

Estoy de acuerdo con Brian Rasmussen, el puerto unxutils es la forma más fácil de hacer esto. En la sección de Batch Files de sus páginas de scripting, Rob van der Woude proporciona una gran cantidad de información sobre el uso de comandos MS-DOS y CMD. Pensé que podría tener una solución nativa a su problema y después de cavar por allí encontré TEE.BAT , que parece ser solo eso, una implementación de tee en lenguaje MS-DOS. Es un archivo por lotes de aspecto bastante complejo y mi inclinación sería seguir utilizando el puerto unxutils.

Si tiene cygwin en la ruta del entorno de Windows, puede usar:

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

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

Esto ayudará a redirigir tanto STDOUT como STDERR

Sé que este es un tema muy antiguo, pero en respuestas anteriores no hay una implementación completa de un Tee en tiempo real escrito en Batch. Mi solución a continuación es un script híbrido Batch-JScript que usa la sección JScript solo para obtener la salida del comando canalizado, pero el procesamiento de los datos se realiza en la sección Batch. Este enfoque tiene la ventaja de que cualquier programador de Batch puede modificar este programa para satisfacer necesidades específicas. Este programa también procesa correctamente la salida del comando CLS producido por otros archivos Batch, es decir, borra la pantalla cuando se detecta la salida 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");

También estaba buscando la misma solución, después de un pequeño intento, pude lograrlo con éxito en el Símbolo del sistema. Aquí está mi solución:

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

Incluso captura cualquier comando PAUSA también.

Aquí hay una muestra de lo que he usado basado en una de las otras respuestas

@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 como esto debería hacer lo que necesitas?

%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 salida a la consola, agregar al registro de la consola, eliminar la salida del comando actual

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

Esta es una variación de una respuesta anterior de MTS, sin embargo, agrega algunas funcionalidades que podrían ser útiles para otros. Aquí está el método que utilicé:

• Un comando se establece como una variable, que se puede usar más adelante en todo el código, para enviarlo a la ventana de comandos y agregarlo a un archivo de registro, usando set _Temp_Msg_Cmd=
  • el comando ha escapado de la redirección utilizando el ^carácter de zanahoria para que los comandos no se evalúen inicialmente
• Se crea un archivo temporal con un nombre de archivo similar al archivo por lotes que se ejecuta %~n0_temp.txtque utiliza la sintaxis de extensión de parámetro de línea de comando %~n0 para obtener el nombre del archivo por lotes.
• La salida se agrega a un archivo de registro separado %~n0_log.txt

Aquí está la secuencia de comandos:

1. Los mensajes de salida y error se envían al archivo temporal. ^> %~n0_temp.txt 2^>^&1
2. El contenido del archivo temporal es entonces ambos:
   • anexado al archivo de registro ^& type %~n0_temp.txt ^>^> %~n0_log.txt
   • salida a la ventana de comando ^& type %~n0_temp.txt
3. El archivo temporal con el mensaje se elimina. ^& del /Q /F %~n0_temp.txt

Aquí está el ejemplo:

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

De esta manera, el comando simplemente se puede agregar después de comandos posteriores en un archivo por lotes que se ve mucho más limpio:

echo test message %_Temp_Msg_Cmd%

Esto se puede agregar al final de otros comandos también. Por lo que puedo decir, funcionará cuando los mensajes tengan varias líneas. Por ejemplo, el siguiente comando genera dos líneas si hay un mensaje de error:

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

Esto creará un archivo de registro con la fecha y hora actual y podrá ver las líneas de la consola durante el proceso.

Utilizo una subrutina por lotes con una declaración "for" para obtener el comando de salida de una línea a la vez y ambos escriben esa línea en un archivo y la envían a la consola.

@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

Si estás en la CLI, ¿por qué no usar un bucle FOR para "HACER" lo que quieras?

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

Gran recurso en Windows CMD para bucles: https://ss64.com/nt/for_cmd.html La clave aquí es establecer los delimitadores (delimitaciones), que romperían cada línea de salida, a nada. De esta manera, no se romperá con el espacio en blanco predeterminado. El% a es una letra arbitraria, pero se usa en la sección "hacer" para, bueno ... hacer algo con los caracteres que se analizaron en cada línea. En este caso, podemos usar los símbolos de unión (&&) para ejecutar el segundo comando echo para crear o agregar (>>) a un archivo de nuestra elección. Es más seguro mantener este orden de comandos de OD en caso de que haya un problema al escribir el archivo, al menos primero conseguiremos el eco en la consola. El signo at (@) delante del primer eco evita que la consola muestre el comando echo en sí, y en su lugar solo muestra el resultado del comando que es mostrar los caracteres en% a. De lo contrario, verías:

echo El volumen en la unidad [x] es Windows El
volumen en la unidad [x] es Windows

ACTUALIZACIÓN: / F omite las líneas en blanco y la única solución es prefiltrar la salida agregando un carácter a cada línea (tal vez con números de línea a través del comando find). Resolver esto en CLI no es rápido ni bonito. Además, no incluí STDERR, así que aquí también estoy capturando errores:

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

Redirigir mensajes de error

Los puntos (^) están ahí para escapar de los símbolos que están detrás de ellos, porque el comando es una cadena que se está interpretando, en lugar de decir, ingresándola directamente en la línea de comandos.

Justo como Unix.

dir | tee a.txt

Funciona en Windows XP, requiere mksntinstalación.

Se muestra en la solicitud y se agrega al archivo.

Lo siguiente ayuda si desea ver realmente algo en la pantalla, incluso si el archivo por lotes se redirigió a un archivo. El dispositivo CON también puede usarse si se redirige a un archivo

Ejemplo:

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

Ver también una buena descripción de redirección: http://www.p-dd.com/chapter7-page14.html

¿Cómo se visualiza y redirige la salida a un archivo? Supongamos que si uso el comando dos, dir> test.txt, este comando redirigirá la salida al archivo test.txt sin mostrar los resultados. cómo escribir un comando para mostrar la salida y redirigir la salida a un archivo usando DOS, es decir, símbolo del sistema de Windows, no en UNIX / LINUX.

Puede encontrar estos comandos en biterscripting ( http://www.biterscripting.com ) útiles.

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.

Esto funciona en tiempo real, pero también es un poco feo y el rendimiento es lento. Tampoco bien probado:

@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

Una alternativa es tee stdout to stderr dentro de su programa:

en java:

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

Luego, en su dos batchfile: java program > log.txt

El stdout irá al archivo de registro y el stderr (los mismos datos) se mostrarán en la consola.

Instalo perl en la mayoría de mis máquinas, así que una respuesta 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

crudo y no probado.

Otra variación es dividir la tubería y luego redirigir la salida como desee.

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

Guarde lo anterior en un archivo .bat. Divide la salida de texto en filestream 1 a filestream 3 también, que puede redirigir según sea necesario. En mis ejemplos a continuación, llamé al script anterior 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. Haga clic en el enlace para "setup-x86_.exe"
3. Ejecuta el instalador
4. En ~ 2ª página, elija un "espejo" para descargar (busqué un dominio .edu)
5. Dije ok a las opciones estándar
6. Cygwin terminó de instalar rápidamente
7. Cmd abierto
8. Escribe c:\cygwin64\bin\script.exey entra
9. Escribe cmdy entra
10. Ejecute su programa
11. Escriba exite ingrese (sale del cmd.exe de Cygwin)
12. Escriba exite ingrese (sale de Cygwin's script.exe)
13. Vea la salida de pantalla de su programa en un archivo de texto llamado "mecanografiado"