Canalizar para vários arquivos no shell

Eu tenho um aplicativo que produzirá uma grande quantidade de dados que não desejo armazenar no disco. O aplicativo emite principalmente dados que não desejo usar, mas um conjunto de informações úteis que devem ser divididas em arquivos separados. Por exemplo, dada a seguinte saída:

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

Eu poderia executar o aplicativo três vezes da seguinte maneira:

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

Isso me daria o que eu quero, mas levaria muito tempo. Também não quero despejar todas as saídas em um único arquivo e analisar isso.

Existe alguma maneira de combinar as três operações mostradas acima de forma que eu só precise executar o aplicativo uma vez e ainda assim obter três arquivos de saída separados?

Se você tem tee

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

( daqui )

( sobre substituição de processo )

Você pode usar awk

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

Você também pode usar as habilidades de correspondência de padrões do seu shell :

./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 até:

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

Uma maneira mais segura de lidar com barras invertidas e linhas começando com -:

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

Como @StephaneChazelas aponta nos comentários, isso não é muito eficiente. A melhor solução é provavelmente a @ AurélienOoms .

Se você possui vários núcleos e deseja que os processos sejam paralelos, é possível:

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

Isso gerará três processos em núcleos paralelos. Se você deseja que haja alguma saída para o console ou um arquivo mestre, ele tem a vantagem de manter a saída em alguma ordem, em vez de misturá-la.

O utilitário gnu paralelo de Ole Tange pode ser obtido na maioria dos repositórios com o nome paralelo ou moreutils . A fonte pode ser obtida em Savannah.gnu.org . Também um vídeo instrutivo introdutório está aqui .

Termo aditivo

Usando a versão mais recente do paralelo (não necessariamente a versão em seu repositório de distribuição), você pode usar a construção mais elegante:

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

O que alcança o resultado da execução de um ./app e 3 processos grep paralelos em núcleos ou encadeamentos separados (conforme determinado pelo próprio paralelo, também considera o -j3 opcional, mas é fornecido neste exemplo para fins instrutivos).

A versão mais recente do paralelo pode ser obtida fazendo:

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

Em seguida, descompacte o arquivo usual, cd to parallel- {date}, ./configure && make, sudo make install. Isso instalará paralelo, página de manual paralela e página de manual paralela_tutorial.

Aqui está um em 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

... se <infor legível, todos os três arquivos serão truncados antes que algo lhes seja gravado.