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

371

¿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?

Edward Thomson
fuente
63
¡Y por favor deja de llamarlo MSDOS! Las similitudes entre cmd.exe y ese braindead command.com son minúsculas y cada vez más pequeñas.
paxdiablo
Ninguno de estos funciona si uno tiene una aplicación de consola que carga un dll que genera texto. El texto principal de la aplicación se redirige a un archivo, pero el resultado de la dll no se muestra y continúa mostrándose en la ventana de la consola. No he encontrado la manera de capturar el texto de la dll.
Brian Reinhold
1
uno podría simplemente conectar un archivo y usar tail ( stackoverflow.com/questions/187587/… ) en ese archivo
x29a
¿Qué sucede si estoy usando una utilidad de línea de comandos y quiero redirigir la salida a un archivo en el mismo formato exacto que se muestra en la pantalla? Usé youtube-dl para extraer enlaces y podría redirigir la salida a un archivo txt, pero no está formateado como obtendrá en el mensaje, en el archivo viene como una sola línea.
beastboy

Respuestas:

153

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"
Drucia sajona
fuente
8
Esta es la respuesta más cercana: funciona en la instalación predeterminada, ya que PS ya está allí en la mayoría de las máquinas y, especialmente, en los servidores.
Stoleg
1
¡Esta es la mejor respuesta! Simple y funciona "fuera de la caja"
Josh Werts
3
ME GUSTA :) de todos modos {powershell "ping -n 10 localhost | tee test.txt"} demostraría mejor lo que está sucediendo en la fiesta de tee
grenix
44
tenga diren cuenta que en powershell hay un alias Get-ChildItemque no es como el dircomando interno de cmd . Necesitas powershell "cmd /c dir | tee test.txt"si quieres la versión interna de cmd
phuclv
8
para ver toda la salida, no olvides redirigir STDERR a STDOUT con 2>&1, por ejemplonode 2>&1 | tee debug_log.txt
Zhe Hu
132

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.

NSPKUWCExi2pr8wVoGNk
fuente
100
Esto satisface la respuesta, pero genera los datos después de que el comando dir se ha completado en lugar de cuando se producen los datos.
Leigh Riffel
10
funcionará, pero se quedará atascado si el comando espera una entrada de stdin.
Vitim.us
55
Me gusta esta respuesta simple! Descubrí que se necesita un en &lugar de a |para la salida de algunos comandos, como pingo7z.exe
Wes Larson
No funciona para comandos interactivos en lugar de dir. Ejemplo: chkdsk /f c: > c:\Temp.txt | c:\Temp.txt. El archivo de informe del sistema está bloqueado por otro proceso.
Sopalajo de Arrierez
44
@lii re: handle output to stderr- Agregue la 2>&1redirección para que sea así: dir 2>&1 > a.txt & type a.txty debería haber mezclado stderr con stdout.
Jesse Chisholm
97

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

Brian Rasmussen
fuente
17
El enlace apunta a una implementación de Windows del comando Unix tee, por lo que funciona en Windows.
Brian Rasmussen
3
Sí, votando la respuesta y el comentario. De hecho, preferiría CygWin ya que tiene todo, pero algunas personas prefieren herramientas que no sean DLL que pueden elegir.
paxdiablo
3
Muchas de las utilidades de Unix también son portadas por el proyecto GnuWin32, vea gnuwin32.sourceforge.net .
VladV
2
UnxUtils se actualizó por última vez en 2003; GnuWin32 está un poco más actualizado.
quack quijote
99
Si usted, como yo, tuvo problemas para encontrar el teepaquete de GnuWin32 , lo encontrará en gnuwin32.sourceforge.net/packages/coreutils.htm .
Nigel Touch
49

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.

Davor Josipovic
fuente
44
¿Por qué el voto negativo? El 95% de las respuestas aquí tienen algo en común: la salida se redirige solo después de que el comando inicial ha finalizado: lea los comentarios. La utilidad UNIX teegenera en tiempo real. wteeTiene la misma funcionalidad. Si no te importan los errores, te irá bien.
Davor Josipovic
Esa es la única solución que funciona para mí, no tener Powershell> 4.0. ¡Pulgares hacia arriba!
Alex
46

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

Andy Welch
fuente
17
Debería usar en &lugar de &&si desea asegurarse de que el typecomando se ejecute incluso si el dircomando falla. Esto es útil cuando hubo algún tipo de error en su comando y aún desea ver el archivo de registro en la consola. Vea el artículo de Microsoft sobre esto . Sin embargo, esto tiene el problema de %errorlevel%establecerse en el nivel de error de type(que sería 0).
ADTC
25

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.

Daniel Rikowski
fuente
3
teeon * nix también es una aplicación separada, no una redirección en el shell
phuclv
22

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.

Ricardo
fuente
55
Hmm, descargue tee / cygwin por nada o compre MSVS con mi efectivo ganado con esfuerzo para un pequeño programa como ese. Esa es una
pregunta
19
No necesita Visual Studio para compilar eso, las herramientas de línea de comandos son realmente gratuitas. solo google ".net sdk download" para el enlace (el enlace directo parece cambiar pero google siempre parece funcionar).
Kris
13
Visual Studio Express también es gratuito, pero todavía usaría tee para esto.
Brian Rasmussen
77
Cygwin es difícil de instalar. Te voté porque esto es lo que estaba buscando.
Samaursa
1
No creo que esto salga a la consola y los archivos al mismo tiempo ¿verdad?
mjaggard
20

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

MTS
fuente
2
Eso solo es útil si desea mostrar el contenido DESPUÉS de que su proceso se haya ejecutado. Y eso no es un problema difícil de resolver.
Christopher Painter
1
Sí, supongo que esto soluciona un problema ligeramente diferente de lo que preguntaba el póster original.
MTS
1
+1 Así es como siempre lo he hecho. Creo que esta es la respuesta correcta a la pregunta original y debe marcarse como tal. El truco, como sugiere @MTS, es que en realidad escribe en dos archivos: uno que se crea por cada comando / línea (de ahí un solo ">" que se sobrescribe cada vez), y luego escribe esa línea en la pantalla ( tipo ), y finalmente, lo vuelve a escribir y redirige su salida, todo el tiempo APENDIENDO, a su archivo de registro con ">>". Así es como lo he hecho durante años, aunque me encanta el simple " " archivo temporal. Siempre he hecho "tmp.txt" o algo así. Sí, bórralo después.
eduncan911
Este es un buen enfoque, pero tuve problemas con algunos errores que no se capturaron. Sin typeembargo, poner los comandos en líneas separadas (en una subrutina) solucionó eso.
Nate Cook
Justo lo que necesitaba para mi aplicación.
Alan
16

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.

marca
fuente
1
Esto parece esperar hasta que la salida se complete también antes de salir al archivo o la consola.
mellamokb
14

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
ア リ ス タ ー
fuente
Intenté esto cuando construí pyqt5.7 en Windows 10, es bastante lento, la salida de la consola no es en tiempo real, ¿tal vez está almacenada? sin embargo, el archivo de registro parece correcto
Shuman
3
Todo eso está completamente mal. No me funciona para nada. El último comando da 'tee' is not recognized as an internal or external commandpor razones obvias. Con la 2>&1línea interior de cmd, cualquier salida a stderr causa errores de powershell.
Pavel P
Podría ser una referencia al cmdlet PowerShell Tee-Object - technet.microsoft.com/en-us/library/ee177014.aspx
Bernd
9

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.

Steve Crane
fuente
Esa cosa de tee.bat se ve bien. Hope OP mira esto.
Jay
10
Tenga en cuenta que el uso de TEE.BAT se generará una vez que se haya completado el comando, al igual que el ejemplo "dir> a.txt | type a.txt" publicado cerca.
adzm
8

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

 dir > a.txt | tail -f a.txt
jkdba
fuente
77
Si vas a usar Cygwin, viene con tee.
Sr. Llama
7

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

Esto ayudará a redirigir tanto STDOUT como STDERR

rashok
fuente
Esto no funciona Intenté usar esto para iniciar JBoss run.bat y se ahoga durante el inicio y el servidor se congela. Hay problemas con este método ...
djangofan
@raja ashok, no funciona para mí. He intentado python.exe 1> file.txt 2> & 1 | escriba file.txt
neo
4

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");
Aacini
fuente
¿De alguna manera esto podría capturar la salida stderr? Tengo un exe molesto que genera todo en la secuencia de error estándar (es decir, para generar un archivo normalmente lo haría)file.exe 2>output.txt
Mark Deven
Me lo imaginé. Puede hacerlo usando file.exe 2>&1|tee.batcomo se encuentra aquí: superuser.com/questions/452763/…
Mark Deven
4

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.

Koder101
fuente
3

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

¿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
Richard K
fuente
Casi, pero no se muestra simultáneamente: si tiene una tarea de larga ejecución, no obtendrá resultados durante mucho tiempo.
JustAMartin
3

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
Dennis
fuente
8
¿Te gustaría explicar lo que está pasando aquí?
John Demetriou
2

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%

ClearBlueSky85
fuente
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

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

7thSphere
fuente
11
¿No estás llamando al mismo programa dos veces con esto?
elcool
1

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
Cody Barnes
fuente
Hago lo mismo cuando trato de capturar la salida de un comando (IE lo puso dentro de un for), pero luego llamo a mi subfunción estándar para hacer eco en la pantalla y escribir en el registro porque lo uso en todo mi script en reemplazo de usar echo . No estoy seguro de por qué eso recibió un voto negativo de los demás, así que lo voté.
Ben Personick
1

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.

Tuve que preguntar
fuente
1

Justo como Unix.

dir | tee a.txt

Funciona en Windows XP, requiere mksntinstalación.

Se muestra en la solicitud y se agrega al archivo.

user2346926
fuente
0

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


fuente
0

¿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.
PM
fuente
0

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
djangofan
fuente
66
No, no es en tiempo real, espera hasta %MYCOMMAND%que termine y falla en muchos casos. Se salta las líneas vacías, las líneas que comienzan con ;falla con contenidos como <space>/<TAB>, ON, OFFo /?. Pero el resto a veces podría funcionar :-)
jeb
0

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.

El coordinador
fuente
0

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.

DannyK
fuente
0

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
usuario3726414
fuente
-1
  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"
Joseph Hansen
fuente