C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).

Tel: 918744170. CC: 28025658

Contenido
1. Programación del shell Bash ................................................................................... 2
Creación y ejecución de un guion de shell ................................................................... 2
Creación y nombre del archivo .................................................................................... 3
Instalación de Sublime Text 4 ...................................................................................... 3
Nombres de ficheros .................................................................................................... 5
Ejecución del guión de shell ........................................................................................ 6
Definición del shell de ejecución ................................................................................ 10
Comentarios al guión de shell .................................................................................... 10
Tabulación del código ................................................................................................ 11
Depurar un guion de shell .......................................................................................... 13
Interacción con el usuario .......................................................................................... 15
Interacción en modo gráfico ....................................................................................... 16
Parámetros y variables especiales ............................................................................ 17
Códigos de salida ...................................................................................................... 22
Orden exit .................................................................................................................. 25
Evaluación aritmética y lógica .................................................................................... 28
La construcción doble paréntesis............................................................................... 29
Orden test .................................................................................................................. 31
Referencias ................................................................................................................... 36
 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

1. Programación del shell Bash

El shell Bash (Bourne-Again Shell) es un intérprete de comandos, un programa
informático que tiene la función de interpretar órdenes. El shell nos proporciona la
posibilidad de programar la ejecución de un conjunto de comandos con su propio lenguaje
y de almacenarlas en un fichero, que ejecutaremos como cualquier otra orden del
sistema. Este archivo de órdenes se denomina guion de shell o shell
script. Se pueden escribir guiones de shell complejos, ya que el Shell admite variables,
parámetros, entrada y salida de datos interactiva, comparaciones, bifurcaciones, bucles,
etc.
La única manera de aprender shell scripting es haciendo guiones de shell. Por eso es
muy recomendable que a medida que vayamos avanzando, copiar los ejemplos y los
probarlos en vuestros sistemas. También debes haciendo las actividades que se irán
proponiendo.

Creación y ejecución de un guion de shell

Un guion de shell o shell script es un conjunto de comandos almacenados en un archivo
de texto plano para poder ser ejecutadas posteriormente con el nombre del archivo. En
el guion podemos incluir la llamada a cualquier programa que sea ejecutable por shell
(órdenes del sistema, otros guiones de shell, etc.), así como llamadas a funciones,
estructuras de control del lenguaje del shell, etc.
Cada orden que escribimos en un guion debe ir separada por un salto de línea o bien por
el carácter; (punto y coma) si está en la misma línea.
Las instrucciones del guion ejecutan seguidas una tras otra en el orden en que están
escritas, como si las estuviéramos escribiendo una a una en la línea de comandos, y el
salto de línea o el carácter punto y coma se interpretan como si pulsamos Intro o Return
después de cada orden.
 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

Creación y nombre del archivo

Para crear un shell script basta con abrir un nuevo archivo vacío en un editor de texto,
escribir la secuencia de comandos que queremos que se ejecuten y guardar el archivo
con el nombre que le queremos dar al guión.
El archivo del guion de shell debe estar compuesto únicamente por texto sin formato y
por ello tenemos que utilizar un editor de texto plano.
Editores de texto avanzados
Los editores de texto vi (o el vim), nano y emacs son muy potentes que se han utilizado
históricamente en entornos Unix, pero pueden resultar algo incómodos.
Existen otros más fáciles de utilizar, como gedit que se encuentra por defecto en el
entorno de escritorio GNOME, SublimeText, Atom, etc. que deberemos instalar.
Los editores de textos planos se distinguen de los procesadores de textos en que se usan
para escribir sólo texto, sin formato y sin imágenes. También podemos optar por usar un
editor de texto avanzado que reconozca el lenguaje del shell y utilice diferentes colores
para el resaltado de la sintaxis. Este tipo de editores son especialmente útiles cuando
somos principiantes, ya que nos ayudan a prevenir errores de sintaxis, como olvidar de
poner una llave de cierre, unas comillas dobles, etc.
El nombre que damos al archivo puede ser cualquier nombre válido de acuerdo con las
normas que hay para nombrar archivos en el sistema en el que estamos trabajando.
Normalmente elegiremos un nombre que sea representativo de lo que hace el guión, por
ejemplo, si hace una copia de seguridad, podemos
llamarlo copia. En todo caso conviene que nos aseguramos de que el nombre no entra
en conflicto con otros programas o comandos existentes en el sistema. Para garantizar
esto, los nombres de los guiones a menudo terminan con la extensión .sh.
Podemos nombrar nuestros guiones con la extensión .sh. Ahora bien, esto sólo es una
convención y no es obligatorio hacerlo.

Instalación de Sublime Text 4

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

1. Añadir Sublime GPG Key

$ wget -qO - https://download.sublimetext.com/sublimehq-pub.gpg | sudo gpg --
dearmor -o /usr/share/keyrings/sublimetext-keyring.gpg
2. Añadir el repositorio
$ echo "deb [arch=amd64 signed-by=/usr/share/keyrings/sublimetext-keyring.gpg]
https://download.sublimetext.com/ apt/stable/" | sudo tee
/etc/apt/sources.list.d/sublime-text.list
3. Actualizar los paquetes del sistema
$ sudo apt update
4. Instalar Sublime Text 4
$ sudo apt install sublime-text
Configurar Sublime Text 4 para shellscript
1. Instalar Package Control
Menu Tools -> Install Package Control
2. Cuando aparezca Package Control was successfully installed Reiniciar.
3. Command Palette
Menu Tools -> Command Palette
Seleccionar: Package Control: Install Package
4. Instalar PackageResourceViewer plugin
5. Escribir en el cuadro: PackageResourceViewer
Cuando se instale con éxito se notificará en la barra de estado.
6. Abrir resource viewer
Menu Tools -> Command Palette
7. Seleccionar: PackageResourceViewer: Open Resource
8. Abrir el recurso shellscript
9. Abrir Bash.sublime-syntax
 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

Nombres de ficheros
Las órdenes which, whereis y locate nos sirven para verificar si ya existen archivos con
un nombre determinado. Por ejemplo, si ejecutamos which date nos devuelve /bin/date,
que indica la ruta completa donde podemos encontrar este archivo. Si no nos devuelve
nada significa que no localiza un archivo con este nombre.
Para empezar, abra un editor de texto y cree un nuevo archivo que contenga las cuatro
líneas siguientes:
#!/bin/bash
# Mi primer guión de shell
echo "Hola, mundo"
echo "Soy $USER "
Aunque ahora no queremos analizar a fondo el significado de cada una de las líneas
anteriores, hacemos una descripción breve para saber qué hace el guión:
1.- La primera línea indica al sistema que el programa Bash ubicado en el directorio /bin
debe ejecutar el resto de las instrucciones que hay en el script.
2.- La línea siguiente es un comentario y, por tanto, el shell la ignora.
3.- La tercera línea es una orden echo, que permite mostrar texto por pantalla, en este
caso, la frase "Hola, mundo".
4.- La última línea es otra orden echo que muestra por pantalla el mensaje “Soy
 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

$USER” sustituyendo el valor de la variable USER por el nombre del usuario que ejecuta
el guión.
Una vez hemos escrito las líneas sin errores, guardamos el archivo y le damos un nombre
para poder ejecutarlo desde la línea de comandos.

Ejecución del guión de shell

La manera más habitual de ejecutar un script es abrir una sesión de terminal y ejecutarlo
como cualquier otra orden del sistema, es decir, escribiendo el nombre del archivo que
contiene el script en la línea de comandos seguido de un salto de
línea. Para poder hacerlo es necesario que el archivo tenga permiso de ejecución para
los usuarios que tienen que ejecutarlo. En el caso más simple, daremos permiso de
ejecución al propietario del fichero con el siguiente orden:
chmod u+x nombrearchivo
Después de añadir el permiso de ejecución al fichero, podemos ejecutarlo con su nombre
teniendo en cuenta las siguientes consideraciones:
1.- Si el directorio que contiene el fichero del shell script está en la variable PATH,
podemos poner sólo el nombre del archivo que contiene el guión para que se ejecute:
# Ejecutar script nombre_script
2.- Si el directorio que contiene el fichero del shell script no está en el PATH, tenemos
que escribir el nombre del archivo indicando donde se encuentra (con ruta relativa o
camino absoluto):
# Ejecutar un guión de shell des del directorio actual
./nombre_script (ruta relativa)
# Ejecutar un guión de shell ubicado /home/usuario
/home/usuario/nombre_script (ruta absoluta)

Variable PATH
 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

La variable PATH contiene la lista de directorios donde el shell se dirigirá para localizar
las órdenes que ejecutamos. Esto nos permite escribir las órdenes escribiendo sólo su
nombre y sin especificar el directorio donde están situadas, es decir, sin preocuparnos
de dónde se encuentran en el disco. La búsqueda de la orden solicitada en los directorios
que se especifican en la variable PATH se hace de izquierda a derecha. Si no encuentra
el orden en ninguno de los directorios especificados en la variable PATH, el shell avisa
con un mensaje de error que no se ha encontrado la orden. Puedes ver el valor de la
variable PATH con la orden echo $PATH.
Ejemplo de creación y ejecución de un guión de shell
Abre una sesión de terminal, asegúrate de que estás situado en tu directorio.
Con un editor de texto plano, crea un archivo que contenga las siguientes líneas:

Guarda el archivo en el mismo directorio de inicio y llámalo holamundo.sh. Dale permiso

de ejecución al archivo:
chmod u+x holamundo.sh
Ejecuta el shell script indicando el nombre de donde se encuentra con ruta relativa:
./holamundo.sh
Ejecuta de nuevo el shell script. Ahora indicando el fichero con ruta absoluta:
~/holamundo.sh ó /home/usuario/holamundo.sh

Crea un directorio ~/scripts para guardar tus programas, mueve el archivo holamundo.sh
en el directorio ~ / scripts y añade el directorio al contenido de la variable PATH con los
siguientes comandos:
mkdir ~/scripts
 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

mv ~/holamundo.sh ~/scripts
export PATH = " $PATH:~/scripts"
Ahora puedes ejecutar holamundo.sh llamándolo sólo por su nombre, sin indicar donde
se encuentra (ni con camino relativo ni con camino absoluto), porque está en un directorio
contenido en la variable PATH.
Puedes intentar situar a cualquier punto de la jerarquía de directorios del sistema y
ejecutar holamundo.sh poniendo sólo su nombre. Por ejemplo:
cd /tmp holamundo.sh
El cambio que has realizado a la variable PATH sólo afecta a la sesión de shell que tienes
activa. Si quieres que la variable PATH tenga el directorio ~/scripts en todas las sesiones
que abras, hay que editar el archivo ~/.bashrc y añadir al final la línea con el orden export
y guardar los cambios.
export PATH = $PATH:~/scripts
Un guión de shell también se puede ejecutar explícitamente con un Shell determinado,
poniendo el nombre del shell ya continuación el nombre del archivo que contiene el guión
de shell:
bash holamundo.sh
Este método generalmente sólo lo usamos cuando queremos comprobar que el programa
funciona con otro shell o cuando queremos depurar (debug) el guión de shell. Por
ejemplo:
rbash nombre_script # Ejecutar el guión con rbash
sh nombre_script # Ejecutar el guión con sh
bash -x nombre_script # Ejecutar el guión con modo debug (opción x)
Observación: El Shell restringido (rbash) es un Shell de Linux que restringe algunas de
las características del shell bash, y es muy claro por el nombre. La restricción está bien
implementada para el comando, así como para el script que se ejecuta en un shell
restringido. Proporciona una capa adicional de seguridad para bash shell en Linux.
Cuando bash ejecuta un shell script, crea un proceso hijo que ejecuta otro bash, el cual
lee las líneas del archivo, las interpreta y ejecuta como si vinieran del teclado. El proceso
 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

bash padre espera mientras el bash hijo ejecuta el script hasta el final, y en ese momento
el control vuelve al proceso padre, el cual vuelve a poner el indicador o prompt. Los
cambios en el entorno de un shell hijo no afectan al entorno del shell padre.
Por lo tanto, si en el guión hay órdenes que modifican el entorno, tales como cambiar de
directorio actual, modificar el valor de una variable de entorno, crear una nueva variable,
etc., estos cambios sólo tienen efecto en el entorno del shell hijo y desaparecen una vez
finaliza la ejecución del guión.
Si queremos ejecutar un guión en el shell actual en lugar de con un shell hijo y, por tanto,
modificar el entorno actual, debemos ejecutar el guión con el
orden source.
source nombre_script # Ejecutar en el shell actual
La orden del Bash llamada source es un sinónimo de la orden. (punto) del shell Bourne:
. nombre_script
Observación: No confundir el orden punto (.) del shell Bourne con el directorio punto, que
indica el directorio actual.
Ejemplo de ejecución de un guión de shell con o sin modificación del entorno
Crea un guión de shell en su directorio de trabajo que contenga las siguientes

#!/bin/bash
cd /etc
echo El directorio actual es: pwd
Guarda el archivo y llámalo cambio.sh. Dale permiso de ejecución al archivo:
chmod u + x cambio.sh
Ejecuta el guión desde el directorio actual mediante un shell hijo:
./cambio.sh
La salida le muestra que en el shell hijo se cambia de directorio. Ahora bien, cuando
finaliza la ejecución del guión, el directorio donde estamos situados sigue siendo nuestro
 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

directorio de trabajo, para que el cambio en el shell hijo no nos afecte. Lo comprobamos
ejecutando: pwd
Ejecuta el guión en el shell actual (en lugar de en un shell hijo) mediante la orden source
o la orden punto (.):
source cambio.sh
En este caso, al finalizar la ejecución nos encontramos en el directorio /etc, ya que las
órdenes del guión se han ejecutado en nuestro shell. Lo comprobamos ejecutando:
pwd
Definición del shell de ejecución
Al escribir guiones de shell es recomendable que indicamos el shell que debe ejecutar el
guión. Por eso los dos primeros caracteres de la primera línea deben ser #!, seguidos del
nombre del shell que debe interpretar las órdenes que vienen a continuación.
Por ejemplo:
#!/bin/bash
No empieces el shell script con una línea en blanco, para que estas líneas también sean
tenidas en consideración.
Observación: Si omitimos la definición del shell de ejecución, el shell script se ejecuta
con el shell lo establecido por defecto y, en el caso de no ser el shell para el que se
ha escrito el guión, las órdenes contenidas pueden dar error al ser ejecutadas.
Comentarios al guión de shell
Los comentarios son útiles para ayudar a entender los scripts. Hay que tener en cuenta
que probablemente no seremos los únicos que vamos a leer el código de los guiones de
shell que hacemos, o que, pasado un tiempo, la memoria puede fallar y no entender el
programa que nosotros mismos hemos escrito.
Normalmente, las primeras líneas después de la línea que indica el shell de ejecución
son un comentario sobre la funcionalidad del programa. El resto del programa se comenta
como sea necesario para una mayor claridad y comprensión del código.
Observación: scripts de inicio como ejemplos de scripts comentados:
 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

Ver los scripts de inicio del sistema en el directorio /etc/init.d. Estos guiones están muy
bien comentados para que sean fácilmente legibles por los administradores y los
programadores del sistema.
Para añadir comentarios al programa sólo hay que poner el símbolo # seguido del texto
que se quiera. Cada nueva línea debe ir precedida del símbolo #. Se puede poner el
símbolo \ al final de una línea para indicar que el texto no ha terminado y continúa en la
línea siguiente. En /etc/init.d hay buenos ejemplos de comentarios en scripts. Edita o
visualiza, por decir alguno, kerneloops

Tabulación del código

En el caso más simple, un guion no es más que una lista de comandos del sistema
escritas una detrás de la otra que se ejecutan de manera secuencial. Ahora bien, al
programar shell scripts a menudo utilizamos estructuras de control de flujo (condicionales
e iterativas) que nos permiten romper el flujo de ejecución, repetir una parte de las
órdenes, etc., y que hacen que el guion de shell no sea simplemente una enumeración
de comandos.
 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

Para facilitar la lectura del código del guion de shell, es muy importante que el código
esté bien tabulado. Bash no necesita que haya tabuladores para poder interpretar el
código, pero a las personas sí que nos va bien que el código esté organizado con
tabuladores para leerlo de una manera cómoda.
El código de un shell script debe estar bien tabulado para que el programa sea legible.
Por ejemplo, consideremos el guion de shell siguiente, escrito sin tabular:
#! /bin/bash
echo -n "Escribe un número:" read X
if [ $X -lt 10 ] ; then echo "X es menor que 10" else
if [ $X -gt 10 ] ; then echo “X es mayor que 10" else
echo “X es igual a 10"
fi fi

La lectura y la comprensión de las estructuras condicionales anidadas del guion de shell

anterior son difíciles. El mismo código, tabulado y comentado, queda así:
 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

La tabulación nos permite leer el código y seguir la lógica del programa con más
comodidad, así como evitar errores de programación (olvidar una palabra clave de cierre
de una estructura de control, situar una palabra clave en algún lugar indebido, etc.).
No hay ninguna norma que fije cómo se debe tabular el código, hay quien utiliza
tabuladores de dos espacios y quien prefiere cuatro espacios. Lo que importa es utilizar
un estilo homogéneo a lo largo de todo el shell script.
Si usamos un editor de texto plano, debemos sangrar el código a mano, o bien con
espacios o bien con tabuladores. Algunos editores avanzados nos facilitan este trabajo
haciendo que a medida que escribimos el código se vaya “sangrando” de manera
automática sin que nosotros nos tengamos que preocupar de las tabulaciones.
Depurar un guion de shell
A veces el funcionamiento de un guion de shell no es el esperado y tenemos que
determinar cuál es la causa de este funcionamiento incorrecto, es decir, tenemos que
depurar el shell script. Una técnica consiste en hacer un seguimiento paso a paso de las
órdenes que ejecuta para ver donde se produce el error. Para realizar este seguimiento
podemos ejecutar el script con bash -x seguido del nombre del guión así:
bash -x nombrearchivo
O bien podemos incluir -x en la primera línea:
 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

#!/bin/bash -x
Si sólo queremos depurar una parte del programa, podemos hacerlo de la siguiente
manera:
# Activar depuración desde aquí
set -x
código para depurar
# Parar la depuración
set +x
La opción -x de Bash indica que se han de imprimir por pantalla las órdenes y sus
argumentos mientras se ejecutan. Así podemos ver qué punto de la ejecución se ha
llegado cuando se produce un error.
Ejemplo de ejecución paso a paso de un guión de shell
Hacer un guión de shell que se llame prueba.sh con las líneas siguientes:
#!/bin/bash
N=5
echo "El valor de N es: $ N "
Ejecuta de manera normal y observa la salida es simplemente el mensaje
El valor de N es: 5
Ahora lo ejecutamos mostrando cada paso de la ejecución de la siguiente manera:
bash -x prueba.sh
El resultado es que nos aparecen las líneas que se van ejecutando con un símbolo +
delante:
+ N=5
+ echo ‘El valor de N és: 5'
El valor de N es: 5
Podemos añadir la opción -v para mostrar todas las líneas de entrada al shell, incluyendo
comentarios, a medida que las va leyendo:
bash -xv prueba.sh

Agustín Herrero Cola 14 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

El resultado es:
#!/bin/bash
# Shell script de prueba N=5
+ N=5
echo “El valor de N es: $N”
+ echo ‘El valor de N es: 5'
El valor de N es: 5
Interacción con el usuario
Un guion de shell puede requerir interacción con el usuario, es decir, solicitarle la entrada
de datos o mostrarle datos de salida. Para poder interaccionar con el programa
normalmente utilizamos las órdenes echo y read, que nos permiten mostrar datos en la
pantalla del terminal y leer datos del teclado en modo texto.
Si lo que queremos es hacer una aplicación gráfica, entonces bash no es la herramienta
indicada. Sin embargo, podemos tener una interacción básica con modo gráfico y utilizar
cajas de diálogo sencillas con algún software que lo permita, como el Zenity.
Órdenes echo y read
1.- La orden echo muestra una cadena de texto añadiendo un salto de línea para la salida
estándar. La sintaxis de la orden es:
echo [ opción ] [ cadena ]
Ejecuta man echo para consultar la lista de caracteres de escape posibles de su sistema.
Las opciones que se pueden utilizar con echo son:
• -n para que no añada un salto de línea después de mostrar la cadena.
• -e para habilitar la interpretación de los caracteres de escape ( \n para añadir un
salto de línea, \ t para añadir un tabulador, etc.). Si utilizamos esta opción hay que
ponemos el texto de la cadena entre comillas dobles.
Por ejemplo:
echo -e "\n\nHola, mundo !! \n\n "
2.- La orden read permite leer datos de la entrada estándar. La utilización más habitual
del orden read es con la siguiente sintaxis:

Agustín Herrero Cola 15 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

read nombre_variable
La orden read lee lo que el usuario introduce por el teclado hasta que hay un salto de
línea y asigna los datos a la variable nombre_variable. Por ejemplo:
read N
Ejecuta man read para ver la sintaxis completa de esta orden.
Ejemplo de guión de shell que interacciona con el usuario con las órdenes echo y read:
Hacer un guión de shell que se llame saludo.sh que pida un nombre y a continuación
muestre un mensaje de saludo con el nombre que hemos introducido.
#!/bin / bash
#
# saludo.sh #
# Ejemplo de uso de las órdenes echo y read #
echo "¿Cómo te llamas?" read NOMBRE
echo "Hola, $NOMBRE "
Interacción en modo gráfico
El shell Bash es un shell de línea de comandos pensado para interactuar en modo texto,
pero podemos tener una interacción básica en modo gráfico utilizando otros programas,
tales como Zenity. Zenity permite utilizar cajas de diálogo basadas en GTK+ en la línea
de comandos y en los shell scripts.
Observación: herramientas GTK
Las GTK o grupo de herramientas del GIMP (GIMP toolkit, en inglés) son unas librerías
pensadas para el desarrollo de aplicaciones gráficas con facilidad. Disponen de licencia
GPL y hay numerosos proyectos que las utilizan, como el GIMP (de ahí le viene el
nombre, ya que inicialmente se crearon para este proyecto), GNOME, el Eclipse o Firefox,
entre otros.
Podemos usar Zenity para crear diálogos simples que interactúen gráficamente con el
usuario, ya sea para obtener información del usuario o para proporcionarle información.
Por ejemplo, podemos pedir al usuario que seleccione una fecha de un calendario
(diálogo de calendario) o un archivo (diálogo de selección de un archivo), o se puede
usar un diálogo de progreso para indicar el estado actual de una operación o usar un
diálogo de alerta para notificar al usuario algún error.

Agustín Herrero Cola 16 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

Por ejemplo, abre una sesión de terminal desde el escritorio (si es Gnome o XFCE
funciona seguro; en otros habrá que probarlo) y ejecuta la línea de comandos siguiente:
/usr/bin/zenity --warning --title = "ASO" --text = "Alumnos/as, hay que hacer el
último esfuerzo" --width = 500
El resultado es un cuadro de diálogo como el que se muestra en la siguiente imagen.

Parámetros y variables especiales

La utilización de parámetros es un método para pasar datos al programa de manera no
interactiva. El lenguaje del shell dispone de una serie de variables especiales que
permiten trabajar con estos parámetros.
Uso de parámetros
Un parámetro o argumento de la línea de comandos no es más que un valor que le
pasamos al programa en el momento de su llamada. Un programa puede tener cualquier
número de argumentos en la línea de comandos.
La mayoría de las órdenes de Unix pueden hacer acciones diferentes en función
de los parámetros que les damos en ejecutarlas. Por ejemplo, en la siguiente orden:
ls /etc
ls es el nombre de la orden que se debe ejecutar. Todo lo que viene a continuación en la
línea de comandos se toma como argumentos para esta orden. Cada uno de los
argumentos está separado por uno o más espacios. En este caso hay un único
argumento, el nombre del directorio /etc.
Consideremos un ejemplo de llamada de una orden con dos argumentos:
tail +10 /var/log/messages
tail es el nombre de la orden, +10 es el primer argumento y el nombre del archivo
/var/log/messages es el segundo argumento.

Agustín Herrero Cola 17 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

Del mismo modo que lo hacen la mayoría de las órdenes, los guiones de shell pueden
aceptar parámetros cuando se ejecutan. Un parámetro o argumento es un valor que le
damos al guión de shell en el momento de su llamada. Los argumentos de un shell script
se pueden referenciar dentro del programa mediante una serie de variables especiales.

Variables especiales
Al ejecutar un guion de shell con parámetros, hay un conjunto de variables especiales
del shell llamadas parámetros posicionales que se fijan automáticamente para que
coincidan con los parámetros dados en el programa. Se llaman parámetros posicionales
porque la asignación de cada variable depende de la posición de un parámetro en la línea
de comandos. Los nombres de estas variables se corresponden con el valor numérico de
su situación en la línea de comandos: 0, 1, 2, 3 ... Y así hasta el último parámetro que se
pasa.
Los parámetros posicionales se pueden utilizar dentro del guion de shell como cualquier
otra variable del shell, es decir, para saber su valor utilizaremos el símbolo $. A partir del
décimo parámetro, el número debe cerrarse entre llaves.
Los parámetros dentro del programa son accesibles utilizando las variables: $0, $1, $2,
$3... ${10}, ${11}, ${12} ...
Ejemplo de uso de parámetros en un shell script
Crea un shell script que se llame args.sh con el siguiente contenido:
Observación: podemos poner `basename $0` para evitar mostrar la ruta entera.

Agustín Herrero Cola 18 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

Guarda el archivo y dale permiso:

$chmod u+x args.sh
Ejecútalo así:
$./args.sh azul verde rojo
La salida del programa es la siguiente:
Valor del primer parámetro del guion de shell: azul
Valor del segundo parámetro del guion de shell:
verde Valor del tercer parámetro del guion de shell: rojo

Puedes probar diferentes ejecuciones del programa que acabas de hacer y comprobar
los resultados, por ejemplo:
. /args.sh ABC
. /args.sh Juan Antonio Luis
Además de los parámetros posicionales, hay otras variables especiales definidas en
cualquier script que podemos usar según nuestras necesidades. La siguiente tabla
muestra el nombre y la descripción de las variables especiales más utilizadas.

Agustín Herrero Cola 19 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

Tener en cuenta las siguientes observaciones:

1. $* Y $ @ son lo mismo cuando no van entre comillas. El espacio es el separador
de parámetros y obvia las comillas si es que aparecen.
2. "$*" expande los parámetros en una cadena: "par1 par2 ...". Es una sola cadena
que comprende todos los parámetros unidos por espacios en blanco. Por ejemplo
1 2 ‘ 3 se convierte en "1 2 3".
3. "$@" expande los parámetros en cadenas diferenciadas: "par1" "par2" ... Es decir,
la lista de cadenas resultante coincide exactamente con lo que se ha dado en el
guión de shell. Por ejemplo, '1 2' 3 se convierte en "1 2" "3".
El valor de las variables especiales se puede guardar en otras variables, por ejemplo:
NOMBRE=$1
Ahora bien, la asignación de valores a las variables especiales no está permitida, por
ejemplo:
# Operación no permitida
$1=Adriana
Ejemplo de visualización de los parámetros y de otras variables especiales.
Modifica el guion de shell args.sh y añade al final las líneas que aparecen en negrita:
#! /bin/bash #
# args.sh #
# Ejemplo de uso de parámetros #
echo "Nombre del guion de shell: $0"
echo “Valor del primer parámetro del guion de shell: $1"
echo “Valor del segundo parámetro del guion de shell: $2"
echo “Valor del tercer parámetro del guion de shell: $3"
echo “Número de parámetros pasados al guion de shell: $#"
echo “Lista de todos los argumentos recibidos: $*"

Ejecútalo:
. /args.sh a b c

Agustín Herrero Cola 20 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

La salida del programa es la siguiente:

Nombre del guion de shell: args.sh
Valor del primer parámetro del guion de shell: a
Valor del segundo parámetro del guion de shell: b
Valor del tercer parámetro del guion de shell: c
Número de parámetros pasados al guion de shell: 3
Lista de todos los argumentos recibidos: abc
¿Es lo mismo ./args.sh abc? Control del número de parámetros
La mayoría de las órdenes muestran un mensaje de error o informativo cuando los
argumentos requeridos por la orden no se han especificado en su llamada. Por ejemplo,
ejecute el comando:
rm
La salida que le da es:
rm: missing operando
Try `rm --help 'for more information.

Análogamente, si un guion de shell espera recibir parámetros, debemos verificar dentro

del programa que la llamada al guion de shell se ha hecho con el número de parámetros
esperado y, en caso contrario, mostrar un mensaje de error. Este control lo podemos
llevar a cabo mediante la estructura condicional if (ya lo veremos más adelante) y la
variable especial $#.

Ejemplo de un shell script con control de número de parámetros

Crea un shell script con el siguiente código y llámalo suma.sh. Este script recibe dos
números por parámetro y muestra por pantalla el resultado de la suma de los dos
números. Al inicio controla que el número de argumentos recibidos es correcto y da un
error si no es así.
#! /bin/bash #
# suma.sh #

Agustín Herrero Cola 21 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

# Recibe dos números por parámetro y muestra la suma por

# La salida estándar.
#
# Control del número de parámetros: if [ $# -ne 2 ] ; then
echo "Error: se esperaban dos parámetros."
echo "Uso del programa: $0 num1 num2"
exit 1
fin
# Recibimos dos parámetros, hacemos la suma
(( SUMA = $1 + $2 ))
echo "La suma de $1 y $2 es: $ SUMA "
Dale permiso de ejecución al archivo y ejecútalo pasándole dos números como
parámetros:
chmod +x suma.sh
. /suma.sh 10 5
La salida del programa es la siguiente:
15
Ahora, no le pases dos parámetros. Por ejemplo:
./suma.sh
La salida del programa es la siguiente:
Error: se esperaban dos parámetros. Uso del programa: suma.sh num1 num2

Códigos de salida
Al finalizar la ejecución todas las órdenes generan un código de salida (en inglés, exit
status o exit code) que es un número entero entre 0 y 255.
Por convención, si la orden acaba bien, normalmente devuelve un cero (0) y si acaba mal
devuelve un valor distinto de cero (entre 1 y 255). Muchas veces, el valor devuelto por el

Agustín Herrero Cola 22 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

orden representa el error generado. Por ejemplo, los errores de sintaxis casi siempre
hacen que las órdenes devuelvan el valor 1.
El shell nos proporciona una variable especial llamada “?” (signo de interrogación sin las
comillas), que contiene el código de salida de la orden ejecutada anteriormente.
El código de salida puede ser utilizado por el Bash, lo podemos mostrar o podemos
controlar el flujo del guión con él. Para visualizar el valor utilizamos la orden echo:
$echo $?
En los guiones de shell, la mayoría de las decisiones de programación se controlan
analizando el valor de los códigos de salida. Cuando evaluamos condiciones, el código
de salida nos indica si la condición es verdadera (devuelve 0) o falsa (devuelve un valor
distinto de cero).

Ejemplo de ejecución de órdenes y consulta de los códigos de salida

Abre una sesión de terminal y ejecuta el comando ls:
ls
Visualiza el código de salida de la orden que acaba de ejecutar:
echo $?
0
La salida es un cero, lo que indica que no ha habido ningún error. Ejecuta el ls con algún
nombre de archivo inexistente para provocar un error:
Ls asdfg
ls: no se ha podido acceder a asdfg: El archivo o directorio no existe Visualiza el código
de salida de la orden que acaba de ejecutar:
echo $?
2
La salida es un valor distinto de cero (un 2), lo que indica que ha habido un error.

Ejecuta el cp sin argumentos para provocar un error:

Agustín Herrero Cola 23 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

cp
cp : falta un operando archivo
Pruebe «cp --help» para obtener más información.

Ejecuta el cp sin argumentos para provocar un error:

cp
cp: falta un operando archivo
Pruebe «cp --help» para obtener más información.

Visualiza el código de salida de la orden que acaba de ejecutar:

echo $?
1
La salida es un 1, lo que indica error de sintaxis.
Del mismo modo que lo hacen las órdenes, los shell scripts devuelven un código de salida
que es el de la última orden ejecutada. El código de salida de un shell script también se
puede consultar justo después de la finalización del programa mediante la variable $?

Ejemplo de visualización del código de salida de un guión de shell

Crea un guión de shell sencillo llamado hola.sh:
#! /bin/bash
echo "Hola, mundo"

Dad permiso de ejecución al fichero y ejecute el guión:

Chmod u+x hola.sh
./hola.sh
Consulta el código de salida desde la línea de comandos:
echo $?

Agustín Herrero Cola 24 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

0
El código devuelto es un cero, el de la última orden ejecutada en el guión de shell, es
decir, la orden echo “Hola, mundo”.

Puedes modificar el guión y añadir al final una orden que dé error para comprobar el
efecto que tiene sobre el código de salida.

Orden exit
La orden exit provoca la finalización del shell script y de manera opcional permite fijar el
código de salida con un valor determinado. Su sintaxis es:
exit [ n ]
siendo n un número entero entre 0 y 255.
Por convención el valor que se devuelve es un cero si ha ido bien o un entero del rango
entre 1 y 255 si ha habido algún error. Normalmente, el rango de 126 a 255 se reserva
para ser utilizado directamente por el shell o para fines especiales, y los códigos del rango
de 0 a 125 se dejan para ser utilizados por el programa.
En todo guión de shell conviene proporcionar un código de salida significativo, al menos
un 0 (cero) si finaliza bien y un 1 (en general, un valor distinto de cero) si hay algún error.
Esto permitirá que el proceso que ha hecho la llamada pueda verificar cómo ha ido la
ejecución del guión de shell.
Si no se pasa ningún parámetro a exit, el código devuelto por el guión de shell es el de
la última orden ejecutada justo antes del exit. Por ejemplo:
#!/bin/bash
orden_1
...
orden_N
# Termina con el código de salida del orden_N.
exit
El ejemplo anterior, habría sido exactamente igual si se hubiera especificado el valor del
código de retorno de la siguiente manera:

Agustín Herrero Cola 25 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

#!/bin/bash
orden_1
...
orden_N
# Termina con el código de salida del orden_N.
exit $?

Análogamente, si un shell script finaliza sin especificar el orden exit, el código de retorno
es el de la última orden ejecutada al shell script.
#!/bin/bash
orden_1
...
orden_N
# Termina con el código de salida del
orden_N.

Ejemplo de utilización del orden exit y comprobación de los códigos de salida. Haz un
guión de shell que se llame salida.sh con las líneas siguientes:
#!/bin/bash
echo "Esto es una prueba."
# Devolvemos código de salida
exit 115
Guarda el archivo, dale permisos y ejecútalo.: /salida.sh
La salida del programa es la siguiente:
Esto es una prueba.
Visualiza el código de salida del guión de shell:
echo $?

Agustín Herrero Cola 26 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

El valor de salida es un 115, dado que la hemos forzado con el orden exit. 115
En la programación de guiones de shell es muy frecuente utilizar el comando exit para
finalizar el programa en cualquier punto sin seguir la norma de la programación
estructurada que dice que un programa debe tener un único punto de salida. Por ejemplo,
un shell script hecho con programación estructurada sería así:
if condicion_error1; then código=1
else
if condicion_error2; then código=2
else
if condicion_error3; then código=3
else
# No hay errores instrucciones código=0
fi fi fi
exit $código
Pero habitualmente nos encontraremos el guión de shell anterior escrito con un estilo
similar al siguiente:
if condicion_error1; then
exit 1
fi
if condicion_error2; then
exit 2
fi
if condicion_error3; then
exit 3
fi
# No hay errores instrucciones
exit 0

Agustín Herrero Cola 27 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

Aunque los dos programas hacen lo mismo, el primero sigue las normas de la
programación estructurada y tiene un único punto de salida en el último éxito, mientras
que el segundo tiene cuatro posibles puntos de salida, uno para cada orden de exit.
Evaluación aritmética y lógica

Al programar casi siempre aparece la necesidad de operar con números, así como de
evaluar el resultado de expresiones aritméticas o lógicas para tomar decisiones.
En Bash disponemos de algunos métodos para realizar evaluaciones aritméticas.
Veremos dos: la orden let y la construcción doble paréntesis (vista anteriormente). Para
aquellos casos que necesitamos operar con números con decimales veremos cómo
hacerlo utilizando el orden bc.
Otro comando muy utilizado en la programación de guiones de shell para hacer
evaluaciones lógicas es la orden test. Esta orden nos permite evaluar expresiones con
tres tipos de elementos: números enteros, archivos y cadenas de caracteres.

Orden let
La orden let permite a los programas de shell evaluar expresiones aritméticas con los
mismos operadores que en el mecanismo de expansión aritmética y con la siguiente
sintaxis:
let expressión_aritmètica
La orden evalúa de izquierda a derecha la expresión y devuelve un código de salida igual
a 0 (verdadero) o 1 (falso). A pesar de que no siempre hay que cerrar la expresión entre
comillas dobles, podemos optar por ponerlas por defecto para evitar errores.
La expresión aritmética puede constar de números enteros, variables y operadores del
shell. También podemos utilizar paréntesis para cambiar el orden de preferencia de una
expresión. Por ejemplo:

#! /bin/bash
# Definición de variables
x=12
y=2

Agustín Herrero Cola 28 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

# Utilización del orden let

let “z = x / y + 1"
echo $z
# z vale 7, primero se ha hecho la división
# Alterar precedencia con paréntesis
let "z = x / (y + 1)"
echo $z # z vale 4, primero se ha hecho la suma
Cuando en la expresión utilizamos operadores lógicos o relacionales (!, <=, >=, < , > , ==
, != ) evaluamos el código de salida devuelto por el shell . Por ejemplo:
let “11 <10"
echo $?
La orden anterior devuelve un 1 indicando que la expresión se ha evaluado como falsa,
ya que 11 no es menor que 10.
Algunas consideraciones para tener en cuenta cuando utilizamos el orden let son:
1. La orden let no muestra ningún resultado por pantalla. Un error común es esperar
que let devuelva el resultado de una operación por la salida estándar, por ejemplo,
ejecutar let 4+2 y esperar un 6 por pantalla. Para operar con let, hay que utilizar
variables y asignar el resultado a las variables, por ejemplo, let x=4+2.
2. La expresión de let se escribe sin espacios. Si deseas poner espacios para separar
los operandos de los operadores para que quede más claro, debes poner la
expresión entre comillas dobles. Por ejemplo, let “x = 4 + 2”
3. Si en una expresión quieres utilizar paréntesis para alterar el orden de precedencia
de los operadores, debes poner doble comillas para anular el significado especial
de los paréntesis. Por ejemplo, let “x=x/(y+1)”.
4. Las variables que se utilizan dentro de una expresión pueden ir referenciadas o
no. Por ejemplo, let x = x + 2 es el mismo que let x=$x+2.

La construcción doble paréntesis

La construcción doble paréntesis, (()), permite evaluar expresiones aritméticas de manera
equivalente a la orden let pero con la siguiente sintaxis:
((Expresión_aritmética))

Agustín Herrero Cola 29 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

Por ejemplo:
(( x = x + ( y / 2 ) ))
Es equivalente a:
let "x = x + (y / 2)"

Observación: muchos autores recomiendan utilizar preferentemente los dobles

paréntesis en lugar del orden let.
A menudo encontramos la construcción doble paréntesis formando parte de bucles while
con el estilo del lenguaje de programación C. Por ejemplo:
x=1
while ( ( x < 10 ) ) ; do
...
Órdenes
...
(( x++ ))
Done
Al igual que con el orden let, las variables utilizadas como operandos en una expresión
pueden ir precedidas del símbolo $ o no. Por ejemplo, las dos expresiones siguientes son
correctas:
(( x = x + 1 )) # Correcto (( x = $x + 1 )) # Correcto
Pero ten cuidado y no has cometido errores como este:
(( $x = x + 1 )) # Incorrecto !!

Operaciones con números con decimales

La orden bc es un programa muy potente que incorpora un lenguaje de programación
propio y que permite hacer cálculos con precisión. Esta orden puede ser de mucha
utilidad si necesitamos realizar operaciones con números con decimales.
Ejecuta man bc para ver el funcionamiento y la descripción de todas las opciones.

Agustín Herrero Cola 30 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

Si ejecutamos bc a la línea de comandos, nos aparece una información sobre la versión

del programa similar a la siguiente:

El programa queda esperando la entrada de datos de forma interactiva desde el teclado,

por lo que podemos introducir las operaciones que queremos hacer, pulsar Intro y luego
obtenemos el resultado, por ejemplo:
6*3/2->obtenemos el siguiente resultado:
9
Para salir de la calculadora tenemos que escribir la palabra quit seguida de Retorno.
Podemos utilizar bc dentro de un shell script mediante una tubería para redirigir los datos
de entrada al programa. Por ejemplo:
echo "(2 + 3) * 5" | bc
En el ejemplo anterior utilizamos la orden echo para pasar los datos de entrada a la orden
bc. El resultado de la operación nos sale por pantalla, en este caso un 25.
Para trabajar con números con decimales especificamos la precisión (cantidad de
decimales) con la opción scale. Por ejemplo:
echo "scale = 2; 7 * 5/3" | bc
La orden anterior nos muestra un 11,66 por pantalla, que es el resultado de la operación
que hemos realizado.
Orden test
La orden test evalúa expresiones lógicas y genera un código de salida que indica si la
expresión es cierta (código de salida igual a cero) o falsa (código de salida distinto de
cero). Esta orden no escribe nada en la salida estándar. Para determinar el resultado de
la orden test hay que evaluar el valor del código de salida con la
variable “?”
La sintaxis de la orden test es la siguiente:
test expresión_test
O en forma abreviada:
[ expresión_test ]
Agustín Herrero Cola 31 | 36
 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

Observación: hay que dejar un espacio después del símbolo [ y antes del símbolo ] .
Observación: es fundamental ejecutar man test para consultar todas las opciones
En las siguientes tablas puedes ver las expresiones que se pueden evaluar con test.

Un ejemplo:

Ficheros:

Agustín Herrero Cola 32 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

Un ejemplo:

Operadores lógicos:

Agustín Herrero Cola 33 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

Un ejemplo:

Cadenas
-n cadena → cierto si la longitud de la cadena es distinta de 0
-z cadena → cierto si la longitud de la cadena es 0
cadena1 = cadena2 → cierto de las cadenas son iguales
cadena1! = cadena2 → cierto si las cadenas son diferentes
cadena → cierto si la cadena de caracteres no es nula

Ejemplos
1.- Usa test para evaluar estas cadenas
#cadena1=”rojo” #cadena2=”verde”
#test “$cadena1” = “$cadena2”
#echo $? 1
#test “$cadena1” = “rojo”
#echo $? 0
Longitud de una cadena
Se puede obtener con la siguiente sintaxis:
echo ${#cadena}

Agustín Herrero Cola 34 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

Observación: Cuidado con las opciones -n y -z en cadenas cuyo contenido sean espacios
en blanco
Practicar:
1. Con la orden test, comprueba si el número 11 es mayor que el número 15.
2. Con la forma abreviada del orden test, comprueba si el número 15 es igual que el
número 15.
3. Con la forma abreviada de test, comprueba si la cadena "hola" es igual a la cadena
"HOLA"
4. Con la orden test, comprueba si existe un archivo llamado /etc/passwd:
5. Asignar a una variable N el valor 15, después con la orden test comprueba si el
valor de N está entre 10 y 20:
6. Escribir con la forma abreviada del comando test una comprobación que diga
cierto si el directorio /tmp no existe:
Cuando evaluamos el valor de una variable en una expresión, debemos asegurarnos de
que la variable siempre contiene algún valor, porque si no, la variable valdrá null y el
script nos dará un error. Por ejemplo:
[ $X -eq 3 ]
bash : [ : -eq: s esperaba un operador unario
La variable X no tiene ningún valor, entonces, su valor se expande y devuelve nada, por
lo tanto, el shell ha interpretado [ -eq 3 ] y ha dado un error.
Si trabajamos con cadenas de caracteres, podemos evitar este error poniendo siempre
las variables entre comillas dobles ( "" ). Así nos aseguramos de que la variable contiene
al menos el valor null y el shell interpretará la cadena como vacía. Por ejemplo:
[ "$X" = 3 ]
En este caso, si X no tiene ningún valor, el shell interpreta [ "" = 3] y no da error.
El shell interpreta los valores de una expresión de test como enteros o como cadenas
de caracteres según los operadores que utilizamos.
Las expresiones que se utilizan con el orden test pueden ser conectadas lógicamente
utilizando los operadores propios de test -a y -o, pero la manera más recomendable de

Agustín Herrero Cola 35 | 36

 C/ Luis de Requesens, 1-3. 28590 Villarejo de Salvanés (MADRID).
Tel: 918744170. CC: 28025658

hacerlo es utilizar las órdenes de test de manera independiente y combinarlas con los
operadores lógicos && (AND lógico) y || (OR lógico). Por ejemplo, en lugar de escribir
[$N -gt 10 -a $ N -lt 20]
es mejor separar las expresiones y conectarlas así:
[$ N -gt 10] && [$ N -lt 20]
Pero ten cuidado; los operadores lógicos no pueden ir dentro de los corchetes de test:
# Operación errónea
[ $N -gt 10 && $ N -lt 20]

Referencias
Apuntes de Francisco Jesús en Administración de Sistemas Operativos
https://franciscojesusgu.wordpress.com/

Agustín Herrero Cola 36 | 36