Nella shell, cosa significa "2> & 1"?

In una shell Unix, se voglio combinare stderre stdoutnello stdoutstream per ulteriori manipolazioni, posso aggiungere quanto segue alla fine del mio comando:

2>&1

Quindi, se voglio usare headl'output da g++, posso fare qualcosa del genere:

g++ lots_of_errors 2>&1 | head

così posso vedere solo i primi pochi errori.

Ho sempre difficoltà a ricordare questo, e devo costantemente andare a cercarlo, ed è principalmente perché non capisco completamente la sintassi di questo particolare trucco.

Qualcuno può rompere questo e spiegare carattere per carattere che cosa 2>&1 significa?

Il descrittore di file 1 è lo standard output ( stdout).
Il descrittore di file 2 è l'errore standard ( stderr).

Ecco un modo per ricordare questo costrutto (anche se non è del tutto esatto): in un primo momento, 2>1può apparire come un buon modo per reindirizzare stderra stdout. Tuttavia, verrà effettivamente interpretato come "reindirizzamento stderra un file denominato 1". &indica che ciò che segue è un descrittore di file e non un nome di file. Così il costrutto diventa: 2>&1.

echo test > afile.txt

reindirizza stdout a afile.txt. Questo è lo stesso di fare

echo test 1> afile.txt

Per reindirizzare stderr, fai:

echo test 2> afile.txt

>& è la sintassi per reindirizzare uno stream a un altro descrittore di file: 0 è stdin, 1 è stdout e 2 è stderr.

Puoi reindirizzare stdout a stderr facendo:

echo test 1>&2 # or echo test >&2

O vice versa:

echo test 2>&1

Quindi, in breve ... 2>reindirizza stderr su un file (non specificato), accodando &1reindirizza stderr a stdout.

Alcuni trucchi per il reindirizzamento

Alcune particolarità della sintassi al riguardo possono avere comportamenti importanti. Ci sono alcuni piccoli campioni di circa redirezioni, STDERR, STDOUT, e gli argomenti ordinazione .

1 - Sovrascrivere o aggiungere?

Simbolo >significa reindirizzamento .

• >significa inviare a tutto il file completato , sovrascrivendo il target se esiste (vedere la noclobberfunzione bash al # 3 più avanti).
• >>significa invia oltre a aggiungerebbe al target se esiste.

In ogni caso, il file verrebbe creato se non esistesse.

2 - La riga di comando della shell dipende dall'ordine !!

Per provare questo, abbiamo bisogno di un semplice comando che invierà qualcosa su entrambi gli output :

$ ls -ld /tmp /tnt
ls: cannot access /tnt: No such file or directory
drwxrwxrwt 118 root root 196608 Jan  7 11:49 /tmp

$ ls -ld /tmp /tnt >/dev/null
ls: cannot access /tnt: No such file or directory

$ ls -ld /tmp /tnt 2>/dev/null
drwxrwxrwt 118 root root 196608 Jan  7 11:49 /tmp

(Mi aspettavo di non avere una directory chiamata /tnt, ovviamente;). Bene, ce l'abbiamo !!

Quindi, vediamo:

$ ls -ld /tmp /tnt >/dev/null
ls: cannot access /tnt: No such file or directory

$ ls -ld /tmp /tnt >/dev/null 2>&1

$ ls -ld /tmp /tnt 2>&1 >/dev/null
ls: cannot access /tnt: No such file or directory

L'ultima riga di comando esegue STDERRil dump sulla console e sembra non essere il comportamento previsto ... Ma ...

Se si desidera creare un filtro post su un output, l'altro o entrambi:

$ ls -ld /tmp /tnt | sed 's/^.*$/<-- & --->/'
ls: cannot access /tnt: No such file or directory
<-- drwxrwxrwt 118 root root 196608 Jan  7 12:02 /tmp --->

$ ls -ld /tmp /tnt 2>&1 | sed 's/^.*$/<-- & --->/'
<-- ls: cannot access /tnt: No such file or directory --->
<-- drwxrwxrwt 118 root root 196608 Jan  7 12:02 /tmp --->

$ ls -ld /tmp /tnt >/dev/null | sed 's/^.*$/<-- & --->/'
ls: cannot access /tnt: No such file or directory

$ ls -ld /tmp /tnt >/dev/null 2>&1 | sed 's/^.*$/<-- & --->/'

$ ls -ld /tmp /tnt 2>&1 >/dev/null | sed 's/^.*$/<-- & --->/'
<-- ls: cannot access /tnt: No such file or directory --->

Si noti che l'ultima riga di comando in questo paragrafo è esattamente la stessa del paragrafo precedente, in cui ho scritto sembra non essere il comportamento previsto (quindi, questo potrebbe anche essere un comportamento previsto).

Bene, ci sono alcuni trucchi sui reindirizzamenti, per fare diverse operazioni su entrambi gli output :

$ ( ls -ld /tmp /tnt | sed 's/^/O: /' >&9 ) 9>&2  2>&1  | sed 's/^/E: /'
O: drwxrwxrwt 118 root root 196608 Jan  7 12:13 /tmp
E: ls: cannot access /tnt: No such file or directory

Nota: il &9descrittore si presenta spontaneamente a causa di ) 9>&2.

Addendum: nota! Con la nuova versione dibash( >4.0) c'è una nuova funzionalità e una sintassi più sexy per fare questo tipo di cose:

$ ls -ld /tmp /tnt 2> >(sed 's/^/E: /') > >(sed 's/^/O: /')
O: drwxrwxrwt 17 root root 28672 Nov  5 23:00 /tmp
E: ls: cannot access /tnt: No such file or directory

E infine per una formattazione dell'output così a cascata:

$ ((ls -ld /tmp /tnt |sed 's/^/O: /' >&9 ) 2>&1 |sed 's/^/E: /') 9>&1| cat -n
     1  O: drwxrwxrwt 118 root root 196608 Jan  7 12:29 /tmp
     2  E: ls: cannot access /tnt: No such file or directory

Addendum: nota! Stessa nuova sintassi, in entrambi i modi:

$ cat -n <(ls -ld /tmp /tnt 2> >(sed 's/^/E: /') > >(sed 's/^/O: /'))
     1  O: drwxrwxrwt 17 root root 28672 Nov  5 23:00 /tmp
     2  E: ls: cannot access /tnt: No such file or directory

Dove STDOUTpassa attraverso un filtro specifico, STDERRa un altro e infine entrambi gli output uniti passano attraverso un terzo filtro di comando.

3 - Una parola su noclobberopzione e >|sintassi

Si tratta di sovrascrivere :

Mentre set -o noclobberchiedi a bash di non sovrascrivere alcun file esistente, la >|sintassi ti consente di superare questa limitazione:

$ testfile=$(mktemp /tmp/testNoClobberDate-XXXXXX)

$ date > $testfile ; cat $testfile
Mon Jan  7 13:18:15 CET 2013

$ date > $testfile ; cat $testfile
Mon Jan  7 13:18:19 CET 2013

$ date > $testfile ; cat $testfile
Mon Jan  7 13:18:21 CET 2013

Il file viene sovrascritto ogni volta, bene ora:

$ set -o noclobber

$ date > $testfile ; cat $testfile
bash: /tmp/testNoClobberDate-WW1xi9: cannot overwrite existing file
Mon Jan  7 13:18:21 CET 2013

$ date > $testfile ; cat $testfile
bash: /tmp/testNoClobberDate-WW1xi9: cannot overwrite existing file
Mon Jan  7 13:18:21 CET 2013

Passa con >|:

$ date >| $testfile ; cat $testfile
Mon Jan  7 13:18:58 CET 2013

$ date >| $testfile ; cat $testfile
Mon Jan  7 13:19:01 CET 2013

Disattivando questa opzione e / o chiedendo se è già impostato.

$ set -o | grep noclobber
noclobber           on

$ set +o noclobber

$ set -o | grep noclobber
noclobber           off

$ date > $testfile ; cat $testfile
Mon Jan  7 13:24:27 CET 2013

$ rm $testfile

4 - Ultimo trucco e altro ...

Per reindirizzare entrambi l' output da un determinato comando, vediamo che una sintassi corretta potrebbe essere:

$ ls -ld /tmp /tnt >/dev/null 2>&1

per questo caso speciale , esiste una sintassi del collegamento: &>... o>&

$ ls -ld /tmp /tnt &>/dev/null

$ ls -ld /tmp /tnt >&/dev/null

Nota: se 2>&1esiste, 1>&2è anche una sintassi corretta:

$ ls -ld /tmp /tnt 2>/dev/null 1>&2

4b- Ora, ti farò pensare a:

$ ls -ld /tmp /tnt 2>&1 1>&2  | sed -e s/^/++/
++/bin/ls: cannot access /tnt: No such file or directory
++drwxrwxrwt 193 root root 196608 Feb  9 11:08 /tmp/

$ ls -ld /tmp /tnt 1>&2 2>&1  | sed -e s/^/++/
/bin/ls: cannot access /tnt: No such file or directory
drwxrwxrwt 193 root root 196608 Feb  9 11:08 /tmp/

4c- Se sei interessato a maggiori informazioni

Puoi leggere il manuale eccellente premendo:

man -Len -Pless\ +/^REDIRECTION bash

in un bash console ;-)

Ho trovato questo brillante post sul reindirizzamento: tutto sui reindirizzamenti

Reindirizzare sia l'output standard che l'errore standard su un file

$ command &> file

Questo one-liner utilizza l' &>operatore per reindirizzare entrambi i flussi di output - stdout e stderr - dal comando al file. Questa è la scorciatoia di Bash per reindirizzare rapidamente entrambi i flussi alla stessa destinazione.

Ecco come appare la tabella dei descrittori di file dopo che Bash ha reindirizzato entrambi i flussi:

Come puoi vedere, sia stdout che stderr ora puntano a file. Quindi qualsiasi cosa scritta su stdout e stderr viene scritta file.

Esistono diversi modi per reindirizzare entrambi i flussi sulla stessa destinazione. Puoi reindirizzare ciascuno stream uno dopo l'altro:

$ command> file 2> & 1

Questo è un modo molto più comune per reindirizzare entrambi i flussi su un file. Il primo stdout viene reindirizzato al file, quindi lo stderr viene duplicato per essere uguale allo stdout. Quindi entrambi i flussi finiscono per indicare file.

Quando Bash vede diversi reindirizzamenti, li elabora da sinistra a destra. Esaminiamo i passaggi e vediamo come succede. Prima di eseguire qualsiasi comando, la tabella dei descrittori di file di Bash è simile alla seguente:

Ora Bash elabora il primo reindirizzamento> file. L'abbiamo visto prima e fa riferimento allo stdout al file:

Next Bash vede il secondo reindirizzamento 2> & 1. Non abbiamo mai visto questo reindirizzamento prima. Questo duplica il descrittore di file 2 per essere una copia del descrittore di file 1 e otteniamo:

Entrambi i flussi sono stati reindirizzati al file.

Comunque stai attento qui! scrittura

comando> file 2> & 1

non è lo stesso della scrittura:

$ comando 2> & 1> file

L'ordine dei reindirizzamenti conta in Bash! Questo comando reindirizza solo l'output standard al file. Lo stderr continuerà a stampare sul terminale. Per capire perché ciò accada, eseguiamo di nuovo i passaggi. Quindi, prima di eseguire il comando, la tabella dei descrittori di file è simile alla seguente:

Ora Bash elabora i reindirizzamenti da sinistra a destra. Per prima cosa vede 2> & 1, quindi duplica stderr in stdout. La tabella dei descrittori di file diventa:

Ora Bash vede il secondo reindirizzamento >filee reindirizza stdout su file:

Vedi cosa succede qui? Stdout ora punta al file, ma lo stderr punta ancora al terminale! Tutto ciò che viene scritto su stderr viene ancora stampato sullo schermo! Quindi stai molto, molto attento con l'ordine dei reindirizzamenti!

Nota anche che in Bash, scrivendo

$ command &> file

è esattamente lo stesso di:

$ command> & file

I numeri si riferiscono ai descrittori di file (fd).

• Lo zero è stdin
• Uno è stdout
• Due è stderr

2>&1 reindirizza fd da 2 a 1.

Funziona con qualsiasi numero di descrittori di file se il programma li utilizza.

Puoi guardare /usr/include/unistd.hse li dimentichi:

/* Standard file descriptors.  */
#define STDIN_FILENO    0   /* Standard input.  */
#define STDOUT_FILENO   1   /* Standard output.  */
#define STDERR_FILENO   2   /* Standard error output.  */

Detto questo, ho scritto strumenti C che utilizzano descrittori di file non standard per la registrazione personalizzata in modo da non vederlo a meno che non lo reindirizzi a un file o qualcosa del genere.

Tale costrutto invia il flusso di errori standard ( stderr) alla posizione corrente dell'output standard ( stdout) - questo problema di valuta sembra essere stato trascurato dalle altre risposte.

È possibile reindirizzare qualsiasi handle di output a un altro utilizzando questo metodo, ma viene spesso utilizzato per canalizzare stdoute stderrtrasmettere in un singolo flusso per l'elaborazione.

Alcuni esempi sono:

# Look for ERROR string in both stdout and stderr.
foo 2>&1 | grep ERROR

# Run the less pager without stderr screwing up the output.
foo 2>&1 | less

# Send stdout/err to file (with append) and terminal.
foo 2>&1 |tee /dev/tty >>outfile

# Send stderr to normal location and stdout to file.
foo >outfile1 2>&1 >outfile2

Nota che l'ultimo non verrà indirizzato stderra outfile2: lo reindirizza a ciò che stdoutera quando è stato riscontrato l'argomento ( outfile1) e quindi reindirizza stdouta outfile2.

Ciò consente alcuni stratagemmi piuttosto sofisticati.

2>&1è un costrutto shell POSIX. Ecco una ripartizione, token per token:

2: Descrittore del file di output " Errore standard ".

>&: Duplica un operatore Descrittore file di output (una variante dell'operatore Reindirizzamento output> ). Dato [x]>&[y], il descrittore di file indicato da xviene creato come copia del descrittore di file di output y.

1Descrittore di file di output " Standard output ".

L'espressione 2>&1copia il descrittore di file 1nella posizione 2, quindi qualsiasi output scritto in 2("errore standard") nell'ambiente di esecuzione passa allo stesso file originariamente descritto da 1("output standard").

Ulteriori spiegazioni:

File Descriptor : "Un numero intero univoco e non negativo per processo utilizzato per identificare un file aperto a scopo di accesso al file."

Output / errore standard : fare riferimento alla seguente nota nella sezione Reindirizzamento della documentazione della shell:

I file aperti sono rappresentati da numeri decimali che iniziano con zero. Il valore più grande possibile è definito dall'implementazione; tuttavia, tutte le implementazioni devono supportare almeno da 0 a 9, incluso, per l'uso da parte dell'applicazione. Questi numeri sono chiamati "descrittori di file". I valori 0, 1 e 2 hanno un significato speciale e usi convenzionali e sono implicati da alcune operazioni di reindirizzamento; sono indicati rispettivamente come input standard, output standard ed errore standard. I programmi di solito prendono l'input dall'input standard e scrivono l'output sull'output standard. I messaggi di errore sono generalmente scritti su errori standard. Gli operatori di reindirizzamento possono essere preceduti da una o più cifre (senza caratteri intermedi consentiti) per designare il numero del descrittore di file.

2 è l'errore standard della console.

1 è l'output standard della console.

Questo è lo standard Unix e Windows segue anche POSIX.

Ad esempio quando corri

perl test.pl 2>&1

l'errore standard viene reindirizzato all'output standard, quindi è possibile visualizzare entrambi gli output insieme:

perl test.pl > debug.log 2>&1

Dopo l'esecuzione, è possibile visualizzare tutto l'output, inclusi gli errori, in debug.log.

perl test.pl 1>out.log 2>err.log

Quindi l'output standard passa a out.log e l'errore standard a err.log.

Ti consiglio di provare a capirli.

Per rispondere alla tua domanda: prende qualsiasi output di errore (normalmente inviato a stderr) e lo scrive nell'output standard (stdout).

Ciò è utile, ad esempio "altro" quando è necessario il paging per tutto l'output. Alcuni programmi come stampare le informazioni sull'utilizzo in stderr.

Per aiutarti a ricordare

• 1 = output standard (dove i programmi stampano output normale)
• 2 = errore standard (dove i programmi stampano errori)

"2> & 1" indica semplicemente tutto ciò che è stato inviato a stderr, invece a stdout.

Consiglio anche di leggere questo post sull'errore di reindirizzamento in cui questo argomento è trattato in dettaglio.

Dal punto di vista di un programmatore, significa esattamente questo:

dup2(1, 2);

Vedi la pagina man .

Capire che 2>&1è una copia spiega anche perché ...

command >file 2>&1

... non è lo stesso di ...

command 2>&1 >file

Il primo invierà entrambi i flussi a file, mentre il secondo invierà errori stdoute l'output ordinario in file.

L'ho trovato molto utile se sei un principiante, leggi questo

Aggiornamento:
In Linux o Unix System ci sono due posti in cui i programmi inviano l'output: Standard output (stdout) e Standard Error (stderr) . Puoi reindirizzare questi output su qualsiasi file.

Ad esempio, se non si esegue

ls -a > output.txt

alcuna operazione, nella console non verrà stampato tutto l'output (stdout) verrà reindirizzato al file di output.

E se provi a stampare il contenuto di qualsiasi file che non esce significa che l'output sarà un errore come se tu stampassi test.txt che non è presente nella directory corrente L'

cat test.txt > error.txt

output sarà

cat: test.txt :No such file or directory

Ma il file error.txt sarà vuoto perché reindirizziamo lo stdout a un file non stderr.

quindi abbiamo bisogno di un descrittore di file (un descrittore di file non è altro che un numero intero positivo che rappresenta un file aperto. Puoi dire che il descrittore è un ID univoco del file) per dire alla shell quale tipo di output stiamo inviando al file. Nel sistema Unix / Linux 1 è per stdout e 2 per stderr .

quindi ora se lo fai

ls -a 1> output.txtsignifica che stai inviando output standard (stdout) a output.txt.

e se lo fai

cat test.txt 2> error.txtsignifica che stai inviando l'errore standard (stderr) a error.txt.

&1viene utilizzato per fare riferimento al valore del descrittore di file 1 (stdout).

Ora al punto 2>&1significa "Reindirizzare lo stderr nello stesso posto in cui stiamo reindirizzando lo stdout"

Ora puoi farlo

cat maybefile.txt > output.txt 2>&1

sia l'output standard (stdout) sia l'errore standard (stderr) verranno reindirizzati su output.txt.

Grazie a Ondrej K. per la segnalazione

Persone, ricordate sempre paxdiablo suggerimento s' circa la corrente posizione del bersaglio reindirizzamento ... E è importante.

Il mio mnemonico personale per l' 2>&1operatore è questo:

• Pensa &come significato 'and'o 'add'(il personaggio è un ampers - e non è vero?)
• Quindi diventa: 'reindirizza 2(stderr) dove 1(stdout) è già / attualmente è e aggiungi entrambi i flussi' .

Lo stesso mnemonico funziona anche per l'altro reindirizzamento frequentemente usato 1>&2:

• Pensa al &significato ando add... (hai l'idea della e commerciale, sì?)
• Quindi diventa: 'reindirizza 1(stdout) dove 2(stderr) è già / attualmente è e aggiungi entrambi i flussi' .

E ricorda sempre: devi leggere le catene di reindirizzamenti "dalla fine", da destra a sinistra ( non da sinistra a destra).

Reindirizzamento dell'input

Il reindirizzamento dell'input provoca l'apertura del file il cui nome deriva dall'espansione della parola per la lettura sul descrittore di file n, oppure l'input standard (descrittore di file 0) se n non è specificato.

Il formato generale per reindirizzare l'input è:

[n]<word

Reindirizzamento dell'output

Il reindirizzamento dell'output provoca l'apertura del file il cui nome deriva dall'espansione della parola per la scrittura sul descrittore di file n o l'output standard (descrittore di file 1) se n non è specificato. Se il file non esiste, viene creato; se esiste, viene troncato a dimensione zero.

Il formato generale per il reindirizzamento dell'output è:

[n]>word

Spostamento dei descrittori di file

L'operatore di reindirizzamento,

[n]<&digit-

sposta la cifra del descrittore di file nel descrittore di file n o l'input standard (descrittore di file 0) se n non è specificato. la cifra viene chiusa dopo essere stata duplicata su n.

Allo stesso modo, l'operatore di reindirizzamento

[n]>&digit-

sposta la cifra del descrittore di file nel descrittore di file n o l'output standard (descrittore di file 1) se n non è specificato.

Rif:

man bash

Digita /^REDIRECTper individuare la redirectionsezione e scopri di più ...

Una versione online è qui: 3.6 Reindirizzamenti

PS:

Molte volte, è manstato il potente strumento per imparare Linux.

A condizione che /foonon esista sul tuo sistema e /tmp...

$ ls -l /tmp /foo

stamperà il contenuto di /tmpe stamperà un messaggio di errore per/foo

$ ls -l /tmp /foo > /dev/null

invierà il contenuto di /tmpad /dev/nulle stampare un messaggio di errore per/foo

$ ls -l /tmp /foo 1> /dev/null

farà esattamente lo stesso (nota 1 )

$ ls -l /tmp /foo 2> /dev/null

stamperà il contenuto /tmpe invierà il messaggio di errore a/dev/null

$ ls -l /tmp /foo 1> /dev/null 2> /dev/null

invierà sia l'elenco che il messaggio di errore a /dev/null

$ ls -l /tmp /foo > /dev/null 2> &1

è una scorciatoia

È come passare l'errore allo stdout o al terminale.

Cioè, cmdnon è un comando:

$cmd 2>filename
cat filename

command not found

L'errore viene inviato al file in questo modo:

2>&1

L'errore standard viene inviato al terminale.

0 per input, 1 per stdout e 2 per stderr.

Un suggerimento : somecmd >1.txt 2>&1è corretto, mentre somecmd 2>&1 >1.txtè totalmente sbagliato senza alcun effetto!

unix_commands 2>&1

Questo è usato per stampare errori sul terminale.

Quanto segue illustra il processo

• Quando vengono generati errori, vengono scritti nell'indirizzo di memoria errori standard &2"buffer", da cui fa 2riferimento il flusso di errori standard .
• Quando viene prodotto, l'output viene scritto nell'indirizzo di memoria standard &1"buffer", da cui fa 1riferimento il flusso di output standard .

Prendi quindi il unix_commandsflusso di errori standard 2e reindirizza >il flusso (di errori) all'indirizzo di memoria di output standard &1, in modo che vengano trasmessi in streaming al terminale e stampati.