Dividir uma entrada para um comando diferente e combinar o resultado

Question

Eu sei combinar o resultado de um comando diferente

paste -t',' <(commanda) <(commandb)

Eu sei canalizar a mesma entrada para um comando diferente

cat myfile | tee >(commanda) >(commandb)

Agora, como combinar esses comandos? Para que eu possa fazer

cat myfile | tee >(commanda) >(commandb) | paste -t',' resulta resultb

Digamos que eu tenha um arquivo

myfile:

1
2
3
4

Eu quero fazer um novo arquivo

1 4 2
2 3 4
3 2 6
4 1 8

eu usei

cat myfile | tee >(tac) >(awk '{print $1*2}') | paste

me daria resultado verticalmente, onde eu realmente quero colá-los na ordem horizontal.

    

Answer 1

Quando você usa várias substituições de processo, não é garantido que você obtenha a saída em uma ordem específica, então é melhor continuar com

paste -t',' <(commanda < file) <(commandb < file)

Supondo que cat myfile represente algum canal caro, acho que você terá que armazenar a saída, seja em um arquivo ou em uma variável:

output=$( some expensive pipeline )
paste -t',' <(commanda <<< "$output") <(commandb <<< "$output")

Usando seu exemplo:

output=$( seq 4 )
paste -d' ' <(cat <<<"$output") <(tac <<<"$output") <(awk '$1*=2' <<<"$output")

1 4 2
2 3 4
3 2 6
4 1 8

Outro pensamento: FIFOs e um único pipeline

mkfifo resulta resultb
seq 4 | tee  >(tac > resulta) >(awk '$1*=2' > resultb) | paste -d ' ' - resulta resultb
rm resulta resultb

1 4 2
2 3 4
3 2 6
4 1 8

    

Answer 2

O shell yash tem recursos exclusivos ( redirecionamento de pipeline e redirecionamento de processo ) que facilitam isso:

cat myfile | (
  exec 3>>|4
  tee /dev/fd/5 5>(commanda >&3 3>&-) 3>&- |
    commandb 3>&- |
    paste -d , /dev/fd/4 - 3>&-
)

3>>|4 ( redirecionamento de pipeline ) cria um canal onde o final da escrita está em fd 3 e o final da leitura em fd 4.

3>(commanda>&3) é redirecionamento de processo , um pouco parecido com a substituição do processo ksh / zsh / bash, mas apenas faz o redirecionamento e não substitui o /dev/fd/n . ksh >(cmd) é mais ou menos o mesmo que yash n>(cmd) /dev/fd/n (há n é um descritor de arquivo escolhido por ksh sobre o qual você não tem controle).

    

Answer 3

com zsh :

pee() (
  n=0 close_in= close_out= inputs=() outputs=()
  merge_command=$1; shift
  for cmd do
    eval "coproc $cmd $close_in $close_out"

    exec {i}<&p {o}>&p
    inputs+=($i) outputs+=($o)
    eval i$n=$i o$n=$o
    close_in+=" {i$n}<&-" close_out+=" {o$n}>&-"
    ((n++))
  done
  coproc :
  read -p
  eval tee /dev/fd/$^outputs $close_in "> /dev/null &
    " exec $merge_command /dev/fd/$^inputs $close_out
)

Em seguida, use como:

$ echo abcd | pee 'paste -d,' 'tr a A' 'tr b B' 'tr c C'
Abcd,aBcd,abCd

Isso é adaptado de esta outra pergunta onde você encontrará algumas explicações detalhadas e dicas sobre as limitações (cuidado de deadlocks!).

    

Answer 4

Para o seu exemplo em particular, não deve haver necessidade de paste e o restante. Muitas vezes é verdade que, quando nos deparamos com um limite com o conjunto de ferramentas padrão, é porque o que queremos fazer de uma maneira pode ser feito de outra maneira. Tais como:

set 1 2 3 4
while [ "$#" -gt 0 ]
do    echo "$1" "$#" "$(($1*2))"
shift;done

... que imprime ...

1 4 2
2 3 4
3 2 6
4 1 8

Você pode obter um arquivo com o conteúdo que você mencionou no array "$@" do seu shell como ...

set -f; IFS='
'; set -- $(cat)

E para validar os valores de arg em um loop como o acima, você pode alterar o teste inicial um pouco ...

while { [ "$1" -eq "${1-1}" ] ;} 2>&"$((2+!$#))"
do    echo "$1" "$#" "$(($1*2))"
shift;done  3>/dev/null >outfile

... que imprime um erro para stderr somente se uma linha lida com set -- $(cat) contiver uma linha que não consiste inteiramente em um único inteiro.