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


371

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?


63
Et arrêtez de l'appeler MSDOS! Les similitudes entre cmd.exe et braindead command.com sont minuscules et deviennent plus petites.
paxdiablo


Rien de tout cela ne fonctionne si l'on a une application console qui charge une DLL qui génère du texte. Le texte de l'application principale est redirigé vers un fichier, mais la sortie de la DLL ne s'affiche pas et continue d'être affichée dans la fenêtre de la console. Je n'ai trouvé aucun moyen de capturer le texte de la DLL.
Brian Reinhold du

1
on pourrait toujours simplement diriger dans un fichier et utiliser tail ( stackoverflow.com/questions/187587/… ) sur ce fichier
x29a

Et si j'utilise un utilitaire de ligne de commande et que je souhaite rediriger la sortie vers un fichier au même format que celui affiché à l'écran, j'ai utilisé youtube-dl pour extraire les liens et je pouvais rediriger la sortie vers un fichier txt, mais ce n'est pas formaté comme vous obtiendrez dans l'invite, dans le fichier sa venue comme une seule ligne.
beastboy

Réponses:


153

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"

8
C'est la réponse la plus proche: cela fonctionne sur l'installation par défaut, car PS est déjà là sur la plupart des machines et, en particulier, des serveurs.
Stoleg

1
C'est la meilleure réponse! Simple et fonctionne "hors de la boîte"
Josh Werts

3
AIMEZ-LE :) de toute façon {powershell "ping -n 10 localhost | tee test.txt"} montrerait mieux ce qui se passe sur le tee party
grenix

4
notez que dirdans powershell est un alias Get-ChildItemqui n'est pas comme la dircommande interne de cmd . Vous avez besoin powershell "cmd /c dir | tee test.txt"si vous voulez la version interne de cmd
phuclv

8
pour voir toute la sortie, n'oubliez pas de rediriger STDERR vers STDOUT avec 2>&1, par exemplenode 2>&1 | tee debug_log.txt
Zhe Hu

132

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

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


100
Cela satisfait la réponse, mais génère les données une fois la commande dir terminée plutôt que lorsque les données sont produites.
Leigh Riffel

10
cela fonctionnera, mais vous serez bloqué si la commande attend une entrée de stdin.
Vitim.us

5
J'aime cette réponse simple! J'ai trouvé qu'un &au lieu d'un |est nécessaire pour la sortie de certaines commandes, comme pingou7z.exe
Wes Larson

Ne fonctionne pas pour les commandes interactives au lieu de dir. Exemple: chkdsk /f c: > c:\Temp.txt | c:\Temp.txt. Le fichier de rapport système est verrouillé par un autre processus.
Sopalajo de Arrierez

4
@lii re: handle output to stderr- Ajoutez la 2>&1redirection pour qu'elle ressemble à ceci: dir 2>&1 > a.txt & type a.txtet vous devriez avoir mélangé stderr avec stdout.
Jesse Chisholm

97

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


17
Le lien pointe vers une implémentation Windows du tee de commande Unix, donc cela fonctionne sur Windows.
Brian Rasmussen

3
Ouais, voter la réponse et le commentaire. Je préfère en fait CygWin car il a tout, mais certaines personnes préfèrent les outils non DLL qu'ils peuvent choisir.
paxdiablo

3
De nombreux utilitaires Unix sont également portés par le projet GnuWin32, voir gnuwin32.sourceforge.net .
VladV

2
UnxUtils a été mis à jour pour la dernière fois en 2003; GnuWin32 est un peu plus à jour.
Quack Quichotte

9
Si vous, comme moi, avez eu du mal à trouver le teepackage de GnuWin32 , vous le trouverez dans gnuwin32.sourceforge.net/packages/coreutils.htm .
Nigel Touch

49

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.


4
Pourquoi le vote négatif? 95% des réponses ont ici un point commun: la sortie n'est redirigée qu'après la fin de la commande initiale: lire les commentaires. L'utilitaire UNIX génère des teesorties en temps réel. wteea la même fonctionnalité. Si cela ne vous dérange pas, cela fera très bien l'affaire.
Davor Josipovic

C'est la seule solution qui fonctionne pour moi, sans Powershell> 4.0. Pouces vers le haut!
Alex

46

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


17
Vous devez utiliser à la &place de &&si vous voulez vous assurer que la typecommande est exécutée même si la dircommande a échoué. Ceci est utile lorsqu'il y a eu une forme d'erreur dans votre commande et que vous souhaitez toujours voir le fichier journal sur la console. Voir l'article de Microsoft à ce sujet . Cependant, cela a le problème d' %errorlevel%être réglé sur le niveau d'erreur de type(qui serait 0).
ADTC le

25

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.


3
teeon * nix est aussi une application distincte, pas une redirection sur le shell
phuclv

22

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.


5
Hmm, téléchargez tee / cygwin pour rien ou achetez MSVS avec mon argent durement gagné pour un petit programme comme ça? C'est difficile :-)
paxdiablo

19
Vous n'avez pas besoin de Visual Studio pour compiler cela, les outils de ligne de commande sont en fait gratuits. juste google ".net sdk download" pour le lien (le lien direct semble changer mais google semble toujours fonctionner).
Kris

13
Visual Studio Express est également gratuit, mais j'utiliserais toujours tee pour cela.
Brian Rasmussen

7
cygwin est difficile à installer. Votez pour vous parce que c'est ce que je cherchais.
Samaursa

1
Je ne pense pas que cela renvoie à la console et aux fichiers en même temps, n'est-ce pas?
mjaggard

20

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


2
Cela n'est utile que si vous souhaitez afficher le contenu APRÈS l'exécution de votre processus. Et ce n'est pas un problème difficile à résoudre.
Christopher Painter

1
Ouais, je suppose que cela résout un problème légèrement différent de ce que l'affiche originale demandait.
MTS

1
+1 C'est comme ça que je l'ai toujours fait. Je crois que c'est la bonne réponse à la question d'origine et devrait être marquée comme telle. L'astuce, comme le suggère @MTS, est que vous écrivez en fait dans deux fichiers: un qui est créé pour chaque commande / ligne (d'où un seul ">" qui écrase à chaque fois), puis vous tapez cette ligne à l'écran ( type ), et enfin, vous le tapez à nouveau et redirigez sa sortie, tout le long APPENDING, vers votre fichier journal avec ">>". C'est ainsi que je le fais depuis des années, bien que j'aime le simple " " fichier temporaire. J'ai toujours fait "tmp.txt" ou tout. Oui, supprimez-le ensuite.
eduncan911

C'est une bonne approche mais j'ai eu des problèmes avec certaines erreurs qui n'étaient pas capturées. Mettre les typecommandes sur des lignes distinctes (dans un sous-programme) a cependant corrigé cela.
Nate Cook

Exactement ce dont j'avais besoin pour ma candidature.
Alan

16

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.


1
Cela semble attendre que la sortie soit terminée également avant de sortir vers le fichier ou la console.
mellamokb

14

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

J'ai essayé cela lors de la construction de pyqt5.7 sur Windows 10, c'est assez lent, la sortie de la console n'est pas en temps réel, peut-être qu'elle est tamponnée? le fichier journal semble correct cependant
Shuman

3
Tout cela est complètement faux. Ça ne marche pas du tout pour moi. La dernière commande donne 'tee' is not recognized as an internal or external commandpour des raisons évidentes. Avec la 2>&1ligne cmd à l'intérieur, toute sortie vers stderr provoque des erreurs de powershell.
Pavel P

Pourrait être une référence à l'applet de commande
Bernd

9

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.


Cette chose tee.bat a l'air bien. J'espère que OP vérifie cela.
Jay

10
Notez que l'utilisation de TEE.BAT sortira une fois la commande terminée, tout comme l'exemple "dir> a.txt | type a.txt" affiché à proximité.
adzm

8

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

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

7
Si vous allez utiliser Cygwin, il est livré avec un tee-shirt.
M. Llama

7

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

Cela aidera à rediriger STDOUT et STDERR


Ça ne marche pas. J'ai essayé de l'utiliser pour lancer le run.bat JBoss et il s'étouffe lors du démarrage et le serveur se bloque. Il y a des problèmes avec cette méthode ...
djangofan

@raja ashok, ne fonctionne pas pour moi. J'ai essayé python.exe 1> file.txt 2> & 1 | type file.txt
neo

4

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

De toute façon, cela pourrait capturer la sortie stderr? J'ai un exe ennuyeux qui produit tout sur le flux d'erreurs standard (c'est-à-dire afin de produire dans un fichier normalement, vous le feriezfile.exe 2>output.txt
Mark Deven

Je l'ai compris. Vous pouvez le faire en utilisant file.exe 2>&1|tee.batcomme trouvé ici: superuser.com/questions/452763/…
Mark Deven

4

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.


3

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
)

3

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

Presque, mais il ne s'affiche pas simultanément - si vous avez une tâche longue, vous n'obtiendrez aucun résultat pendant longtemps.
JustAMartin

3

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

8
voulez-vous expliquer ce qui se passe ici?
John Demetriou

2

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%


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

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


11
n'appelez-vous pas le même programme deux fois avec ça?
elcool

1

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

Je fais de même lorsque j'essaie de capturer la sortie d'une commande (IE la met dans un for) mais j'appelle simplement ma sous-fonction standard pour faire écho à l'écran et écrire dans le journal car je l'utilise tout au long de mon script en remplacement de l'utilisation d'écho . Je ne sais pas pourquoi cela a obtenu un downvote des autres, alors j'ai voté pour.
Ben Personick

1

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.


1

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.


0

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


0

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.

0

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

6
Non, ce n'est pas en temps réel, il attend jusqu'à la %MYCOMMAND%fin et il échoue dans de nombreux cas. Il saute les lignes vides, les lignes commençant par ;défaut avec un contenu comme <space>/<TAB>, ON, OFFou /?. Mais le reste pourrait parfois fonctionner :-)
jeb

0

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.


0

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


0

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
  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é"
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.