Tutti gli usi che teeio abbia mai visto erano tali:

 do_something | tee -a logfile

O:

do_something_else | tee logfile

È stato teeinventato per coloro che non sanno che puoi fare lo stesso con i reindirizzamenti del tubo shell? Ad esempio:

do_something >> logfile

O:

do_something_else > logfile

È praticamente lo stesso e richiede meno colpi di tastiera per scrivere. In quali funzioni nascoste non vedo tee?

Quello che non vedi è che do_something | tee -a logfilemette l'output in logfile e to stdout, mentre lo do_something >> logfileinserisce solo nel file di log.

Lo scopo teeè quello di produrre uno scenario di input singolo, output multiplo - proprio come in un incrocio a "T".

MODIFICARE

Ci sono stati commenti su come teeconsentire un uso più apparente di sudo. Questa è questo il punto: cat, ddo forse meglio bufferfornire questa possibilità con la migliore prestazione, se non hai bisogno di uscite multiple. Utilizzare teeper ciò che è progettato, non per ciò che "può anche fare"

Tee non è inutile

Forse lo sapevi comunque? In caso contrario, continua a leggere! O se sai come funziona, ma non sei sicuro del motivo per cui esiste, salta alla fine per vedere come si adatta alla filosofia Unix.

Qual è lo scopo di tee?

Nella sua forma più semplice, prende i dati sull'input standard e li scrive sull'output standard e su uno (o più) file. È stato paragonato a un raccordo a T idraulico nel modo in cui divide un ingresso in due uscite (e due direzioni).

Esempi

Facciamo il tuo primo esempio:

do_something | tee -a logfile

Questo prende l'output di do_somethinge lo aggiunge al file di log, mostrandolo allo stesso tempo all'utente. In effetti, la pagina di Wikipedia sutee ha questo come secondo esempio:

Per visualizzare e aggiungere l'output di un comando a un file esistente:

  lint program.c | tee -a program.lint

Questo visualizza l'output standard del comando lint program.c sul computer e allo stesso tempo ne aggiunge una copia alla fine del file program.lint. Se il file program.lint non esiste, viene creato.

Il prossimo esempio ha un altro uso: escalation delle autorizzazioni :

Per consentire l'escalation delle autorizzazioni:

cat ~/.ssh/id_rsa.pub | ssh admin@server "sudo tee -a /root/.ssh/authorized_keys2 > /dev/null"

Questo esempio mostra il tee utilizzato per bypassare una limitazione intrinseca nel sudocomando. sudonon è in grado di reindirizzare l'output standard in un file. Scaricando il suo flusso standard in /dev/null, eliminiamo anche l'output speculare nella console. Il comando sopra fornisce all'utente root l'accesso corrente a un server tramite ssh, installando la chiave pubblica dell'utente nell'elenco di autorizzazioni della chiave del server.

O forse vuoi prendere l'output di un comando, scriverlo da qualche parte e anche usarlo come input per un altro comando?

È inoltre possibile utilizzare il comando tee per memorizzare l'output di un comando su un file e reindirizzare lo stesso output di un input su un altro comando.

Il comando seguente eseguirà un backup delle voci crontab e passerà le voci crontab come input per il comando sed che effettuerà la sostituzione. Dopo la sostituzione, verrà aggiunto come nuovo cron job.

$ crontab -l | tee crontab-backup.txt | sed 's/old/new/' | crontab –

(credito per esempi di utilizzo del comando Tee )

Tee funziona con la filosofia Unix:

Scrivi programmi che fanno una cosa e la fanno bene. Scrivi programmi per lavorare insieme. Scrivi programmi per gestire flussi di testo, perché questa è un'interfaccia universale.

(Ringraziamenti di base della filosofia Unix )

tee si adatta a tutti questi:

• fa una cosa: crea una copia aggiuntiva di input
• funziona con altri programmi perché è la colla (o un pezzo idraulico a "T" se preferisci) che consente ad altri programmi di lavorare insieme come negli esempi sopra
• lo fa manipolando un flusso di testo fornito sull'input standard

È praticamente lo stesso e richiede meno colpi di tastiera per scrivere.

Non è affatto lo stesso ...

Quanto segue sembra essere in qualche modo equivalente, ma non lo sono:

$ echo "hi" > test.txt

$ echo "hi" | tee test.txt
hi

La differenza fondamentale è che il primo ha scritto i dati solo nel file indicato, mentre il secondo ha scritto hinel terminale ( stdout) e nel file indicato, come mostrato di seguito:

teeti consente di scrivere i dati in un file e di usarli in una pipeline successiva, permettendoti di fare cose utili - come mantenere i dati a metà strada attraverso una pipeline:

grep '^look ' interesting_file.txt \
  | tee interesting_lines.txt \
  | sort

In alternativa, è possibile scrivere su un file con privilegi elevati, senza assegnare privilegi elevati all'intera pipeline (qui echoviene eseguito come utente, mentre teescrive nel file come root):

echo 0 \
  | sudo tee /proc/sys/net/ipv4/ip_forward

Con tee, puoi scrivere su molti file ( e stdout ):

echo "hi" \
  | tee a.txt b.txt

È anche possibile utilizzare execcon teeper registrare tutto l'output di uno script in un file, consentendo comunque a un osservatore ( stdout) di vedere i dati:

exec > >( tee output.log )

Questa è una maglietta:

Un raccordo a forma di T. Ha un'entrata e due prese separate.
In altre parole, divide una pipa in due; come un bivio.

Allo stesso modo, teeè un pipe ( |) che consente di reindirizzare l'input standard a due output separati.

Esempio
Dire ad esempio che si digita ls /.
Otterrai un output simile a:

Applications    Network     Users       bin        dev      net      private    tmp         var
Library         System      Volumes     cores      etc      home     opt        sbin        usr

Reindirizza l'output su un file di testo ls / > ls.txte nessun output viene visualizzato nella shell, solo nel file di testo risultante.

Vuoi vedere l'output E passarlo contemporaneamente a un file di testo?
Aggiungi a teealla tua pipe ( |) cioè:ls / | tee ls.txt

Confronta i due:

ls /          >          ls.txt
ls /        | tee        ls.txt

No. Ti capita di menzionare uno dei pochi esempi in cui potresti effettivamente reindirizzare al file usando >e >>operatori.

Ma Tee può fare molto di più. Poiché esegui il pipe ad esso, puoi quindi eseguire il pipe a qualcos'altro.

Un buon esempio è elencato nella pagina di Wikipedia :

find "4DOS" wikipedia.txt | tee 4DOS.txt | sort > 4DOSsorted.txt

Fondamentalmente, puoi eseguire il pipe su Tee, quindi puoi eseguire il pipe da Tee a qualcos'altro. Se tutto ciò che vuoi fare è scrivere un file di registro, sì, allora non hai davvero bisogno di Tee.

teeè tutt'altro che inutile. Lo uso sempre e sono contento che esista. È uno strumento molto utile se si dispone di una pipeline che si desidera suddividere. Un esempio molto semplice è che hai qualche directory $dche vuoi tarare e vuoi anche cancellarla perché sei paranoico (come me) e non ti fidi del supporto di memorizzazione per conservare i dati in modo affidabile. Si potrebbe scrivere sul disco e poi hash, ma che sarebbe fallire se l'archivio viene danneggiato prima di essere hash. Inoltre, dovresti leggerlo e se lavori su file di diverse centinaia di GB, saprai che non vorrai davvero rileggerli se non è necessario.

Quindi quello che faccio è semplicemente questo:

tar -c "$d" | tee >(sha256sum) >(cat > "$d"".tar") > /dev/null

Crea la pallina di catrame e la convoglia per collegarla a T che poi la convoglia a due sotto-shell, in una delle quali è con hash e nell'altra in cui è scritta sul disco.

È fantastico anche se vuoi eseguire diverse operazioni su un file di grandi dimensioni:

< file.tar.gz tee >(sha256sum) >(tar -xz) /other/storage/location/file.tar.gz > /dev/null

Legge il file una volta, lo esegue l'hashing (in modo da poter verificare se è ancora come dovrebbe essere), lo estrae e lo copia in una posizione diversa. Non è necessario leggerlo tre volte per quello.

Nitpick sulla risposta di @ bertieb che dice Questo esempio mostra che tee viene usato per bypassare una limitazione intrinseca nel comando sudo. sudo non è in grado di reindirizzare l'output standard in un file.

Non ci sono limiti intrinseci, solo un malinteso su come viene elaborato il comando.

Esempio:

sudo echo 0 > /proc/sys/net/ipv4/ip_forward

La shell corrente analizza la riga di comando. Trova il reindirizzamento dell'output e lo esegue. Quindi esegue il comando, che è il sudoe fornisce la riga di comando rimanente come argomenti al comando eseguito. Se la shell corrente non ha i permessi di root, il reindirizzamento dell'output fallirà.

echo 0 | sudo tee /proc/sys/net/ipv4/ip_forward

Questo funziona perché il reindirizzamento dell'output è rinviato al teecomando, che a quel punto ha i permessi di root perché è stato eseguito tramite sudo.

sudo bash -c "echo 0 > /proc/sys/net/ipv4/ip_forward"

Questo funziona perché la shell che esegue il reindirizzamento ha i permessi di root.

Come altri hanno già detto, il piping dell'output al teecomando scrive tale output su un file e su stdout.

Uso spesso teequando desidero catturare l'output di un comando che richiede molto tempo per essere eseguito, mentre voglio anche controllare visivamente l'output quando il comando lo rende disponibile. In questo modo, non devo aspettare che il comando finisca l'esecuzione prima di ispezionare l'output.

Ciò che sembra non essere stato ancora menzionato (a meno che non me lo sia perso), è che il teecomando può anche scrivere su più file contemporaneamente. Per esempio:

ls *.png | tee a.txt b.txt

scriverà tutti i *.pngfile nella directory corrente in due file diversi ( a.txte b.txt) contemporaneamente.

In effetti, puoi digitare il testo in diversi file contemporaneamente con teequesto:

$ tee --append a.txt b.txt c.txt d.txt
These lines are appended to four different files,
and are also written to stdout.
CTRL-D

L'uso più comune di tee è vedere il testo sul terminale mentre lo si invia al file (o ai file). La formulazione della tua domanda presuppone che tu scriva sempre e solo testo nei file di registro. Ho degli script che scrivono elenchi di nomi di file o di directory per attivare i file (che devono essere elaborati in modo asincrono da altri script) e utilizzo Tee per inviare lo stesso contenuto a stdout. Tutto lo stdout è diretto ai registri. Quindi ho il mio testo dove lo voglio e ho una voce di registro che registra ciò che ho fatto, tutto da una singola istruzione "echo"

tee è anche il metodo migliore in Unix per creare più file identici. Lo uso occasionalmente per creare più file vuoti, come questo ...

:|tee file01 file02 file03

Immagina di voler scrivere l'output di un comando in un file di registro E stampare su stdout. Quando è necessario farlo contemporaneamente, è necessario tee.

Un caso d'uso è avere script di build che scrivano l'intera build su stdout (ad esempio per Jenkins) ma allo stesso tempo cose importanti in un file di registro separato (per e-mail di riepilogo).

Inizierai davvero a perdere teequando devi script in Windows. Non c'è teee questo è davvero fastidioso.