En esta sección vamos a ver bastantes ejemplos y sintaxis de comandos. Es conveniente especificar una notación que permita describir la sintaxis de un comando de manera fácil.
Por ejemplo:

comando1 [arg1] arg2 {arg3|arg4} [arg5|arg6]

Significa que comando1 acepta el argumento arg1, que el argumento arg2 es obligatorio, se puede elegir entre arg3 o arg4 pero no los dos o ninguno. Por último, se puede elegir entre arg5 o arg6, pero no los dos

La shell o intérprete de comandos es el interfaz básico que nos permite comunicarnos con el ordenador y arrancar los programas que guardamos en el disco duro.

Internamente no es mas que un programa que básicamente espera a que nosotros le introduzcamos una orden o comando para ejecutarlo, tras lo cual vuelve a quedarse a la espera del siguiente comando. Esta funcionalidad básica es un punto común que tienen todos los interpretes de comandos de cualquier sistema operativo. A partir de aquí, dependiendo de la shell y de los recursos que ponga a su disposición el sistema operativo, aparecen diversas extensiones que pueden cubrir desde una interfaz intuitiva y totalmente gráfica (escritorio de la familia de S.O de Microsoft) hasta el auténtico lenguaje de programación que encontramos en casi todas las shells de los S.O del entorno Unix. En esto último es en lo que nos vamos a centrar en este capítulo.

El prompt de la shell es un indicativo de que la shell está lista para recibir nuevos comandos.

Prácticamente todas las shells ofrecen esta característica mediante la cual el usuario puede asignar o acceder a cierta información. Esta información es válida sólo mientras la shell que el usuario está usando continúe cargada en memoria. Cuando el usuario sale del sistema (logout) esta información se pierde.

El uso de estas no difiere de las variables encontradas en los lenguajes de programación aunque está en cierto modo simplificado. No hace falta declararlas y todas las variables almacenan valores del tipo string (cadena de carácteres). Al igual que con las variables de los lenguajes de programación encontramos operadores de comparación y asignación. La shell también ofrece otros operadores relacionados con el uso de variables de estado. Veremos esto más detalladamente en próximos capítulos.

La entrada y salida estándar son unas abstracciones que proporcionan al programador una forma unificada de leer y escribir datos desde su programa.

Supón por un momento que eres un programador que tienes que diseñar una aplicación que lea unos ciertos datos del usuario y muestre unos resultados. Uno podría utilizar las rutinas que el S.O. le ofrece y leer estos datos desde el teclado, para luego mostrar los resultados por pantalla. Sin embargo, como buen programador que eres, quieres darle a tu programa suficiente flexibilidad para que ademas de leer del teclado, también pueda leer los datos de un archivo. Y ademas, también quieres que sea capaz de imprimir los resultados por la impresora .... Esto requeriría la adición de nuevas rutinas para leer desde un archivo y para imprimir a una impresora. Y esto es sólo el principio, hay mil formas de leer datos y otras mil de mostrarlos.

Precisamente lo que se pretende con la entrada y salida estándar es que el programador no tenga que hacer nada de lo indicado arriba. Proporcionan dos canales únicos de entrada y salida que el programador puede utilizar en cualquier momento. El programador no sabe y no le preocupa como se han introducido los datos que vienen del canal de entrada estándar, y tampoco le interesa a donde van a parar los datos que vuelca sobre el canal de salida estándar. En lo que a él concierne, sólo está leyendo datos del usuario y mostrandole los resultados.

Todo esto se resume básicamente en lo siguiente: La entrada estándar es un canal por el cual un usuario le introduce datos a un programa. Este canal inicialmente apunta al teclado, pero (y aquí está lo importante) no tiene porque ser siempre así. El usuario puede hacer que la entrada estándar apunte a un archivo de datos o a un micrófono, por ejemplo. Lo mismo ocurre con la salida estándar. Esta apunta por defecto a la pantalla, pero un usuario puede manipularla de tal manera que apunte a un archivo, la impresora o los altavoces.

Al hecho de hacer que el canal de entrada o salida estándar apunte a otro sitio que no sea el dispositivo por defecto se llama redirección de la entrada y salida estándar. La redirección de la entrada y salida estándar es algo que se hace desde la shell, al mismo tiempo que se llama al programa. La shell proporciona una sintaxis adecuada para poder ejecutar un programa con la entrada/salida estándar redireccionada. Lo veremos con ejemplos en el próximo capítulo.

Una tubería no es más que una forma de conectar la salida estándar de un programa con la entrada estándar de otro programa automáticamente. Es un concepto muy importante, ya que permite que varios programas puedan encadenarse y hacer que los resultados de un comando puedan tratarse como datos a procesar por el siguiente.

Un hecho conocido de los sistemas Unix es que son S.O. multitarea y multiusuario. La característica principal de un S.O. multitarea es que puede aparentar que está ejecutando varios procesos (programas) a la vez (y digo aparentar porque un procesador convencional sólo puede ejecutar una instrucción a la vez).

Las shell de los sistemas Unix se aprovechan de esta capacidad ofreciendo al usuario dos formas de ejecutar sus comandos:

1. Ejecución síncrona (en primer plano): Es la forma más usual de ejecutar un comando. El usuario escribe el comando en el prompt de la shell, pulsa INTRO y espera a que se ejecute el comando. Sólo (importante) después de que el comando se halla ejecutado la shell muestra el prompt indicando que está preparada para el siguiente comando.
2. Ejecución asíncrona (segundo plano): Una vez que el usuario indica a la shell el comando que quiere ejecutar y pulsa INTRO, esta le devuelve el control (es decir, muestra el prompt) de inmediato. El comando introducido se está ejecutando en segundo plano, es decir, que el usuario puede seguir introduciendo comandos (que a su vez también pueden estar en segundo plano) mientras el primero se ejecuta.

Esta shell seguramente es la de uso más extendido. Proporciona una interfaz al usuario muy configurable y potente.

El prompt de bash suele variar de un sistema a otro, dependiendo de como este configurado. El prompt por defecto suele ser este: nombre-sistema:dir-actual $ para los usuarios normales y nombre-sistema:dir-actual # para el administrador del sistema.

En mi ordenador por ejemplo es asi:

tajo:~$

(yo suelo dar nombres de ríos a mis ordenadores ;-) )

A partir de ahora, para notar que en un ejemplo hay que teclear el comando comando1 pondra de esta forma:

tajo:~$ comando1

Lo que significa que hay que teclear comando1 en la shell y pulsar INTRO. Por supuesto, no hay que teclear tajo:~$, eso es solo para indicar que me encuentro en la shell.

En bash, una variable de entorno se asigna de la siguiente manera:

nombreVar=valor

En primer lugar hay que notar que no hay ningún espacio en la asignación. Estas asignaciones son erroneas y provocarán un error:

nombreVar =valor nombreVar= valor nombreVar = valor

También hay que tener en cuenta que las variables de entorno son sensibles a las mayúsculas y minúsculas: Si el valor que asignamos tiene espacios en blanco, la asignación se realiza de las siguientes maneras:

nombreVar='valor con espacios en blanco' nombreVar="valor con espacios en blanco"

(nótese que los carácteres ' y " son sólo delimitadores, no forman parte del valor).

Supongamos por ejemplo:

tajo:~$ inicioQuijote='En un lugar de la mancha....'

En bash hay una distinción entre la variable y el valor que contiene. Es una distinción muy importante que hay que saber. Podemos pensar en la variable como una cierta localización de memoria X en la que podemos guardar valores. Así, cuando escribimos:

tajo:~$ inicioQuijote='En un lugar de la mancha....'

estamos diciendo a bash que guarde en la localización de memoria X (la variable inicioQuijote) la cadena (el valor) 'En un lugar de la mancha...'.

¿Cómo podemos acceder al valor de la variable inicioQuijote?. Hay dos formas:

$inicioQuijote \'

o

${inicioQuijote}

Supongamos que queremos redirigir la salida del comando: echo "Hola caracola" al archivo saludos.txt

Esto se hace de la siguiente manera:

tajo:~/pruebas$ echo "hola caracola" > saludos.txt

Análogamente, supongamos que tenemos un comando comando1, el cual tiene que leer una serie de datos del usuario. Para hacer que lea los datos de un archivo (datos.txt) en vez de por teclado:

tajo:~/pruebas$ comando1 < datos.txt

Supongamos que además tenemos un comando2 que hace lo mismo que comando1 pero que además muestra unos resultados. Haremos lo siguiente para que lea de datos.txt y muestre en res.txt:

tajo:~/pruebas$ comando2 < datos.txt > res.txt

La sintaxis adecuada para encadenar la salida del comando comando1 con la del comando comando2 es:

comando1 | comando2

Se pueden hacer pipes entre varios procesos, de la siguiente forma:

comando1 | comando2 | comando3 .....

Esto conecta la salida estándar de comando1 a la entrada estándar de comando2, la salida estándar de comando2 con la entrada estándar de comando3, y asi ad infinitum (:D).

Imaginemos que queremos ejecutar el comando comando1, pero mientras este se ejecuta queremos seguir haciendo otras cosas, ya que comando1 tarda mucho en ejecutarse. Esto se hace de la siguiente manera:

tajo:~/pruebas$ comando1 & [1] 32933 tajo:~/pruebas$

Con lo cual comando1 seguirá ejecutándose mientras nosotros trabajamos en otras cosas.

El número a la derecha de los corchetes es el PID (ver más adelante) del proceso. Una vez que el proceso termine de ejecutarse en segundo plano, la shell nos lo notificará con un mensaje.

Lo que hemos visto hasta ahora no son más que conceptos básicos sobre bash. Más información se puede conseguir en la página de manual de bash ( comando: man bash ) o en su manual de referencia (http://www.gnu.org/software/bash∞)

La página de manual de bash también nos puede ser útil cuando queramos alguna referencia rápida (comando: man bash)

Cuando tengamos alguna duda sobre algun comando, generalmente podemos consultar su página de manual. Esto se hace así:

man [seccion] comando

Las páginas man se agrupan en secciones que contienen ayuda de diversos temas. Por ejemplo, la sección 1 es para programas de usuario. La sección 2 es para rutinas del kernel, etc ....

Para ver más información detallada siempre podemos escribir:

man man

Hay veces en las que un tema aparece en más de una sección. Podemos ver en que secciones aparece el comando comando1 con:

man -k comando1

Los Howto's son textos que documentan los pasos necesarios para realizar con éxito alguna tarea (compilar el kernel, configurar las X, etc...). Son textos de orientación principalmente prácticos.

Las guías son textos más largos que los Howto's y que cubren casi totalmente un tema determinado (administración del sistema, red, etc ...). La mayoría son mini-libros.

Tanto las guías como los howto's se pueden coger gratis y sin ningún cargo de http://www.linuxdoc.org∞, aunque lo más normal es que estén también en tu distribución (prueba en /usr/doc/HOWTO, o /usr/doc/Linux-HOWTO).

|| MANDATO || DESCRIPCIÓN || NOTAS ||
|| ls || Lista los contenidos de un directorio || Una opción útil es -l (formato largo) ||
|| cd [dir] || Entrar en el directorio dir || Si no se especifica el directorio se vuelve al directorio de inicio ||
|| mkdir dir || Crea el directorio dir || Para poner espacios, englobar el nombre entre comillas ||
|| cp arch dir || Copia el archivo arch al directorio dir || Si el directorio dir es . se lleva al directorio actual ||
|| mv arch dir || Mueve el archivo arch al directorio dir || Si el directorio dir es . se lleva al directorio actual ||
|| rm arch || Borra definitivamente el archivo arch || ¡¡Cuidado con lo que borras!! ||
|| rmdir dir || Borra el directorio definitivamente dir || El directorio tiene que estar vacío ||

Para buscar archivos utilizaremos el comando find:

La forma básica de buscar un archivo:

• Sin tener en cuenta mayúsculas y minúsculas: find ruta_inicio -iname nombre_archivo_y_comodines
• Teniendo en cuenta mayúsculas y minúsculas: find ruta_inicio -name nombre_archivo_y_comodines

En ambos caso, find se situa en ruta_inicio y va descendiendo recursivamente por todos sus subdirectorios.