Potok do wielu plików w powłoce

Mam aplikację, która wygeneruje dużą ilość danych, których nie chcę przechowywać na dysku. Aplikacja generuje głównie dane, których nie chcę używać, ale zestaw przydatnych informacji, które należy podzielić na osobne pliki. Na przykład biorąc pod uwagę następujące dane wyjściowe:

JUNK
JUNK
JUNK
JUNK
A 1
JUNK
B 5
C 1
JUNK

Mógłbym uruchomić aplikację trzy razy tak:

./app | grep A > A.out
./app | grep B > B.out
./app | grep C > C.out

To dałoby mi to, czego chcę, ale zajęłoby to zbyt długo. Nie chcę też zrzucać wszystkich danych wyjściowych do jednego pliku i analizować przez to.

Czy jest jakiś sposób na połączenie trzech powyższych operacji w taki sposób, że muszę uruchomić aplikację tylko raz i nadal uzyskać trzy osobne pliki wyjściowe?

Jeśli masz koszulkę

./app | tee >(grep A > A.out) >(grep B > B.out) >(grep C > C.out) > /dev/null

( stąd )

( o zastępowaniu procesów )

Możesz użyć awk

./app | awk '/A/{ print > "A.out"}; /B/{ print > "B.out"}; /C/{ print > "C.out"}'

Możesz także użyć zdolności dopasowywania wzoru powłoki :

./app | while read line; do 
     [[ "$line" =~ A ]] && echo $line >> A.out; 
     [[ "$line" =~ B ]] && echo $line >> B.out; 
     [[ "$line" =~ C ]] && echo $line >> C.out; 
 done

Lub nawet:

./app | while read line; do for foo in A B C; do 
     [[ "$line" =~ "$foo" ]] && echo $line >> "$foo".out; 
  done; done

Bezpieczniejszy sposób radzenia sobie z odwrotnymi ukośnikami i liniami, zaczynając od -:

./app | while IFS= read -r line; do for foo in A B C; do 
     [[ "$line" =~ "$foo" ]] && printf -- "$line\n" >> "$foo".out; 
  done; done

Jak wskazuje @StephaneChazelas w komentarzach, nie jest to zbyt wydajne. Najlepszym rozwiązaniem jest prawdopodobnie @ AurélienOoms ' .

Jeśli masz wiele rdzeni i chcesz, aby procesy były równoległe, możesz:

parallel -j 3 -- './app | grep A > A.out' './app | grep B > B.out' './app | grep C > C.out'

Spowoduje to odrodzenie trzech procesów w równoległych rdzeniach. Jeśli chcesz mieć jakieś wyjście na konsolę lub plik główny, ma tę zaletę, że utrzymuje wyjście w pewnej kolejności, a nie miksuje.

Narzędzie GNU równoległe z Ole Tange można uzyskać z większości repozytoriów pod nazwą równolegle lub moreutils . Źródło można uzyskać z Savannah.gnu.org . Również wprowadzenie film instruktażowy jest tutaj .

Uzupełnienie

Korzystając z nowszej wersji programu równoległego (niekoniecznie wersji w repozytorium dystrybucji), możesz użyć bardziej eleganckiej konstrukcji:

./app | parallel -j3 -k --pipe 'grep {1} >> {1}.log' ::: 'A' 'B' 'C'

Który osiąga wynik uruchomienia jednego ./app i 3 równoległych procesów grep w oddzielnych rdzeniach lub wątkach (jak określono przez sam równoległy, również rozważ -j3 jako opcjonalny, ale podano go w tym przykładzie w celach instruktażowych).

Nowszą wersję programu równoległego można uzyskać, wykonując:

wget http://ftpmirror.gnu.org/parallel/parallel-20131022.tar.bz2

Następnie zwykłe rozpakowywanie, cd na równolegle- {data}, ./configure && make, sudo make install. Spowoduje to zainstalowanie równoległego, strony podręcznika równoległego i strony podręcznika równoległego.

Oto jeden w Perlu:

./app | perl -ne 'BEGIN {open(FDA, ">A.out") and 
                         open(FDB, ">B.out") and 
                         open(FDC, ">C.out") or die("Cannot open files: $!\n")} 
                  print FDA $_ if /A/; print FDB $_ if /B/; print FDC $_ if /C/'

sed -ne/A/w\ A.out -e/B/w\ B.out -e/C/p <in >C.out

... jeśli <injest czytelny, wszystkie trzy pliki wyjściowe zostaną obcięte, zanim cokolwiek zostanie do nich zapisane.