Latinoamérica
de.novatoanovato@gmail.com

Redireccionamientos

Dedicado al nuevo usuario de software libre

Redireccionamientos

Flujo de datos estándar

Antes de comenzar a desarrollar los redireccionamientos, me gustaría comentarles, que es importante tener conocimientos previos sobre flujos de datos y también entrada, salida y error estándar, ya que van de la mano con redireccionamiento. Para quienes quieran refrescar o abordar estos temas, les dejo el siguiente artículo pensado y construido para ésta continuación.

Conocimientos previos, necesarios:

  • Flujo de datos.
  • Descriptores.
  • Entrada, salida y error estándar.

Entrada, salida y error estándar

¿Qué son los redireccionamientos?

En GNU/Linux comúnmente ingresamos las ordenes por medio de un teclado, una vez ejecutada una orden, generará dos posibles salidas: Si la orden se ejecutó correctamente obtendremos una salida estándar, caso contrario el flujo de datos tomara como salida la del error estándar. El objeto por el que visualizaremos esa salida suele ser por defecto: la pantalla o monitor. Y el medio por el que podremos verlo: el emulador de terminal. Así es como se comporta el flujo estándar de datos.

Los descriptores de la entrada, salida y error estándar son:

  •  (0) STDIN: Dispositivo de entrada estándar, por defecto el teclado.
  •  (1) STDOUT: Dispositivo de salida estándar, por defecto el emulador de terminal o pantalla.
  •  (2) STDERR: Dispositivo de salida de mensajes de error estándar, por defecto el emulador terminal o pantalla.

Pero entonces… ¿Qué es un redireccionamiento?.

Un redireccionamiento ocurre cuando: Por medio de operadores modificamos el flujo estándar de datos en la instancia de salida de una ejecución, ya sea de la salida estándar o de la salida de error estándar hacia otro destino. Pero por si no quedo claro, una redireccionamiento consiste en cambiar el flujo estándar de los datos. Tan simple como eso.

Redireccionamientos del flujo de datos estándar

En GNU/Linux contamos con una serie de operadores que nos permitirán llevar a cabo distintos tipos de redireccionamientos. Estos, indirectamente forman parte de la sintaxis de los comandos y podrían ser utilizados según nuestras necesidades.

NOTA: Como solo estamos abordando redireccionamientos en esta entrada, no se desarrollarán las particularidades de los comandos, sino que se utilizarán como ejemplos para comprender las funcionalidades de los operadores en los redireccionamiento.

Los operadores de redireccionamiento se corresponden con la siguiente sintaxis:

comando [operador][ruta][elemento]

Donde:

  • Comando: No es mas que una orden o instrucción que se pretenda utilizar.
  • Operador: En redireccionamientos, es un carácter predefinido que indica el sentido que tomaría la salida en el flujo de datos estándar.
  • Ruta: Ya sea relativa o absoluta, la ruta es la dirección que podemos darle a una salida (STDOUT o STDERR) hacia un elemento.
  • Elemento: El elemento es el destino que tendría la salida (STDOUT o STDERR), completando así el redireccionamiento.

Redireccionar la salida estándar a un archivo (>)

Éste tipo de redireccionamiento puede que sea un poco familiar para algunos. Por medio de el, es posible redireccionar la salida estándar (STDOUT), hacía un archivo, en vez de que siga su camino por defecto. El operador del que hablamos es «>«. Y a continuación aprenderemos a usarlo.

NOTA: Si la salida se produce por la salida de error estándar (STDERR), el operador no la redireccionará. Solo afecta a la salida estándar (STDOUT).

Sintaxis del operador >

Si quisiéramos cambiar el flujo de datos estándar y enviar la salida (STDOUT)hacia un archivo, deberemos utilizar el operador > bajo la sintaxis:

comando > NombreDelArchivo

Ejemplo

Para ponernos en un contexto que no será de utilidad para abordar un ejemplo en el uso de este tipo de redireccionamiento, les comento que me encuentro en un directorio cualquiera, sin importar donde se encuentre, listo su contenido ejecutando el comando ls -l, donde obtendré por la salida estándar el siguiente resultado.

ls -l

Hasta acá todo normal , ejecuto un comando valido y obtengo un resultado por la salida estándar, en esta caso: una lista de archivos y directorios con sus respectivos permisos contenidas en un directorio padre nombrado como TioNovato.

Bueno, usemos el ejemplo dado para redireccionar su salida utilizando el operador «>«, hacia el archivo que nombraremos como listado. Ejecutemos:

ls -l > listado

Como podemos observar, no nos imprimió la salida estándar en pantalla como estamos acostumbrados, entonces ¿Qué paso realmente?. Bueno volvamos a listar el contenido del directorio en cuestión, de forma estándar.

ls -l

Vemos que nos apareció un nuevo archivo llamado listado, como lo indicamos. Si observamos su contenido, en mi caso utilizando el comando cat, vemos que:

cat listado

El contenido es el mismo que la salida estándar.

Lo que hicimos cuando ejecutamos la linea ls -l > listado, fue redirigir la salida estándar que produce el comando ls -l al archivo que decidimos nombrar como listado, por medio del operador >. Lo que significa que cambiamos el flujo de datos estándar. Cabe señalar que: en el caso de que el archivo no exista, lo crea. Pero si el archivo existe, lo sobrescribirá.

Si queda alguna duda de que listado es un archivo, podemos abrirlo con el editor de texto nano. Solo a modo de observación.

nano listado

Por otro lado. ¿Podrías identificar el tipo de elemento que es listado desde la propia lista de permisos obtenida de la ejecución de ls -l?, ¿Porque llegaste a esa conclusión?.

Redireccionar la salida estándar agregándola a un archivo (>>)

Al igual que en el caso anterior, puede que este tipo de redireccionamiento les sea familiar también. Por medio de el, es posible redireccionar la salida estándar (STDOUT), hacía un archivo, en vez de que siga su camino por defecto. El operador del que hablamos es «>>«. Y a continuación aprenderemos a usarlo.

NOTA: Si la salida se produce por la salida de error estándar (STDERR), el operador no la redireccionará. Solo afecta a la salida estándar (STDOUT).

Sintaxis del operador >>

Este tipo de redireccionamientos trabaja bajo la siguiente sintaxis:

comando >> NombreDelArchivo

Ejemplo

Utilizaremos el mismo contexto que en el caso anterior para poder ejemplificar su uso. Por ende, me encuentro en el directorio TioNovato, cuyo contenido es:

ls -l

Cambiemos el flujo de datos de la salida estándar (STDOUT) que nos genera el comando ls -l (lista del contenido del directorio TioNovato), redireccionandolo al archivo que nombraremos como concatenar.txt, utilizando el operador >>, de la siguiente manera.

ls -l >> concatenar.txt

Como podemos observar, al ejecutarlo no obtendremos el resultado por pantalla, sino que la salida estándar (STDOUT) fue redireccionada. ¿A donde?, te preguntaras. Bueno, le indicamos que vaya al archivo concatenar.txt, revisemos si está y su contenido.

ls -l

Luego de listar el contenido del directorio TioNovato nuevamente,vemos que hay un archivo nuevo cuyo nombre indicamos en la ejecución de este ejemplo. Pero.. ¿Qué contiene?. Bueno, veamos.

nano concatenar.txt

Lo que paso fue que la salida estándar (STDOUT) fue redireccionada al archivo concatenar.txt.

Pero.. ¿Que pasaría si quiero redireccionar la salida estándar, de otra ejecución, al mismo archivo que creamos para esta ultima utilizando el mismo operador de redireccionamientos? Manos a la obra…

Concatenar salida estándar

Para marcar la diferencia, voy a ejecutar en el mismo directorio TioNovato el comando ls -la, que me listará su contenido incluyendo los elementos ocultos, y voy a redireccionar la salida estándar al archivo concatenar.txt, utilizando el operador >>. Observemos que pasa.

ls -la >> concatenar.txt

Como es una redirección, no obtendremos salida estándar, y sabiendo que esta fue enviada al archivo concatenar.txt, observamos su contenido.

nano concatenar.txt

Veremos que la salida estándar del comando ls -la, se AGREGO al archivo concatenar.txt al final del contenido que ya existía en el.

Concatenando la salida de error estándar

Hasta acá hemos redireccionado el flujo de datos estándar debido que las ejecuciones siempre fuero exitosas, eso quiere decir que tomaron el camino STDOUT, pero… ¿Que sucede si en la ejecución de este comando, bajo la sintaxis del mismo operador, nos genera una salida de error estándar STDERR?

Provoquemos un error en la ejecución de forma intencional ejecutando:

ls -la /hola >> concatenar.txt

Nos encontramos en el directorio TioNovato y Solicitaremos con el comando ls -la se nos liste el contenido del directorio /hola (Este directorio me lo invente, no existe), y utilizando el operador >> enviaremos la salida estándar a archivo concatenar.txt.

¿Podrías explicar lo que paso acá?.

Lo que paso es muy sencillo de explicar, como la ejecución del comando es errónea debido a que el directorio /hola no existe, la salida de la ejecución ocurre por la salida del error estándar (STDERR) y no por la salida estándar (STDOUT). Como el operador >> solo redirecciona la salida estándar, no ocurrirá un redirecconamiento. Para ello contamos con otros operadores.

Redireccionar la salida de error estándar a archivo (2>)

Así como podemos cambiar el flujo de la salida estándar, contamos con operadores que nos permiten hacer lo mismo, pero, con la salida de error estándar. En caso de que se produzca una claro.

NOTA: Si la salida se produce por la salida estándar (STDOUT), el operador no la redireccionará. Solo afecta a la salida de error estándar (STDERR).

Sintaxis del operador 2>

Si quisiéramos cambiar el flujo de datos estándar y enviar la salida de error estándar (STDERR) hacia un archivo, deberemos utilizar el operador 2> bajo la sintaxis:

comando 2> NombreDelArchivo

Ejemplo

La mecánica es la misma que en el redireccionamiento de la salida estándar a un archivo, solo que el operador es 2> y por medio de este podremos redireccionar la salida del error estándar (STDERR) hacia un archivo. Donde en caso de no existir el archivo lo creará y de existir el archivo con el mismo nombre lo sobrescribirá.

Utilizaremos el mismo contexto de trabajo que en los casos anteriores. Nos encontramos en el directorio TioNovato, y listaremos el contenido de un directorio que no existe de forma intencional para producir un error, el directorio (/hola), y obtener la salida deseada por el canal deseado. Tomaremos esa salida de error estándar y la enviaremos a un archivo que nombraremos como archivo.txt utilizando el operador 2>. Antes, listemos el contenido de TioNovato.

ls -l

Como observamos, solo hay 3 directorios. Entonces, ejecutemos:

ls -la /hola 2> archivo.txt

La ejecución no nos devolvió ninguno resultado, pero si listamos el contenido del directorio TioNovato, veremos que se creo un nuevo elemento, el archivo archivo.txt.

Cuyo contenido es:

nano archivo.txt

Por lo que hemos conseguido por medio del operador 2>, redireccionar el error estándar (STDERR) a un archivo.

Este tipo de redireccionamiento no concatena las salidas que apuntan a un mismo archivo, sino que las sobrescribe. Veamos un ejemplo generando otro error de forma intencional en la ejecución de un comando, enviándolo al mismo archivo que generamos en el ejemplo anterior.

Para visualizar el cambio, listamos el contenido del directorio TioNovato y vemos el contenido del elemento archivo.txt.

Y generamos un error para obtener una salida por STDERR, ejecutando cat inexistente e indicando que apunte al elemento archivo.txt.

cat inexistente 2> archivo.txt

Como vemos no obtuvimos una salida estándar, pero si miramos el contenido del elemento archivo.txt veremos que su contenido cambio, fue sobrescrito.

Redireccionar la salida de error estándar agregándolo a un archivo (2>>)

Igual que en el caso de la salida estándar concatenada en un archivo, es posible redireccionar la del error estándar de la misma forma. El operador que nos permite hacerlo es 2>>. Donde de producirse un error en la ejecución del comando, podemos direccionar la salida de error estándar hacia un archivo.

NOTA: Si la salida se produce por la salida estándar (STDOUT), el operador no la redireccionará. Solo afecta a la salida de error estándar (STDERR).

Sintaxis del operador 2>>

La sintaxis para este operador es la siguiente:

comando 2>> NombreDelArchivo.txt

Donde en caso de no existir el archivo indicado creara uno, pero en el caso de existir, escribirá el error estándar en la ultima linea del archivo ya existente.

Ejemplo

Continuaremos con el mismo contexto de trabajo. Estamos en el directorio TioNovato, y listaremos el contenido de un directorio que no existe, de forma intencional, para producir un error (/hola) y obtener la salida deseada por el canal deseado. Tomaremos esa salida de error estándar y la enviaremos a un archivo que nombraremos como archivo.txt utilizando el operador 2>>. Esta ejecución no reemplazara el contenido ya existente en archivo.txt, sino que la salida de error estándar será agregada al final del contenido ya existente en el elemento. Estamos concatenando a archivo.txt la salida de error estándar. Listemos el contenido de TioNovato.

Generemos un error en la ejecución, para enviar la salida a archivo.txt, pero antes, para evacuar dudas, observemos el contenido de ese elemento.

Ahora si, ejecutemos:

ls -la /hola 2>> archivo.txt

Como vemos, la instrucción se ejecuto sin más. Pero.. ¿Qué fue lo que paso?. Como generamos un error de forma intencional debido a que el directorio que intentamos listar /hola no existe, obtuvimos una salida de error estándar, que direccionamos a archivo.txt. Abramos el elemento, y observemos su contenido.

nano archivo.txt

Y observamos que la salida de error estándar fue agregada (concatenada), al elemento archivo.txt.

Redireccionar la salida estándar y la salida de error estándar a un archivo &>

Dentro de los operadores que nos permiten llevar a cabo redireccionamientos, es posible emplear uno que nos permite cambiar el flujo estándar sin saber cual salida se generará, indistintamente si esta toma el camino de la salida estándar (STDOUT) o la de la salida de error estándar (STDERR). El operador que nos permite llevar a cabo esta tarea es &>.

Nota: El operador &> redireccionará la salida que se genere a un archivo indicado, si este no existe lo creará y si existe lo sobrescribirá.

Sintaxis del operador &>

La sintaxis para este operador es la siguiente:

comando &> NombreDelArchivo.txt

Ejemplo

Seguiremos en el mismo contexto de trabajo. Nos encontramos posicionados en el directorio TioNovato  y listaremos el contenido del directorio con la intención de ejecutar un comando valido para obtener obtener un resultado por la salida estándar. Utilizando el operador &> indicaremos que el redireccionamiento se produzca hacia el elemento archivo.txt.

Listemos antes el contenido de el directorio TioNovato:

ls -l

Teniendo como referencia lo obtenido en pantalla, redireccionemos la salida según lo planeado.

ls -l &> archivo.txt

 

Como vemos no obtuvimos ninguna salida, pero si listamos nuevamente el contenido del directorio TioNovato veremos que se creo el elemento archivo.txt. Bueno veamos su contenido.

Bien, ahora ejecutemos un comando invalido, para producir una salida de error estándar y veamos que sucede con este operador. Listemos el contenido de un directorio inexistente, por ejemplo /hola, apuntando al elemento ya creado como archivo.txt y utilizando el operador &>.

ls -l /hola &> archivo.txt

Si vemos el contenido del elemento archivo.txt con el comando cat.

cat archivo.txt

Apreciamos el fue sobrescrito, pero esta vez que el flujo de datos proveniente de la salida de error estándar.

Como podemos observar, ya sea que se produzca una salida estándar (STDOUT) o una salida de error estándar (STDERR), con este operador sera redireccionada al elemento que apuntamos, donde de no existir lo creará y de existir lo sobrescribirá.

Redireccionar la salida estándar y la de salida error estándar a un archivo &>>

En el caso de que necesitemos redireccionar salida del flujo de datos indistintamente de si se produce por la salida estándar o la salida del error estándar hacia un mismo elemento sin sobrescribirlo, contamos con el operador &>>.

Sintaxis del operador &>>

La sintaxis para este operador es la siguiente:

comando &>> NombreDelArchivo.txt

Ejemplo

Continuamos en el mismo contexto de trabajo. Estando en el directorio TioNovato, listaremos el contenido del directorio con la intención de ejecutar un comando valido para obtener obtener un resultado por la salida estándar. Utilizando el operador &>> indicaremos que el redireccionamiento se produzca hacia el elemento concatenar.txt.

Listemos el contenido del directorio en el que nos encontramos:

ls -l

Bien, cambiemos el flujo de datos hacia el elemento que crearemos con el nombre concatenar.txt utilizando el operador &>>.

ls -l &>> concatenar.txt

Tras su ejecución, veremos que no hemos obtenido resultado por la salida estándar. Sin embargo hemos creado el elemento concatenar.txt, según lo indicado, cuyo contenido es el que hubiésemos obtenido por la salida estándar (STDOUT).

cat concatenar.txt

Ahora bien, si de forma deliberada  ingresamos un comando invalido y redireccionamos la salida al mismo elemento, veremos que pasa. Para ello utilizare como comando a Hola, como ya sabemos, no existe tal comando. Y por medio del operador &>> apuntaremos al elemento concatenar.txt para ver que sucede.

Hola &>> concatenar.txt

Tras la ejecución no obtendremos salida porque la hemos redireccionado al elemento concatenar.txt ya existente. Si vemos su contenido:

Veremos que la salida de error estándar fue añadida en la ultima linea del elemento concatenar.txt.

Como podemos observar, ya sea que se produzca una salida estándar (STDOUT) o una salida de error estándar (STDERR), con este operador sera redireccionada al elemento que apuntamos, donde de no existir lo creará y de existir lo añadirá al elemento existente.

Redireccionar salida del error estándar a donde apunta la salida estándar (2>&1)

Este es un tipo de redireccionamiento compuesto, ya que se genera a partir de un un redireccionamiento previo, en este caso para cuando apuntamos la salida estándar hacia un fichero, pero querramos que si se genera una salida de error estándar, esta apunte al mismo destino. Para entenderlo mejor veamos un ejemplo ejecutando un comando valido redirigido al archivo SalidaCompuesta.txt.

ls -l >> SalidaCompuesta.txt

Y observemos su contenido.

cat SalidaCompuesta.txt

Vemos que se creo al archivo SalidaCompuesta.txt cuyo contenido es el correspondiente a la salida estándar.

Bueno, ahora para la misma salida valida introducimos el redireccionamieto compuesto, solo para ver que pasa.

ls -l >> SalidaCompuesta.txt 2>&1

Vemos el contenido.

cat SalidaCompuesta.txt

Observamos que la salida estándar para el comando valido se concateno al fichero SalidaCompuesta.txt según lo indicamos en el primer redireccionamieto. Ahora provoquemos una salida por el error estándar listando un directorio inexistente para ver que pasa.

ls -l NoExiste >> SalidaCompuesta.txt 2>&1

Si vemos el contenido.

cat SalidaCompuesta.txt

Como podemos observar, la salida del error estándar fue redirigida al fichero SalidaCompuesta.txt.

Redireccionar la salida estándar a donde apunta la salida del error estándar (1>&2)

Este tipo de redireccionamieto es compuesto y si bien es poco común, al igual que en el caso anterior se genera dado un redireccionamieto previo. Solo que en este caso se redirecciona la salida estándar hacia donde apunta la salida del error estándar.

Provoquemos una salida no valida y la redirijamos al fichero SalidaNoValida.txt.

ls -l NoExiste 2>> SalidaNoValida.txt

Y veamos el contenido del fichero a donde apuntamos la salida del error estándar.

cat SalidaNoValida.txt

Vemos que fue redirigida al fichero. Ahora aplicamos el redireccionamiento compuesto para un comando no valido.

Vemos que la salida fue concatenada al fichero SalidaNoValida.txt. Pero que pasaría si le pasamos un comando valido. Veamos.

ls -l 2>> SalidaNoValida.txt 1>&2

Vamos el contenido del fichero

cat SalidaNoValida.txt

Observamos que la salida estándar fue concatenada el fichero SalidaNoValida.txt a pesar de que el primer redireccionamieto indica un redireccionamieto para la salida del error estándar. Indicando que stdout salga por donde apunta a stderr.

Redireccionamiento here-string (<<<)

En los redireccionamientos here-string se pasa una cadena ingresada por la entrada estandar que es interpretada por el comando al que se le redirecciona como un argumento. Aunque también es posible utilizar variables como entrada estandar. Es decir, here-string se compone de una cadena o string de posibles argumentos o variables.

Un ejemplo simple, puede ser para el comando bc (calculadora CLI). Veamos.

bc <<< 5*5


Como vemos utilice primero una ejecución directa bc 5*5, obteniendo un resultado no valido, pero si aplicamos el redireccionamiento here-string veremos que el comando bc lo toma como un argumento valido.

Redireccionamiento here-doc (<<)

Es cuando un bloque de texto puede ser redireccionado a un comando o archivo de una manera interactiva pasando un delimitador como argumento.

cat << fin (donde fin es el delimitador)

Como podemos observar, tras la ejecución se nos permitirá ingresar por teclado todo el texto que querramos, incluso saltos de lineas. cuando ingresamos el delimitar fin por teclado la instancia de ejecución terminara. En este caso al ingresar fin (ingresado como delimitador en la linea de ejecución) y presionar enter, terminaremos de interactuar.

Redireccionar archivo como entrada estándar (<)

Este tipo de redireccionamiento nos permite ingresar un archivo como entrada estándar, siempre y cuando sea admitido por el comando a quien se pasamos la entrada.

El ejemplo mas simple al que podemos acudir es:

cat < SalidaCompuesta.txt

Donde SalidaCompuesta.txt es un archivo utilizado en uno de los ejemplos anteriores.

Puedes seguirnos en:

Ayudanos a mantener el sitio con una contribución.
Muchas gracias!

Espero sea de utilidad.
Saludos, Cristian Bellini.

Deja una respuesta

Tu dirección de correo electrónico no será publicada.