Affichage de la sortie de l'invite de commande Windows et redirection vers un fichier

Comment puis-je exécuter une application de ligne de commande dans l'invite de commande Windows et afficher la sortie à la fois et la rediriger vers un fichier en même temps?

Si, par exemple, je devais exécuter la commande dir > test.txt, cela redirigerait la sortie vers un fichier appelé test.txtsans afficher les résultats.

Comment pourrais-je écrire une commande pour afficher la sortie et rediriger la sortie vers un fichier dans l'invite de commandes Windows, similaire à la teecommande sous Unix?

Pour développer la réponse de davor , vous pouvez utiliser PowerShell comme ceci:

powershell "dir | tee test.txt"

Si vous essayez de rediriger la sortie d'un exe dans le répertoire courant, vous devez utiliser .\sur le nom de fichier, par exemple:

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

J'ai pu trouver une solution / solution de contournement de la redirection de la sortie vers un fichier puis vers la console:

dir > a.txt | type a.txt

où dir est la commande dont la sortie doit être redirigée, a.txt un fichier où stocker la sortie.

Il y a un port Win32 de la teecommande Unix , qui fait exactement cela. Voir http://unxutils.sourceforge.net/ ou http://getgnuwin32.sourceforge.net/

Regarde ça: wintee

Pas besoin de cygwin.

J'ai rencontré et signalé quelques problèmes.

Vous pouvez également vérifier les non- sorties car il contient tee (et pas besoin de cygwin), mais attention, les EOL de sortie sont de type UNIX ici.

Enfin, si vous avez PowerShell, vous pouvez essayer Tee-Object. Tapez get-help tee-objectdans la console PowerShell pour plus d'informations.

@ tori3852

Je l'ai trouvé

dir > a.txt | type a.txt

n'a pas fonctionné (quelques premières lignes de la liste des répertoires uniquement - suspectez une sorte de bifurcation du processus et la deuxième partie, la commande 'type' s'est terminée avant la fin de la liste des dés?), alors j'ai plutôt utilisé:

dir > z.txt && type z.txt

ce qui a fait - commandes séquentielles, on termine avant le deuxième démarre.

Malheureusement, il n'y a rien de tel.

Les applications de console Windows n'ont qu'une seule poignée de sortie. (Eh bien, il y en a deux STDOUT, STDERRmais cela n'a pas d'importance ici) Le >redirige la sortie normalement écrite dans le handle de console vers un handle de fichier.

Si vous voulez avoir une sorte de multiplexage, vous devez utiliser une application externe vers laquelle vous pouvez détourner la sortie. Cette application peut alors écrire à nouveau dans un fichier et dans la console.

Une simple application console C # ferait l'affaire:

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

Pour l'utiliser, il vous suffit de diriger la commande source dans le programme et de fournir le chemin de tous les fichiers vers lesquels vous souhaitez dupliquer la sortie. Par exemple:

dir | CopyToFiles files1.txt files2.txt 

Affiche les résultats de dir et stocke les résultats dans files1.txt et files2.txt.

Notez qu'il n'y a pas beaucoup (quoi que ce soit!) Dans la manière de gérer les erreurs ci-dessus, et la prise en charge de plusieurs fichiers peut ne pas être réellement nécessaire.

Cela fonctionne, bien que ce soit un peu moche:

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

Il est un peu plus flexible que certaines des autres solutions, en ce sens qu'il fonctionne déclaration par déclaration afin que vous puissiez également l'utiliser pour l'ajouter. J'utilise cela un peu dans des fichiers batch pour enregistrer et afficher des messages:

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

Oui, vous pouvez simplement répéter l'instruction ECHO (une fois pour l'écran et la deuxième fois redirigée vers le fichier journal), mais cela semble tout aussi mauvais et est un peu un problème de maintenance. Au moins de cette façon, vous n'avez pas à modifier les messages à deux endroits.

Notez que _ n'est qu'un nom de fichier court, vous devrez donc vous assurer de le supprimer à la fin de votre fichier de commandes (si vous utilisez un fichier de commandes).

mtee est un petit utilitaire qui fonctionne très bien à cet effet. C'est gratuit, la source est ouverte et ça marche.

Vous pouvez le trouver sur http://www.commandline.co.uk .

Utilisée dans un fichier batch pour afficher la sortie ET créer un fichier journal simultanément, la syntaxe ressemble à ceci:

    someprocess | mtee /+ mylogfile.txt

Où / + signifie ajouter la sortie.

Cela suppose que vous avez copié mtee dans un dossier qui se trouve dans le PATH, bien sûr.

Je voudrais développer un peu l' excellente réponse de Saxon Druce .

Comme indiqué, vous pouvez rediriger la sortie d'un exécutable dans le répertoire courant comme ceci:

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

Cependant, cela se connecte uniquement stdoutà test.txt. Il ne se connecte pas également stderr.

La solution évidente serait d'utiliser quelque chose comme ceci:

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

Cependant, cela ne fonctionnera pas pour tous something.exe. Certains something.exes interpréteront le 2>&1comme un argument et échoueront. La bonne solution consiste à avoir uniquement des apostrophes autour du something.exeet de ses commutateurs et arguments, comme ceci:

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

Je suis d'accord avec Brian Rasmussen, le port unxutils est le moyen le plus simple de le faire. Dans la section Fichiers batch de ses pages de script, Rob van der Woude fournit une mine d'informations sur l'utilisation des commandes MS-DOS et CMD. Je pensais qu'il pourrait avoir une solution native à votre problème et après avoir fouillé là-bas, j'ai trouvé TEE.BAT , qui semble être juste cela, une implémentation de langage batch MS-DOS de tee. C'est un fichier batch d'aspect assez complexe et mon inclination serait toujours d'utiliser le port unxutils.

Si vous avez cygwin dans votre chemin d'accès à l'environnement Windows, vous pouvez utiliser:

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

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

Cela aidera à rediriger STDOUT et STDERR

Je sais que c'est un sujet très ancien, mais dans les réponses précédentes, il n'y a pas d'implémentation complète d'un Tee en temps réel écrit en batch. Ma solution ci-dessous est un script hybride Batch-JScript qui utilise la section JScript juste pour obtenir la sortie de la commande canalisée, mais le traitement des données se fait dans la section Batch. Cette approche présente l'avantage que tout programmeur Batch peut modifier ce programme pour répondre à des besoins spécifiques. Ce programme traite également correctement la sortie de la commande CLS produite par d'autres fichiers Batch, c'est-à-dire qu'il efface l'écran lorsque la sortie de la commande CLS est détectée.

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

Je cherchais également la même solution, après un petit essai, j'ai réussi à y parvenir dans l'invite de commande. Voici ma solution:

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

Il capture même également n'importe quelle commande PAUSE.

Voici un échantillon de ce que j'ai utilisé sur la base d'une des autres réponses

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

Quelque chose comme ça devrait faire ce dont vous avez besoin?

%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

envoyer la sortie à la console, ajouter au journal de la console, supprimer la sortie de la commande actuelle

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

Il s'agit d'une variante d'une réponse précédente de MTS, mais elle ajoute des fonctionnalités qui pourraient être utiles à d'autres. Voici la méthode que j'ai utilisée:

• Une commande est définie comme une variable, qui peut être utilisée plus tard dans le code, pour sortir dans la fenêtre de commande et l'ajouter à un fichier journal, en utilisant set _Temp_Msg_Cmd=
  • la commande a échappé à la redirection en utilisant le ^caractère carotte afin que les commandes ne soient pas évaluées initialement
• Un fichier temporaire est créé avec un nom de fichier similaire au fichier de commandes en cours d'exécution appelé %~n0_temp.txtqui utilise la syntaxe d'extension de paramètre de ligne de commande %~n0 pour obtenir le nom du fichier de commandes.
• La sortie est ajoutée à un fichier journal distinct %~n0_log.txt

Voici la séquence de commandes:

1. Les messages de sortie et d'erreur sont envoyés dans le fichier temporaire ^> %~n0_temp.txt 2^>^&1
2. Le contenu du fichier temporaire est alors à la fois:
   • annexé au fichier journal ^& type %~n0_temp.txt ^>^> %~n0_log.txt
   • sortie dans la fenêtre de commande ^& type %~n0_temp.txt
3. Le fichier temporaire avec le message est supprimé ^& del /Q /F %~n0_temp.txt

Voici l'exemple:

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 cette façon, la commande peut simplement être ajoutée après des commandes ultérieures dans un fichier de commandes qui semble beaucoup plus propre:

echo test message %_Temp_Msg_Cmd%

Cela peut également être ajouté à la fin d'autres commandes. Pour autant que je sache, cela fonctionnera lorsque les messages auront plusieurs lignes. Par exemple, la commande suivante génère deux lignes en cas de message d'erreur:

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

Cela va créer un fichier journal avec le datetime actuel et vous pouvez les lignes de console pendant le processus

J'utilise un sous-programme batch avec une instruction "for" pour obtenir la sortie de la commande une ligne à la fois et à la fois écrire cette ligne dans un fichier et la sortir sur la 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

Si vous êtes sur la CLI, pourquoi ne pas utiliser une boucle FOR pour "FAIRE" tout ce que vous voulez:

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

Grande ressource sur Windows CMD pour les boucles: https://ss64.com/nt/for_cmd.html La clé ici est de définir les délimètres (délimitations), qui briseraient chaque ligne de sortie, à rien. De cette façon, il ne se cassera pas sur la valeur par défaut de l'espace blanc. Le% a est une lettre arbitraire, mais il est utilisé dans la section "faire" pour, eh bien ... faire quelque chose avec les caractères qui ont été analysés à chaque ligne. Dans ce cas, nous pouvons utiliser les esperluettes (&&) pour exécuter la 2e commande echo pour créer ou ajouter (>>) à un fichier de notre choix. Plus sûr de conserver cet ordre de commandes DO en cas de problème d'écriture du fichier, nous aurons au moins l'écho sur la console en premier. Le signe at (@) devant le premier écho empêche la console d'afficher la commande écho elle-même et affiche simplement le résultat de la commande qui consiste à afficher les caractères dans% a. Sinon, vous verriez:

echo Volume dans le lecteur [x] est Windows
Volume dans le lecteur [x] est Windows

MISE À JOUR: / F ignore les lignes vides et le seul correctif consiste à pré-filtrer la sortie en ajoutant un caractère à chaque ligne (peut-être avec des numéros de ligne via la commande find). Résoudre cela dans CLI n'est pas rapide ou joli. De plus, je n'ai pas inclus STDERR, alors voici également les erreurs de capture:

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

Redirection des messages d'erreur

Les carets (^) sont là pour échapper aux symboles après eux, car la commande est une chaîne qui est interprétée, par opposition à dire, la saisir directement sur la ligne de commande.

Tout comme unix.

dir | tee a.txt

Fonctionne sous Windows XP, il nécessite mksntinstallé.

Il s'affiche à l'invite et s'ajoute au fichier.

La suite est utile si vous voulez que quelque chose soit vraiment visible à l'écran - même si le fichier de commandes a été redirigé vers un fichier. Le périphérique CON peut également être utilisé s'il est redirigé vers un fichier

Exemple:

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

Voir également une bonne description de la redirection: http://www.p-dd.com/chapter7-page14.html

Comment afficher et rediriger la sortie vers un fichier. Supposons que si j'utilise la commande dos, dir> test.txt, cette commande redirige la sortie vers le fichier test.txt sans afficher les résultats. comment écrire une commande pour afficher la sortie et rediriger la sortie vers un fichier en utilisant DOS, c'est-à-dire l'invite de commande Windows, pas sous UNIX / LINUX.

Vous pouvez trouver ces commandes dans le biterscripting ( http://www.biterscripting.com ) utiles.

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.

Cela fonctionne en temps réel mais est également très laid et les performances sont lentes. Pas bien testé non plus:

@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

Une alternative est de té stdout à stderr dans votre programme:

en java:

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

Ensuite, dans votre fichier batch: java program > log.txt

Le stdout ira au fichier journal et le stderr (mêmes données) s'affichera sur la console.

J'installe perl sur la plupart de mes machines donc une réponse en utilisant 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

brut et non testé.

Une autre variante consiste à diviser le tuyau, puis à rediriger la sortie comme vous le souhaitez.

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

Enregistrez ce qui précède dans un fichier .bat. Il divise également la sortie texte de filestream 1 en filestream 3, que vous pouvez rediriger si nécessaire. Dans mes exemples ci-dessous, j'ai appelé le script ci-dessus 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. Cliquez sur le lien pour "setup-x86_.exe"
3. Exécutez le programme d'installation
4. Sur ~ 2ème page, choisissez un "miroir" à télécharger (j'ai cherché un domaine .edu)
5. J'ai dit ok aux options standard
6. Cygwin a rapidement terminé l'installation
7. Ouvrir cmd
8. Type c:\cygwin64\bin\script.exe et entrez
9. Type cmd et entrez
10. Exécutez votre programme
11. Tapez exitet entrez (quitte Cygwin's cmd.exe)
12. Tapez exitet entrez (quitte le script.exe de Cygwin)
13. Voir la sortie d'écran de votre programme dans un fichier texte appelé "dactylographié"