Pipe vers plusieurs fichiers dans le shell

J'ai une application qui produira une grande quantité de données que je ne souhaite pas stocker sur le disque. L'application génère principalement des données que je ne souhaite pas utiliser, mais un ensemble d'informations utiles qui doivent être divisées en fichiers séparés. Par exemple, étant donné la sortie suivante:

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

Je pourrais exécuter l'application trois fois comme ceci:

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

Cela m'obtiendrait ce que je veux, mais cela prendrait trop de temps. Je ne veux pas non plus sauvegarder toutes les sorties dans un seul fichier et les analyser.

Existe-t-il un moyen de combiner les trois opérations illustrées ci-dessus de telle manière que je n'ai besoin d'exécuter l'application qu'une seule fois et d'obtenir toujours trois fichiers de sortie distincts?

Si vous avez un tee

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

(d' ici )

(à propos de la substitution de processus )

Vous pouvez utiliser awk

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

Vous pouvez également utiliser les capacités de correspondance de motifs de votre coque :

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

Ou même:

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

Un moyen plus sûr qui peut gérer les barres obliques inverses et les lignes commençant par -:

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

Comme le souligne @StephaneChazelas dans les commentaires, ce n'est pas très efficace. La meilleure solution est probablement @ AurélienOoms ' .

Si vous avez plusieurs cœurs et que vous souhaitez que les processus soient en parallèle, vous pouvez faire:

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

Cela engendrera trois processus dans des cœurs parallèles. Si vous voulez qu'il y ait une sortie vers la console, ou un fichier maître, cela a l'avantage de garder la sortie dans un certain ordre, plutôt que de la mélanger.

L'utilitaire gnu parallèle d'Ole Tange peut être obtenu auprès de la plupart des dépôts sous le nom parallèle ou moreutils . La source peut être obtenue sur Savannah.gnu.org . Une vidéo d'introduction est également disponible ici .

Addenda

En utilisant la version la plus récente de Parallel (pas nécessairement la version de votre référentiel de distribution), vous pouvez utiliser la construction la plus élégante:

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

Ce qui permet d'obtenir le résultat d'exécuter un ./app et 3 processus grep parallèles dans des cœurs ou des threads séparés (comme déterminé par parallèle lui-même, considérez également le -j3 comme facultatif, mais il est fourni dans cet exemple à des fins instructives).

La nouvelle version de Parallel peut être obtenue en faisant:

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

Ensuite, décompressez d'habitude, cd vers parallel- {date}, ./configure && make, sudo make install. Ceci installera parallèle, page de manuel parallèle et page de manuel parallel_tutorial.

En voici un en Perl:

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

... if <inest lisible, les trois fichiers de sortie seront tronqués avant que quoi que ce soit ne leur soit écrit.