Come posso inviare stdout a più comandi?

Ci sono alcuni comandi che filtrano o agiscono sull'input, e poi lo passano come output, penso di solito a stdout- ma alcuni comandi prenderanno semplicemente stdine faranno tutto ciò che fanno con esso, e non produrranno nulla.

Conosco molto bene OS X e quindi ce ne sono due che mi vengono subito in mente pbcopye pbpasteche sono mezzi per accedere agli Appunti di sistema.

Comunque, so che se voglio prendere stdout e sputare l'output per andare su entrambi stdoute su un file, allora posso usare il teecomando. E ne so un po ' xargs, ma non credo sia quello che sto cercando.

Voglio sapere come posso dividere stdoutper passare tra due (o più) comandi. Per esempio:

cat file.txt | stdout-split -c1 pbcopy -c2 grep -i errors

Probabilmente c'è un esempio migliore di quello, ma sono davvero interessato a sapere come posso inviare stdout a un comando che non lo inoltra e pur continuando stdouta non essere "disattivato" - non sto chiedendo come fare catun file e grepparte di esso e copiarlo negli Appunti: i comandi specifici non sono così importanti.

Inoltre - non sto chiedendo come inviarlo a un file e stdout- questa potrebbe essere una domanda "duplicata" (scusate) ma ho fatto un po 'di ricerca e ho trovato solo quelli simili che chiedevano come dividere tra stdout e un file - e le risposte a quelle domande sembravano essere tee, che non credo funzioneranno per me.

Infine, potresti chiedere "perché non rendere pbcopy l'ultima cosa nella catena di tubi?" e la mia risposta è 1) cosa succede se voglio usarlo e vedere ancora l'output nella console? 2) cosa succede se voglio usare due comandi che non vengono emessi stdoutdopo che hanno elaborato l'input?

Oh, e un'altra cosa - mi rendo conto di poter usare teee un nome pipe ( mkfifo) ma speravo in un modo che potesse essere fatto in linea, in modo conciso, senza una configurazione precedente :)

È possibile utilizzare teeed elaborare la sostituzione per questo:

cat file.txt | tee >(pbcopy) | grep errors

Questo invierà tutto l'output di cat file.txtto pbcopye otterrai solo il risultato grepsulla tua console.

È possibile inserire più processi nella teeparte:

cat file.txt | tee >(pbcopy) >(do_stuff) >(do_more_stuff) | grep errors

È possibile specificare più nomi di file teee, inoltre, l'output standard può essere reindirizzato in un solo comando. Per inviare l'output a più comandi, è necessario creare più pipe e specificarne ognuna come output di tee. Esistono diversi modi per farlo.

Sostituzione del processo

Se la tua shell è ksh93, bash o zsh, puoi usare la sostituzione di processo. Questo è un modo per passare una pipe a un comando che prevede un nome file. La shell crea la pipe e passa un nome di file simile /dev/fd/3al comando. Il numero è il descrittore di file a cui è connessa la pipe. Alcune varianti di unix non supportano /dev/fd; su questi viene invece utilizzata una pipa denominata (vedi sotto).

tee >(command1) >(command2) | command3

Descrittori di file

In qualsiasi shell POSIX, è possibile utilizzare esplicitamente più descrittori di file . Ciò richiede una variante unix che supporti /dev/fd, poiché tutti gli output tranne uno teedevono essere specificati per nome.

{ { { tee /dev/fd/3 /dev/fd/4 | command1 >&9;
    } 3>&1 | command2 >&9;
  } 4>&1 | command3 >&9;
} 9>&1

Pipe nominate

Il metodo più semplice e portatile è usare le pipe con nome . Il rovescio della medaglia è che è necessario trovare una directory scrivibile, creare le pipe e ripulire in seguito.

tmp_dir=$(mktemp -d)
mkfifo "$tmp_dir/f1" "$tmp_dir/f2"
command1 <"$tmp_dir/f1" & pid1=$!
command2 <"$tmp_dir/f2" & pid2=$!
tee "$tmp_dir/f1" "$tmp_dir/f2" | command3
rm -rf "$tmp_dir"
wait $pid1 $pid2

Gioca con la sostituzione del processo.

mycommand_exec |tee >(grep ook > ook.txt) >(grep eek > eek.txt)

grepsono due binari che hanno lo stesso output del mycommand_execloro input specifico del processo.

Se lo stai usando zsh, puoi sfruttare la potenza della MULTIOSfunzione, ovvero eliminare teecompletamente il comando:

uname >file1 >file2

scriverà semplicemente l'output di unamein due file diversi: file1e file2, cosa equivale auname | tee file1 >file2

Allo stesso modo reindirizzamento di input standard

wc -l <file1 <file2

è equivalente a cat file1 file2 | wc -l(si noti che questo non è lo stesso wc -l file1 file2, il successivo conta il numero di righe in ciascun file separatamente).

Ovviamente puoi anche usare MULTIOSper reindirizzare l'output non su file ma su altri processi, usando la sostituzione dei processi, ad esempio:

echo abc > >(grep -o a) > >(tr b x) > >(sed 's/c/y/')

Per un output ragionevolmente piccolo prodotto da un comando, possiamo reindirizzare l'output su un file temporaneo e inviare tali file temporanei ai comandi in loop. Questo può essere utile quando l'ordine dei comandi eseguiti può essere importante.

Il seguente script, ad esempio, potrebbe farlo:

#!/bin/sh

temp=$( mktemp )
cat /dev/stdin > "$temp"

for arg
do
    eval "$arg" < "$temp"
done
rm "$temp"

Test eseguito su Ubuntu 16.04 con /bin/shcome dashshell:

$ cat /etc/passwd | ./multiple_pipes.sh  'wc -l'  'grep "root"'                                                          
48
root:x:0:0:root:/root:/bin/bash

Cattura il comando STDOUTsu una variabile e riutilizzalo tutte le volte che vuoi:

commandoutput="$(command-to-run)"
echo "$commandoutput" | grep -i errors
echo "$commandoutput" | pbcopy

Se è necessario acquisire STDERRanche, quindi utilizzare 2>&1alla fine del comando, in questo modo:

commandoutput="$(command-to-run 2>&1)"

Questo può essere utile: http://www.spinellis.gr/sw/dgsh/ (shell grafica diretta) Sembra una sostituzione bash che supporta una sintassi più semplice per i comandi "multipipe".

Ecco una soluzione parziale rapida e sporca, compatibile con qualsiasi shell inclusa busybox.

Il problema più stretto che risolve è: stampare il completo stdoutsu una console e filtrarlo su un'altra, senza file temporanei o named pipe.

• Avvia un'altra sessione sullo stesso host. Per scoprire il nome TTY, digitare tty. Supponiamo /dev/pty/2.
• Nella prima sessione, esegui the_program | tee /dev/pty/2 | grep ImportantLog:

Si ottiene un registro completo e uno filtrato.