Pipes: cosa devi sapere per iniziare a usarli in GNU / Linux

Un pipe o pipe è in realtà una pipeline disponibile per UNIX / Linux e molto pratica. Ma per comprendere appieno cos'è una pipe, dovresti sapere che in un ambiente * nix ha 3 flussi di dati incorporati. Ciò, per chi non lo sapesse, significa che i dati possono viaggiare da o verso tre punti.

Allora lo capirai in un modo migliore, ma quello che voglio chiarirti ora è che con una pipeline quello che puoi fare è canalizzare da uno di quei punti ad altri. Ciò consente di prendere l'output o il risultato che un programma lancia verso l'input di un altro per quello da utilizzare, ecc. Proverò a spiegarlo con alcuni esempi pratici che ti aiuteranno a capirlo molto bene.

Quei punti di cui stavo parlando o flussi di dati, sono:

• stdin: corrisponde a 0 ed è lo standard input. Generalmente, l'input standard per un sistema * nix è la tastiera. Cioè, ciò che digiti saranno le informazioni utilizzate. Ha un dispositivo speciale associato ad esso che è / dev / stdin.
• stdout: identificato con 1, è lo standard output. Di solito corrisponde al monitor o allo schermo del tuo computer, che è dove puoi vedere le informazioni. Ad esempio, quando esegui un comando ls, l'elenco dei contenuti verrà visualizzato sullo schermo, giusto? Il dispositivo associato è / dev / stdout.
• stderr: identificato con 2, è lo standard error output, per quando si verifica un errore in un programma. Il dispositivo associato è / dev / stderr.

Con una pipeline è possibile far passare l'output standard o lo stdout di un comando direttamente allo standard input di un altro. Cioè, puoi fare in modo che un programma ne alimenti un altro. Invece di utilizzare i parametri immessi dalla tastiera, una pipe fornisce le informazioni generate dal comando precedente attraverso questa pipeline rappresentata dal |

Con gli esempi lo capirai meglio. Supponi di voler elencare il contenuto di una directory, ma ti interessa solo vedere i nomi che corrispondono alla parola doc. Quindi potresti usare una pipeline per convogliare l'output di ls nell'input del filtro grep per dirgli di visualizzare solo quelli che corrispondono a quel modello:

ls -l | grep doc

Quindi, invece di mostrarti tutti i nomi, ti mostra solo quelli che ti interessano davvero. Puoi fare lo stesso con il contenuto di un file. Immagina di voler vedere solo le informazioni dei processi denominati firefox e non tutti:

ps aux | grep firefox

Invece di mostrare tutto l'output del programma ps sullo schermo (stdout), quello che fa è incanalarlo verso l'ingresso del filtro grep e mostra solo nell'output ciò che corrisponde al pattern firefox in questo caso ...

Se vuoi, puoi usare vari tubi portare l'output di un comando all'input di un altro secondo comando, e l'output di quel secondo all'input di un terzo, e così via. Per esempio:

cat libro | grep love | more

Come vedi le possibilità sono molte, tutto ciò che puoi immaginare e ti è permesso. Mostra anche solo la prima e l'ultima riga di un file, conta le righe che entrano in wc che provengono dall'elenco e persino ordinale:

cat listado | head
cat listado | tail
cat listado | wc -l
cat listado | sort

Puoi anche lavorare con errori con | & e ad esempio cerca la parola alert nell'output di uno script se fallisce:

./miscript |& grep alerta 

E infine, ci sono due comandi strettamente legati alle pipe che sono tee e xargs e che possono estendere ulteriormente le possibilità di questi. Nel caso di tee, ciò che consentirà è di mostrare il risultato del programma precedente sullo standard output in modo che tu possa vederlo, e in aggiunta a ciò, lo può reindirizzare a un altro file. Un esempio potrebbe essere se elenchi il contenuto di una directory e desideri vedere l'output di ls -l al momento e salvarlo anche in un file list.txt:

ls -l | tee listado.txt

Se non usi tee, non sarai in grado di vedere l'output di output sulla tua console ...

Y xargs in alcuni casi è ancora più interessante. In questo caso è in grado di costruire un comando dallo standard input che riceve attraverso la pipeline. In altre parole, è in grado di catturare tutto ciò che un programma precedente ha avviato attraverso il suo output e che raggiunge xargs attraverso la pipeline per passarlo a un altro comando come argomenti.

Ancora non lo capisci? Lo vedrai molto meglio con un esempio. Immagina di voler rimuovere tutti i dannati file thumbs.db da una directory, un disco o una partizione. Se ce ne sono molti, potrebbe essere impossibile andare uno per uno con il comando rm per eliminarli manualmente. Ma con xargs puoi automatizzare tutto. E puoi farlo usando find per individuarli, inviare l'output tramite l'input di xargs e questo a sua volta darà a rm i nomi come argomenti. Pertanto, tutti quelli individuati verranno eliminati automaticamente:

find ./ -name "thumbs.db" | xargs rm

Ad esempio, supponiamo che find localizzi /home/name/thumbs.db, /media/test/thumbs.db e /tmp/thumbs.db. Ebbene, xargs li consegnerà a rm come se fossero argomenti. Cioè, come se avessimo eseguito: rm /home/name/thumbs.db, quindi rm /media/test/thumbs.db e quindi rm /tmp/thumbs.db.