En el caparazón, ¿qué significa "2> & 1"?

En un shell de Unix, si quiero combinar stderr y stdout en el stdout stream para una mayor manipulación, puedo agregar lo siguiente al final de mi comando:

2>&1

Entonces, si quiero usar head en la salida de g++, Puedo hacer algo como esto:

g++ lots_of_errors 2>&1 | head

para que pueda ver solo los primeros errores.

Siempre tengo problemas para recordar esto, y constantemente tengo que buscarlo, y es principalmente porque no entiendo completamente la sintaxis de este truco en particular.

¿Alguien puede romper esto y explicar carácter por carácter lo que 2>&1 ¿medio?

preguntado el 03 de mayo de 09 a las 19:05

@dbr No creo que sea solo bash, creo que es una cosa de bourne shell; de ahí sh, bash, ksh, ash, dash, etc.-

Esto es parte del párrafo de redirección que describe los shells compatibles con POSIX, o shell POSIX para abreviar. ksh es un shell POSIX, por ejemplo. Ver:pubs.opengroup.org/onlinepubs/009695399/utilities/… -

Esta construcción también funciona en Windows. -

Generalmente es mejor hacerlo 2>&1 que 2> / dev / null ;-)-

Pensé en mencionar eso |& es taquigrafía para 2>&1 | si está usando zsh. No puedo decir si eso se aplica a otras conchas similares a bourne o si es una característica única de Zsh. -

18 Respuestas

El descriptor de archivo 1 es la salida estándar (stdout).
El descriptor de archivo 2 es el error estándar (stderr).

Aquí hay una forma de recordar esta construcción (aunque no es del todo precisa): al principio, 2>1 puede parecer una buena forma de redireccionar stderr a stdout. Sin embargo, en realidad se interpretará como "redireccionamiento stderr a un archivo llamado 1". & indica que lo que sigue y precede es un descriptor de archivo y no un nombre de archivo. Entonces la construcción se convierte en: 2>&1.

Imagine >& como operador de fusión de redireccionamiento.

Respondido 18 Oct 20, 03:10

pero entonces no debería ser mejor &2>&1? - dokaspar

@Dominik: No, & solo se interpreta como "descriptor de archivo" en el contexto de las redirecciones. Escritura command &2>& se analiza como command & y 2>&1, es decir, "correr command en segundo plano, luego ejecute el comando 2 y redirigir su stdout a su stdout ". - adam rosenfield

¿Por qué eligieron cosas tan arcanas como esta? Sólo curioso. - tostada de coma

Pero, ¿cómo redirigiría stderr a un archivo llamado '& 1'? - Martín Fixman

@Martin: 2>'&1' - usuario1247058

echo test > afile.txt

redirige stdout a afile.txt. Esto es lo mismo que hacer

echo test 1> afile.txt

Para redirigir stderr, haz lo siguiente:

echo test 2> afile.txt

>& es la sintaxis para redirigir una secuencia a otro descriptor de archivo: 0 es stdin, 1 es stdout y 2 es stderr.

Puede redirigir stdout a stderr haciendo:

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

O viceversa:

echo test 2>&1

Entonces, en resumen ... 2> redirige stderr a un archivo (no especificado), agregando &1 redirige stderr a stdout.

Respondido 04 Jul 18, 21:07

Esto tiene algún sentido para tí, java ... 2&1 >> data.log, Vi a uno de mis colegas hacer esto? - tanga pham

@Harry que parece un shell que no es bash, o un error tipográfico. cmd 2>&1 >> somefile.log agregará stdout / stderr a un archivo; es básicamente lo mismo que el anterior, con >> file para anexar - dbr

@dbr cmd 2>&1 >>file no redirige stderr al archivo, pero cmd >> file 2>&1 lo hace. El orden importa. En el primer caso, stderr se redirige a stdout del shell (posiblemente un tty si el comando se ingresa de forma interactiva), y luego stdout se dirige al archivo. En el segundo caso, stdout se dirige al archivo y luego stderr se dirige al mismo lugar. - Guillermo Pursell

Me gusta la respuesta anterior, pero podría ser un poco más clara. "2> & 1" redirige stderr al destino de stdout. Entonces, si tiene algo como "ls -l >> directoryContents 2> & 1", el resultado será un archivo llamado directoryContents que tendrá el contenido del directorio de trabajo adjunto. Si hay algún error en la ejecución: los mensajes de error también se agregarán al archivo directoryContents, a medida que ocurran. - máximo oeste

Is 0(or 1,2)>&0(or 1,2) como una opción para controlar la salida? Es echo test >test.log 2>&1 mismo como echo test 2>&1 >test.log? - simin jie

Algunos trucos sobre la redirección

Algunas particularidades de sintaxis sobre esto pueden tener comportamientos importantes. Hay algunas pequeñas muestras sobre redirecciones, STDERR, STDOUTy argumentos pedido.

1 - ¿Sobreescritura o anexión?

Símbolo > significa redirección.

  • > significa enviar a un archivo completo completo, sobrescribiendo el destino si existe (consulte noclobber función de bash en #3 luego).
  • >> significa enviar además de se agregaría al objetivo si existe.

En cualquier caso, el archivo se crearía si no existiera.

2 - El línea de comando de shell depende de la orden !!

Para probar esto, necesitamos un comando simple que enviará algo en ambas salidas:

$ 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

(Esperando que no tenga un directorio llamado /tnt, por supuesto ;). Bueno, lo tenemos !!

Entonces, veamos:

$ 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

Los últimos volcados de línea de comando STDERR a la consola, y parece que no es el comportamiento esperado ... Pero ...

Si quieres hacer algo post filtrado Introducción estándar salida, error salida o ambos:

$ 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 --->

Observe que la última línea de comando en este párrafo es exactamente la misma que en el párrafo anterior, donde escribí parece no ser el comportamiento esperado (entonces, esto podría incluso ser un comportamiento esperado).

Bueno, hay algunos trucos sobre las redirecciones, para haciendo diferentes operaciones en ambas salidas:

$ ( 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:: &9 descriptor ocurriría espontáneamente debido a ) 9>&2.

Anexo: nota! Con la nueva versión de (>4.0) hay una nueva característica y una sintaxis más atractiva para hacer este tipo de cosas:

$ 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

Y finalmente para un formato de salida en cascada de este tipo:

$ ((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

Anexo: nota! Misma nueva sintaxis, en ambos sentidos:

$ 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

Dónde STDOUT pasar por un filtro específico, STDERR a otro y finalmente ambas salidas fusionadas pasan por un tercer filtro de comando.

3 - Una palabra sobre noclobber opción y >| sintaxis

Eso es sobre sobrescribir:

Aunque la set -o noclobber instruir a bash a no sobrescribir cualquier archivo existente, el >| la sintaxis le permite superar esta limitación:

$ 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

El archivo se sobrescribe cada vez, bueno ahora:

$ 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

Pasar 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

Desmarcando esta opción y / o preguntando si ya está configurada.

$ 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 - Último truco y más ...

Para redireccionar ambas salida de un comando dado, vemos que una sintaxis correcta podría ser:

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

para esto especial caso, hay una sintaxis de atajo: &> ... o >&

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

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

Nota: si 2>&1 existe, 1>&2 es una sintaxis correcta también:

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

4b- Ahora te dejo pensar en:

$ 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- Si te interesa más, información

Puede leer el buen manual presionando:

man -Len -Pless\ +/^REDIRECTION bash

en un parche de consola ;-)

Respondido el 26 de enero de 21 a las 18:01

Encontré esta publicación brillante sobre la redirección: Todo sobre redirecciones

Redirigir tanto la salida estándar como el error estándar a un archivo

$ comando &> archivo

Este one-liner usa el &> operador para redirigir ambos flujos de salida, stdout y stderr, del comando al archivo. Este es el atajo de Bash para redirigir rápidamente ambas transmisiones al mismo destino.

Así es como se ve la tabla de descriptores de archivos después de que Bash haya redirigido ambas transmisiones:

Ingrese la descripción de la imagen aquí

Como puede ver, tanto stdout como stderr ahora apuntan a file. Entonces, cualquier cosa que se escriba en stdout y stderr se escribe en file.

Hay varias formas de redirigir ambas transmisiones al mismo destino. Puede redirigir cada transmisión una tras otra:

$ comando> archivo 2> & 1

Esta es una forma mucho más común de redirigir ambas secuencias a un archivo. Primero stdout se redirige al archivo, y luego stderr se duplica para que sea el mismo que stdout. Entonces ambas corrientes terminan apuntando a file.

Cuando Bash ve varias redirecciones, las procesa de izquierda a derecha. Repasemos los pasos y veamos cómo sucede. Antes de ejecutar cualquier comando, la tabla de descriptores de archivos de Bash se ve así:

Ingrese la descripción de la imagen aquí

Ahora Bash procesa el primer archivo de redirección. Hemos visto esto antes y hace que stdout apunte a archivo:

Ingrese la descripción de la imagen aquí

Siguiente Bash ve la segunda redirección 2> & 1. No hemos visto esta redirección antes. Este duplica el descriptor de archivo 2 para que sea una copia del descriptor de archivo 1 y obtenemos:

Ingrese la descripción de la imagen aquí

Ambas transmisiones se han redirigido al archivo.

Sin embargo, ¡ten cuidado aquí! Escritura

comando> archivo 2> & 1

no es lo mismo que escribir:

$ comando 2> & 1> archivo

¡El orden de las redirecciones es importante en Bash! Este comando redirige solo la salida estándar al archivo. El stderr seguirá imprimiendo en el terminal. Para entender por qué sucede eso, repasemos los pasos nuevamente. Entonces, antes de ejecutar el comando, la tabla de descriptores de archivos se ve así:

Ingrese la descripción de la imagen aquí

Ahora Bash procesa las redirecciones de izquierda a derecha. Primero ve 2> & 1 por lo que duplica stderr a stdout. La tabla de descriptores de archivos se convierte en:

Ingrese la descripción de la imagen aquí

Ahora Bash ve la segunda redirección, >file, y redirige stdout al archivo:

Ingrese la descripción de la imagen aquí

¿Ves lo que pasa aquí? Stdout ahora apunta al archivo, ¡pero el stderr todavía apunta a la terminal! ¡Todo lo que se escribe en stderr aún se imprime en la pantalla! ¡Así que tenga mucho, mucho cuidado con el orden de las redirecciones!

También tenga en cuenta que en Bash, escribir

$ comando &> archivo

es exactamente lo mismo que:

$ comando> & archivo

Respondido 05 Jul 18, 04:07

Los dos últimos son diferentes si "comando" termina en un número, ya que entonces se toma como descriptor de archivo opcional para >& - MM

¡Muy bonito dibujo y explicación! ¿Podría explicarnos qué significa realmente "duplicar"? Usted mencionó, "Este [2> & 1] duplica el descriptor de archivo 2 para ser una copia del descriptor de archivo 1". Parece que stderr se duplica en stdout. Pero si es el caso, ¿debería también ver un error? /dev/tty0? - HCSF

Esta es una explicación muy agradable con visual. Si soy yo quien hace esta pregunta, la marcaré como respuesta aceptada. - MaXi32

Los números se refieren a los descriptores de archivo (fd).

  • Cero es stdin
  • Uno de ellos es stdout
  • Dos es stderr

2>&1 redirige fd 2 a 1.

Esto funciona para cualquier número de descriptores de archivo si el programa los usa.

Puedes mirar /usr/include/unistd.h si los olvidas:

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

Dicho esto, he escrito herramientas C que usan descriptores de archivo no estándar para el registro personalizado, por lo que no lo ve a menos que lo redirija a un archivo o algo así.

respondido 06 nov., 12:01

Esa construcción envía el flujo de error estándar (stderr) al corriente ubicación de la salida estándar (stdout) - este problema monetario parece haber sido ignorado por las otras respuestas.

Puede redirigir cualquier identificador de salida a otro utilizando este método, pero se usa con mayor frecuencia para canalizar stdout y stderr se transmite en un solo flujo para su procesamiento.

Estos son algunos ejemplos del soporte que puede requerir:

# 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

Tenga en cuenta que ese último no de reservas stderr a outfile2 - lo redirige a lo que stdout fue cuando se encontró el argumento (outfile1) y luego redirecciones stdout a outfile2.

Esto permite algunos trucos bastante sofisticados.

Respondido el 26 de junio de 09 a las 09:06

Aunque ese último ejemplo sería mucho más claro como: foo> outfile2 2> outfile1 - Michael Cramer

Más claro, sí, pero eso no mostraría la naturaleza "posicional" de la redirección. El ejemplo es artificial, ya que generalmente no es útil hacer esto en una sola línea; el método se vuelve realmente útil cuando diferentes partes son responsables de las diferentes partes de la redirección. Por ejemplo, cuando un script hace un bit de redirección y lo ejecuta con otro bit. - paxdiablo

Me acabo de dar cuenta de que el último ejemplo también resuelve una confusión de larga data que tenía con respecto a por qué esto: some_program 2>&1 > /dev/null no funciona así: some_program > /dev/null 2>&1. - snapfractalpop

Su comentario sobre el último ejemplo vale sus letras en oro :-) Nunca pensé que estos argumentos de redireccionamiento fueran posicionales ... Creo que es muy importante saberlo. - Nils-o-mat

2 es el error estándar de la consola.

1 es la salida estándar de la consola.

Este es el Unix estándar, y Windows también sigue el POSIX.

Por ejemplo, cuando corres

perl test.pl 2>&1

el error estándar se redirige a la salida estándar, por lo que puede ver ambas salidas juntas:

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

Después de la ejecución, puede ver todos los resultados, incluidos los errores, en el debug.log.

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

Luego, la salida estándar pasa a out.log y el error estándar a err.log.

Le sugiero que intente comprenderlos.

Respondido 05 Jul 18, 04:07

La segunda muestra es incorrecta: como orden de precedencia STDERR se redirige a SALIDA ESTÁNDAR, solo por defecto SALIDA ESTÁNDAR será escrito a registro de depuración (¿No estás registrado como STDERR) ver mi respuesta (el párrafo # 2)! Para asegurar ambas para ser redirigido al mismo archivo, debe invertir las directivas de redirección: perl test.pl > debug.log 2>&1 - F.Hauri

2>&1 es una construcción de shell POSIX. Aquí hay un desglose, ficha por ficha:


2"Error estándar"descriptor de archivo de salida.

>&: Duplicar un descriptor de archivo de salida operador (una variante de Redirección de salida operador >). Dado [x]>&[y], el descriptor de archivo indicado por x está hecho para ser una copia del descriptor del archivo de salida y.

1 "Salida estándar"descriptor de archivo de salida.

La expresion 2>&1 copia descriptor de archivo 1 a la ubicación 2, por lo que cualquier salida escrita en 2 ("error estándar") en el entorno de ejecución va al mismo archivo descrito originalmente por 1 ("salida estándar").


Explicación adicional:

Descriptor de archivo: "Un entero no negativo único por proceso que se utiliza para identificar un archivo abierto con el fin de acceder al archivo".

Salida / error estándar: Consulte la siguiente nota en el Redirección sección de la documentación del shell:

Los archivos abiertos están representados por números decimales que comienzan con cero. El valor más grande posible está definido por la implementación; sin embargo, todas las implementaciones admitirán al menos de 0 a 9, inclusive, para su uso por la aplicación. Estos números se denominan "descriptores de archivos". Los valores 0, 1 y 2 tienen un significado especial y usos convencionales y están implícitos en ciertas operaciones de redireccionamiento; se denominan entrada estándar, salida estándar y error estándar, respectivamente. Los programas generalmente toman su entrada de la entrada estándar y escriben la salida en la salida estándar. Los mensajes de error generalmente se escriben en error estándar. Los operadores de redirección pueden ir precedidos de uno o más dígitos (sin que se permitan caracteres intermedios) para designar el número de descriptor de archivo.

Respondido el 25 de diciembre de 16 a las 06:12

Para responder a su pregunta: toma cualquier salida de error (normalmente enviada a stderr) y la escribe en la salida estándar (stdout).

Esto es útil, por ejemplo, con 'más' cuando necesita paginación para todos los resultados. Algunos programas, como imprimir información de uso en stderr.

Para ayudarte a recordar

  • 1 = salida estándar (donde los programas imprimen salida normal)
  • 2 = error estándar (donde los programas imprimen errores)

"2> & 1" simplemente apunta todo lo enviado a stderr, a stdout en su lugar.

También recomiendo leer esta publicación sobre la redirección de errores donde este tema se cubre con todo detalle.

contestado el 04 de mayo de 09 a las 00:05

Encontré esto muy útil si eres un principiante leer este

Actualizar:
En el sistema Linux o Unix, hay dos lugares a los que los programas envían la salida: Salida estándar (stdout) y error estándar (stderr)Puede redirigir estos resultados a cualquier archivo.

Como si hicieras esto

ls -a > output.txt

No se imprimirá nada en la consola toda la salida (salida estándar) se redirige al archivo de salida.

Y si intenta imprimir el contenido de cualquier archivo que no sale significa que la salida será un error como si imprime test.txt que no está presente en el directorio actual

cat test.txt > error.txt

La salida será

cat: test.txt :No such file or directory

Pero el archivo error.txt estará vacío porque redirigimos el stdout a un archivo que no es stderr.

así que necesitamos un descriptor de archivo (un descriptor de archivo no es más que un entero positivo que representa un archivo abierto. Puede decir que el descriptor es una identificación única del archivo) para decirle al shell qué tipo de salida estamos enviando al archivo. 1 es para stdout y 2 para stderr.

así que ahora si haces esto

ls -a 1> output.txt significa que está enviando salida estándar (stdout) a output.txt.

y si haces esto

cat test.txt 2> error.txt significa que está enviando un error estándar (stderr) a error.txt.

&1 se utiliza para hacer referencia al valor del descriptor de archivo 1 (stdout).

Ahora al grano 2>&1 significa "Redirigir stderr al mismo lugar donde estamos redirigiendo stdout"

Ahora puedes hacer esto

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

tanto la salida estándar (stdout) como el error estándar (stderr) serán redirigidos a output.txt.

Gracias a Ondrej K. por señalar

Respondido 02 Abr '20, 16:04

Las respuestas de solo enlace son problemáticas. El enlace puede desaparecer y hacer que la respuesta sea inútil. Siempre debe incluir suficientes detalles en la propia respuesta. - Ondrej K.

Desde el punto de vista de un programador, significa precisamente esto:

dup2(1, 2);

Consulte las página man.

Entendiendo que 2>&1 es un copia también explica por qué ...

command >file 2>&1

... no es lo mismo que ...

command 2>&1 >file

El primero enviará ambas transmisiones a file, mientras que el segundo enviará errores a stdouty salida ordinaria en file.

Respondido el 03 de diciembre de 15 a las 10:12

Gente, recuerda siempre paxdiablopista sobre el corriente ubicación del objetivo de redireccionamiento ... is importante.

Mi mnemónico personal para el 2>&1 operador es este:

  • Piensa en & como significado 'and' or 'add' (el personaje es un amperios-y¿no es así?)
  • Entonces se convierte en: 'redireccionar 2 (stderr) a donde 1 (stdout) ya / actualmente es y add ambas corrientes '.

El mismo mnemónico también funciona para el otro redireccionamiento de uso frecuente, 1>&2:

  • Piensa en & sentido and or add... (te haces una idea sobre el ampersand, ¿sí?)
  • Entonces se convierte en: 'redireccionar 1 (stdout) a donde 2 (stderr) ya / actualmente es y add ambas corrientes '.

Y recuerda siempre: tienes que leer cadenas de redirecciones 'desde el final', de derecha a izquierda (no de izquierda a derecha).

Respondido 01 Jul 12, 11:07

Redirigir la entrada

La redirección de la entrada hace que el archivo cuyo nombre resulta de la expansión de la palabra se abra para lectura en el descriptor de archivo n, o la entrada estándar (descriptor de archivo 0) si no se especifica n.

El formato general para redirigir la entrada es:

[n]<word

Redirigir la salida

La redirección de la salida hace que el archivo cuyo nombre resulta de la expansión de la palabra se abra para escribir en el descriptor de archivo n, o la salida estándar (descriptor de archivo 1) si no se especifica n. Si no existe el archivo, se crea; si existe, se trunca a tamaño cero.

El formato general para redirigir la salida es:

[n]>word

Descriptores de archivos en movimiento

El operador de redirección,

[n]<&digit-

mueve el dígito del descriptor de archivo al descriptor de archivo n, o la entrada estándar (descriptor de archivo 0) si no se especifica n. el dígito se cierra después de ser duplicado an.

Del mismo modo, el operador de redirección

[n]>&digit-

mueve el dígito del descriptor de archivo al descriptor de archivo n, o la salida estándar (descriptor de archivo 1) si no se especifica n.

Ref:

man bash

Tipo /^REDIRECT para ubicar a la redirection sección, y aprenda más ...

Una versión en línea está aquí: 3.6 Redirecciones

PS:

Mucho tiempo man fue la poderosa herramienta para aprender Linux.

Respondido 05 Jul 18, 04:07

Siempre que /foo no existe en su sistema y /tmp lo hace…

$ ls -l /tmp /foo

imprimirá el contenido de /tmp e imprima un mensaje de error para /foo

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

enviará el contenido de /tmp a /dev/null e imprima un mensaje de error para /foo

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

hará exactamente lo mismo (tenga en cuenta el 1)

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

imprimirá el contenido de /tmp y envía el mensaje de error a /dev/null

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

enviará tanto la lista como el mensaje de error a /dev/null

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

es taquigrafía

Respondido el 01 de Septiembre de 16 a las 21:09

Esto es como pasar el error al stdout o al terminal.

Es decir, cmd no es un comando:

$cmd 2>filename
cat filename

command not found

El error se envía al archivo de esta manera:

2>&1

El error estándar se envía al terminal.

Respondido 05 Jul 18, 04:07

unix_commands 2>&1

Se utiliza para imprimir errores en el terminal.

Lo siguiente ilustra el proceso

  • Cuando se producen errores, se escriben en la dirección de memoria de errores estándar &2 "búfer", desde el cual el flujo de error estándar 2 Referencias.
  • Cuando se produce la salida, se escribe en la dirección de memoria de salida estándar &1 "búfer", desde el cual el flujo de salida estándar 1 Referencias.

Así que toma el unix_commands flujo de error estándar 2y redirigir > el flujo (de errores) a la dirección de memoria de salida estándar &1, para que se transmitan al terminal y se impriman.

Respondido el 25 de enero de 20 a las 20:01

0 para entrada, 1 para stdout y 2 para stderr.

Un consejo: somecmd >1.txt 2>&1 es correcto, mientras que somecmd 2>&1 >1.txt es totalmente Mal sin efecto!

Respondido 25 Jul 16, 10:07

Tenga en cuenta que 1>&2 no se puede usar indistintamente con 2>&1.

Imagine que su comando depende de la tubería, por ejemplo:
docker logs 1b3e97c49e39 2>&1 | grep "some log"
grepping ocurrirá en ambos stderr y stdout desde stderr se fusiona básicamente en stdout.

Sin embargo, si lo intentas:
docker logs 1b3e97c49e39 1>&2 | grep "some log",
grepping realmente no buscará en ninguna parte porque la tubería Unix está conectando procesos a través de la conexión stdout | stdin y stdout en el segundo caso fue redirigido a stderr en el que la tubería Unix no tiene ningún interés.

Respondido 22 Jul 20, 14:07

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.