La pantalla Negra. Parte III

Y esta semana, con un poco de retraso, Mario bross, no, no vamos a
jugar, vamos a tratar los pipes, o tuberías, y los filtros.

    Linux Debian (Potatoe)

    Login: gustavo
    password:
    [gustavo]$ _

Para empezar, necesitamos crear algunos archivos con datos, para ello
podemos utizar un editor de textos, hay varios, el "joe", el "vi", el "jed",
y el "emacs" son cuatro de los más populares, el único del que hay garantia
de que se puede encontrar en cualquier Unix es el vi, pero es un poco complejo
de utilizar, así que vamos a crear un archivo a mano.

    [gustavo]$ echo hola
    hola
    [gustavo]$ _

La orden echo, envía a "salida estandar" un mensaje, ¿Y qué eso de salida
estandar?

Veamos, cualquier aplicación de Unix/Linux, e incluso las aplicaciones de DOS,
tienen tres archivos abiertos, que utilizan para poder funcionar.

El primer archivo es de sólo lectura y se llama "entrada estandar", representa
normalmente al teclado, los programas leen a traves de este archivo todo lo
que escribimos. Normalmente se conoce a este archivo como stdin

El segundo archivo es de sólo escritura, y se llama "salida estandar", y
representa la salida de nuestro programa, cuando un programa quiere escribir
algo en la pantalla, lo que hace es escribir en este archivo.

El tercer archivo, se llama "error estandar", es también de sólo escritura, es
similar al anterior, y se usa para imprimir mensajes de error.

He dicho, que la salida estandar representa la pantalla y la entrada estandar,
representa el teclado, pero eso no tiene por que ser siempre así.

Podemos cambiar la salida estandar de un programa con el operador ">"

    [gustavo]$ echo hola > archivo.txt
    [gustavo]$ _

No hemos visto la salida de echo por la pantalla, la salida ha sido
redirigida al archivo "archivo.txt".

    [gustavo] ls
    archivo.txt
    [gustavo] _

Si queremos ver el contenido de ese archivo usamos la orden "cat"

    [gustavo] cat archivo.txt
    hola
    [gustavo] _

¿Y como podemos añadir más líneas al archivo?, vamos a intentarlo.

    [gustavo]$ echo linea2 > archivo.txt ; cat archivo.txt
    linea2
    [gustavo]$ _

Recordemos que se pueden meter dos ordenes en una sóla línea si las separamos
con un punto y coma.

¿Qué ha pasado?, se ha roto el archivo y contiene lo último que hemos escrito.

Para que no se sobreescriba utilizamos el símbolo ">>".

    [gustavo]$ echo linea1 > archivo.txt
    [gustavo]$ echo linea2 >> archivo.txt
    [gustavo]$ echo linea3 >> archivo.txt
    [gustavo]$ cat archivo.txt
    linea1
    linea2
    linea3
    [gustavo]$ _

Cualquier cosa que envíe cosas a pantalla usando la salida estandar puede ser
redirigido, por ejemplo la orden "ls", o incluso la orden "cat".

    [gustavo]$ cat archivo1.txt >> archivo2.txt
    [gustavo]$ ls
    archivo1.txt   archivo2.txt
    [gustavo]$ _

En este caso como archivo2.txt no existía, lo crea nuevo, y en este caso
hemos copiado el archivo, ambos tienen el mismo contenido.

TIP 1: Cuidado con el operador ">", puede machacar documentos, pues siempre
los crea nuevos.

¿Qué utilidades podemos encontrar redirigiendo la salida estandar?, veamos

    [gustavo]$ ls -l /usr/bin

Salen un montón de archivos y no nos da tiempo a verlos.

    [gustavo]$ ls -l /usr/bin > archivo3.txt
    [gustavo]$ _

TIP 2: En lugar de teclear de nuevo "ls -l /usr/bin" podemos recuperar las
ordenes anteriores con las flechas de cursor y editarlas a nuestra
conveniencia. En este caso con pulsar la flecha arriba una vez, aparece
"ls -l /usr/bin" y sólo tenemos que añadir "> archivo3.txt"

Si usamos la orden cat, para visualizar archivo3.txt, estamos en las mismas,
no nos da tiempo a ver nada, usaremos mejor la orden "more"

    [gustavo]$ more archivo3.txt

    muchas lineas

    --more--(12%)

Vemos como en esta ocasión. cuando se acaba la pantalla, la salida se para,
si pulsamos el retorno de carro, avanzamos una línea, si pulsamos la barra
espaciadora, avanzamos una página entera.

Salimos del paginador "more" cuando se acaba el documento a visualizar, o
bién cuando pulsamos la tecla "q". En linux hay otro paginador mejor que
"more", se llama "less", permite avanzar y retroceder por el texto usando
las tecla del cursor.

Vamos a probarlo un poco.

    [gustavo]$ cd /usr/doc/FAQ
    [FAQ]$ _

¿Se acuerdan de los famosos FAQ y los HowTo de Linux de los que muchos hablan?,
pues están aqui, en este archivo, ...

    [FAQ]$ ls -l
    drwxr-xr-x     5 root      root         1024  Dec 22 01:46  ./
    drwxr-xr-x   198 root      root         5120  Dec 22 01:46  ../
    drwxr-xr-x     2 root      root         2084  Dec 22 01:46  html/
    drwxr-xr-x     2 root      root         1024  Dec 22 01:46  ps/
    drwxr-xr-x     2 root      root         1024  Dec 22 01:46  txt/
    [FAQ]$ _

Vemos que hay un directorio para html, (hará falta un navegador web, como el
lynx), otro para documentos que están en postscript y otro para archivos ASCII
planos.

Un archivo ASCII plano, es un archivo de texto, que no tiene formato, como los
que hemos creado hace poco.

    [FAQ]$ cd txt
    [txt] less Linux-FAQ

Para volver a nuestro directorio, usamos
 
    [txt] cd $HOME
    [gustavo] _

HOME es una variable de entorno que contiene nuestro directorio de trabajo,
se verá en otro capitulo

Hasta ahora, hemos visto que podemos guardar la salida estandar de un programa
en un archivo, y luego, ver cómodamente esa salida estandar con un paginador,
como puede ser "less".

Pero eso es un poco incómodo, pues podemos llenar el disco duro de archivos
innecesarios, ¿como podemos evitarnos ese paso?

Con ayuda de una "tubería", ya era hora que comenzara a hablar de lo que trata
este capítulo.

Para utilizar una tubería, se utiliza el operador pipe y es este "|", la barra
vertical que se consigue pulsando tecla "1" con la tecla "Alt Gr".

    [gustavo]$ ls -l /etc/bin  |  less

Ya podemos ver tranquilamente en la pantalla qué archivos tenemos en el
directorio /etc/bin.

Para hacerlo más divertido, con la orden "tree", podemos obtener un listado
de los directorios existentes a partir de un directorio en forma de árbol.

    [gustavo]$ tree -d /usr | less

Si lo usamos con la opción -a, muestra todo, incluidos los archivos.

Existen otros filtros que se pueden usar con una tubería, uno de los más
conocidos es el filtro "sort", que ordena alfabéticamente la entrada estandar.

Cuando redireccionamos la "salida estandar" a un archivo, si se produce un
error en el programa, el mensaje de error no se imprime en el archivo, si no
que se vuelca a la pantalla.

Esto es debido a que los mensajes de error se imprimen usando "error estandar",
"stderr". Para redireccionar el error estandar.

    [gustavo]$  cc  programa.c -o programa 2>errores.txt

La orden cc, sirve para compilar programas que están escritos en lenguaje "C"
y "C++", en el ejemplo, los errores de compilación se enviarán al archivo
"errores.txt".

Y por último ...

    [gustavo]$ exit

    Linux Debian (Potatoe)

    Login: gustavo
    password:
    [gustavo]$ _

Hoy hemos visto:
* Crear archivos con contenido.
* Ver archivos.
* Concepto de entrada estandar, salida estandar y error estandar
* Redireccionamiento de salida estandar y error estandar.
* Tuberías.

Próximamente me extenderé en el tema de los archivos.

Lokutus, asimilando la red.