Wyświetlanie wyniku wiersza polecenia systemu Windows i przekierowanie go do pliku

Jak mogę uruchomić aplikację wiersza polecenia w wierszu polecenia systemu Windows, aby dane wyjściowe były jednocześnie wyświetlane i przekierowywane do pliku?

Jeśli na przykład miałbym uruchomić polecenie dir > test.txt, przekierowałoby to wyjście do pliku wywoływanego test.txtbez wyświetlania wyników.

Jak napisać polecenie, aby wyświetlić dane wyjściowe i przekierować dane wyjściowe do pliku w wierszu polecenia systemu Windows, podobnie jak teepolecenie w systemie Unix?

Aby rozwinąć odpowiedź davor , możesz użyć programu PowerShell w następujący sposób:

powershell "dir | tee test.txt"

Jeśli próbujesz przekierować wyjście exe w bieżącym katalogu, musisz użyć .\nazwy pliku, np .:

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

Udało mi się znaleźć rozwiązanie / obejście przekierowywania danych wyjściowych do pliku, a następnie do konsoli:

dir > a.txt | type a.txt

gdzie dir jest poleceniem, do którego wyjścia należy przekierować, a.txt plik, w którym należy zapisać dane wyjściowe.

Jest port Win32 teepolecenia Unix , który robi dokładnie to. Zobacz http://unxutils.sourceforge.net/ lub http://getgnuwin32.sourceforge.net/

Sprawdź to: wintee

Nie potrzebujesz cygwina.

Spotkałem się i zgłosiłem kilka problemów.

Możesz także sprawdzić unxutils, ponieważ zawiera tee (i nie potrzebujesz cygwina), ale uważaj, że wyjściowe EOL są tutaj podobne do UNIX-a.

Wreszcie, jeśli masz PowerShell, możesz wypróbować Tee-Object. Wpisz get-help tee-objectkonsolę PowerShell, aby uzyskać więcej informacji.

@ tori3852

znalazłem to

dir > a.txt | type a.txt

nie działało (tylko kilka pierwszych wierszy listowania katalogów - podejrzewam, że rozwidla się jakiś proces, a druga część, polecenie „typ” zakończyło się przed zakończeniem listingu?), więc zamiast tego użyłem:

dir > z.txt && type z.txt

który zrobił - sekwencyjne polecenia, jedno wykonuje się przed drugim uruchomieniem.

Niestety nie ma czegoś takiego.

Aplikacje konsoli Windows mają tylko jeden uchwyt wyjściowy. (Cóż, są dwa STDOUT, STDERRale to nie ma znaczenia). >Przekierowuje wyjście normalnie zapisywane do uchwytu konsoli do uchwytu pliku.

Jeśli chcesz mieć pewnego rodzaju multipleksowanie, musisz użyć zewnętrznej aplikacji, na którą możesz przekierować wyjście. Ta aplikacja może następnie ponownie zapisać plik i konsolę.

Prosta aplikacja na konsolę C # załatwi sprawę:

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

Aby tego użyć, po prostu potokuj polecenie źródłowe do programu i podaj ścieżkę do plików, które chcesz zduplikować. Na przykład:

dir | CopyToFiles files1.txt files2.txt 

Wyświetli wyniki dir, a także zapisze wyniki zarówno w plikach1.txt, jak i plikach2.txt.

Należy pamiętać, że powyższy sposób obsługi błędów nie ma wiele (nic!), A obsługa wielu plików może nie być wymagana.

To działa, choć jest trochę brzydkie:

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

Jest nieco bardziej elastyczny niż niektóre inne rozwiązania, ponieważ działa instrukcja po instrukcji, dzięki czemu można go również używać do dołączania. Używam tego dość często w plikach wsadowych do rejestrowania i wyświetlania komunikatów:

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

Tak, możesz po prostu powtórzyć instrukcję ECHO (raz na ekranie i po raz drugi przekierowanie do pliku dziennika), ale wygląda to tak samo źle i jest to trochę problem z konserwacją. Przynajmniej w ten sposób nie musisz wprowadzać zmian w wiadomościach w dwóch miejscach.

Zauważ, że _ to tylko krótka nazwa pliku, więc musisz ją usunąć na końcu pliku wsadowego (jeśli używasz pliku wsadowego).

mtee to małe narzędzie, które działa bardzo dobrze w tym celu. Jest bezpłatny, źródło jest otwarte i po prostu działa.

Można go znaleźć na stronie http://www.commandline.co.uk .

Używana w pliku wsadowym do wyświetlania danych wyjściowych ORAZ utworzenia pliku dziennika jednocześnie, składnia wygląda następująco:

    someprocess | mtee /+ mylogfile.txt

Gdzie / + oznacza dołączenie wyniku.

Zakłada się, że skopiowałeś mtee do folderu, który znajduje się w PATH, oczywiście.

Chciałbym trochę rozwinąć doskonałą odpowiedź Saxona Druce'a .

Jak już wspomniano, możesz przekierować wyjście pliku wykonywalnego w bieżącym katalogu w następujący sposób:

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

Jednak tylko loguje się stdoutdo test.txt. Nie rejestruje się również stderr.

Oczywistym rozwiązaniem byłoby użycie czegoś takiego:

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

Jednak to nie zadziała dla wszystkich something.exes. Niektórzy something.exes zinterpretują to 2>&1jako argument i zawiodą. Prawidłowe rozwiązanie to zamiast tego mieć apostrofy tylko wokół something.exeprzełączników i argumentów, tak jak poniżej:

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

Zgadzam się z Brianem Rasmussenem, że port unxutils jest najłatwiejszym sposobem na zrobienie tego. W sekcji Pliki wsadowe swoich stron skryptów Rob van der Woude zawiera wiele informacji na temat korzystania z poleceń MS-DOS i CMD. Pomyślałem, że może on mieć natywne rozwiązanie twojego problemu i po tym, jak się tam przekopałem , znalazłem TEE.BAT , który wydaje się być właśnie implementacją tee w MS-DOS. Jest to dość skomplikowany plik wsadowy i nadal chciałbym używać portu unxutils.

Jeśli masz cygwin na ścieżce środowiska Windows, możesz użyć:

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

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

Pomoże to przekierować STDOUT i STDERR

Wiem, że to bardzo stary temat, ale we wcześniejszych odpowiedziach nie ma pełnej implementacji trójnika w czasie rzeczywistym napisanego Batch. Moje rozwiązanie poniżej to hybrydowy skrypt Batch-JScript, który używa sekcji JScript tylko w celu uzyskania danych wyjściowych z polecenia potokowego, ale przetwarzanie danych odbywa się w sekcji Batch. Takie podejście ma tę zaletę, że każdy programista Batch może modyfikować ten program, aby dopasować go do określonych potrzeb. Ten program również poprawnie przetwarza dane wyjściowe polecenia CLS wygenerowane przez inne pliki wsadowe, tzn. Czyści ekran po wykryciu danych wyjściowych polecenia 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");

Szukałem również tego samego rozwiązania, po krótkiej próbie udało mi się to osiągnąć w wierszu polecenia. Oto moje rozwiązanie:

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

Przechwytuje nawet dowolne polecenie PAUZA.

Oto próbka tego, czego użyłem na podstawie jednej z pozostałych odpowiedzi

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

Coś takiego powinno zrobić to, czego potrzebujesz?

%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

wyślij dane wyjściowe do konsoli, dołącz do dziennika konsoli, usuń dane wyjściowe z bieżącego polecenia

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

Jest to odmiana poprzedniej odpowiedzi MTS, jednak dodaje ona niektórych funkcji, które mogą być przydatne dla innych. Oto metoda, której użyłem:

• Polecenie jest ustawione jako zmienna, z której można później korzystać w całym kodzie, aby wyświetlać dane w oknie poleceń i dołączać do pliku dziennika za pomocą set _Temp_Msg_Cmd=
  • polecenie uniknęło przekierowania za pomocą ^znaku marchewki, więc polecenia nie są początkowo oceniane
• Tworzony jest plik tymczasowy o nazwie podobnej do uruchamianego pliku wsadowego, %~n0_temp.txtktóry używa składni rozszerzenia parametru wiersza polecenia, %~n0 aby uzyskać nazwę pliku wsadowego.
• Dane wyjściowe są dołączane do osobnego pliku dziennika %~n0_log.txt

Oto sekwencja poleceń:

1. Dane wyjściowe i komunikaty o błędach są wysyłane do pliku tymczasowego ^> %~n0_temp.txt 2^>^&1
2. Zawartość pliku tymczasowego jest wtedy zarówno:
   • dołączony do pliku dziennika ^& type %~n0_temp.txt ^>^> %~n0_log.txt
   • wyjście do okna poleceń ^& type %~n0_temp.txt
3. Plik tymczasowy z wiadomością zostanie usunięty ^& del /Q /F %~n0_temp.txt

Oto przykład:

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

W ten sposób polecenie można po prostu dołączyć po późniejszych poleceniach do pliku wsadowego, który wygląda na znacznie czystszy:

echo test message %_Temp_Msg_Cmd%

Można to również dodać na końcu innych poleceń. O ile mogę stwierdzić, będzie działać, gdy wiadomości mają wiele linii. Na przykład następujące polecenie wyświetla dwa wiersze, jeśli pojawia się komunikat o błędzie:

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

Spowoduje to utworzenie pliku dziennika z bieżącą datą i możesz konsolować wiersze konsoli podczas procesu

Korzystam z podprogramu wsadowego z instrukcją „for”, aby uzyskać dane wyjściowe polecenia po jednym wierszu, i oba zapisują ten wiersz do pliku i wysyłają go do konsoli.

@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śli korzystasz z interfejsu CLI, skorzystaj z pętli FOR, aby „zrobić” cokolwiek chcesz:

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

Świetny zasób na Windows CMD dla pętli: https://ss64.com/nt/for_cmd.html Kluczem tutaj jest ustawienie ograniczników (delimów), które zerwałyby każdą linię wyjścia, do zera. W ten sposób nie zepsuje się domyślnej białej spacji. % A to dowolna litera, ale jest używana w sekcji „do”, aby ... cóż ... zrobić coś ze znakami, które zostały przeanalizowane w każdym wierszu. W takim przypadku możemy użyć znaków ampersands (&&) do wykonania drugiego polecenia echa w celu utworzenia lub dołączenia (>>) do wybranego przez nas pliku. Bezpieczniej jest zachować tę kolejność poleceń DO na wypadek, gdyby wystąpił problem z zapisaniem pliku, przynajmniej dostaniemy echo do konsoli. Znak at (@) przed pierwszym echem powstrzymuje konsolę przed wyświetlaniem samego polecenia echo, a zamiast tego wyświetla wynik polecenia, które ma wyświetlać znaki w% a. W przeciwnym razie zobaczysz:

echo Wolumin na dysku [x] to Windows
Wolumin na dysku [x] to Windows

AKTUALIZACJA: / F pomija puste linie i jedyną poprawką jest wstępne filtrowanie wyniku, dodając znak do każdej linii (być może z numerami linii za pomocą polecenia find). Rozwiązanie tego w CLI nie jest szybkie ani ładne. Nie dodałem także STDERR, więc tutaj również są błędy:

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

Przekierowywanie komunikatów o błędach

Kreski (^) służą do ucieczki przed symbolami po nich, ponieważ polecenie jest ciągiem, który jest interpretowany, w przeciwieństwie do tego, wprowadzając go bezpośrednio w wierszu polecenia.

Podobnie jak unix.

dir | tee a.txt

Działa w systemie Windows XP, wymaga mksntzainstalowania.

Wyświetla się w monicie, a także dołącza się do pliku.

Poniższe informacje pomagają, jeśli chcesz naprawdę zobaczyć coś na ekranie - nawet jeśli plik wsadowy został przekierowany do pliku. Urządzenie CON może być również używane, jeśli zostanie przekierowane do pliku

Przykład:

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

Zobacz także dobry opis przekierowania: http://www.p-dd.com/chapter7-page14.html

Jak wyświetlić i przekierować dane wyjściowe do pliku. Załóżmy, że jeśli użyję polecenia dos, katalog> test.txt, to polecenie przekieruje dane wyjściowe do pliku test.txt bez wyświetlania wyników. jak napisać polecenie, aby wyświetlić dane wyjściowe i przekierować dane wyjściowe do pliku przy użyciu DOS, tj. wiersz polecenia systemu Windows, a nie w UNIX / LINUX.

Przydatne mogą być te polecenia w skryptowaniu bitów ( http://www.biterscripting.com ).

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.

Działa to w czasie rzeczywistym, ale jest też trochę brzydkie, a wydajność jest niska. Niezbyt dobrze przetestowany:

@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

Alternatywą jest wprowadzenie standardowego do standardowego w swoim programie:

w java:

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

Następnie w pliku wsadowym dos: java program > log.txt

Stdout przejdzie do pliku dziennika, a stderr (te same dane) pojawi się na konsoli.

Instaluję perla na większości moich maszyn, więc odpowiedź za pomocą perla: 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;

reż | perl tee.pl lub reż | perl tee.pl reż. bat

surowy i nieprzetestowany.

Inną odmianą jest podzielenie potoku, a następnie przekierowanie wyjścia według własnego uznania.

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

Zapisz powyższe w pliku .bat. Dzieli również tekst na strumieniu plików 1 na strumień plików 3, który można przekierować w razie potrzeby. W poniższych przykładach nazwałem powyższy skrypt 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. Kliknij link „setup-x86_.exe”
3. Uruchom instalatora
4. Na ~ 2. stronie wybierz „dublowanie”, z którego chcesz pobrać (szukałem domeny .edu)
5. Powiedziałem ok do standardowych opcji
6. Cygwin szybko zakończył instalację
7. Otwórz cmd
8. Wpisz c:\cygwin64\bin\script.exei wpisz
9. Wpisz cmdi wpisz
10. Uruchom swój program
11. Wpisz exiti wprowadź (wychodzi z Cygwin's cmd.exe)
12. Wpisz exiti wprowadź (wychodzi z Cygwin's script.exe)
13. Zobacz wyjście ekranu programu w pliku tekstowym o nazwie „maszynopis”