1 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

1. Primer script en bash

Si ya has practicado un poco con el shell bash, te habrás dado cuenta de que se
pueden hacer muchas cosas interesantes con él. Aunque hay veces, que para
conseguir determinado resultado necesitaremos introducir, por ejemplo, 3 o 4
comandos; o tenemos que evaluar una condición manualmente (por ejemplo, con ls
comprobamos manualmente si un archivo existe). Los scripts de shell nos dan la
posibilidad de automatizar series de comandos y evaluaciones de condiciones.

Un script es como se llama a un archivo (o conjunto de archivos) que contiene

instrucciones (en nuestro caso comandos de bash), y que necesita de un programa
ayudante para ejecutarse (en nuestro caso la propia terminal bash será el programa
ayudante). Un script tiene cierta similitud con un programa, pero existen diferencias.
Generalmente, los programas están en lenguaje de máquina (la máquina lo entiende
directamente), mientras que los scripts son archivos que contienen en formato texto
los comandos o instrucciones que la aplicación ayudante ejecutará.

Aunque en principio esto puede resultar un tanto abstracto, vamos a verlo despacio
y con ejemplos. Si no has programado nunca, en este capítulo encontrarás el
aprendizaje del shellscripting en bash como una sencilla introducción a la
programación, que te ayudará a comprender después los fundamentos de otros
lenguajes de programación. No te preocupes, porque lo vamos a explicar todo de
forma sencilla y no te quedará ninguna duda.

Pues bien, vas a crear tu primer script bash. Para ello utilizaremos el editor vim, que
es la versión mejorada del editor vi. Si recordamos, un script era un archivo de texto
plano con comandos; así que haz vim miscript.sh y pon en él lo siguiente (lo
explicaremos detenidamente a continuación):

Como ya sabemos, la extensión en los archivos en Linux no tiene significado útil. Es

por convenio general, por lo que a los scripts de shell se les llama con la extensión
".sh" (de SHell). De este modo identificaremos fácilmente nuestros scripts entre el
resto de archivos de un directorio.

Observemos la primera línea: #!/bin/bash. Esta línea es un tanto especial, y es

característica de todos los scripts en Linux, no solamente los de bash. Tras #!
indicamos la ruta a la aplicación ayudante, la que interpretará los comandos del
archivo. En nuestro caso es bash, así que ponemos ahí /bin/bash, que es la ruta

Conceptos básicos de Linux JBS

2 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

hacia la aplicación bash. Como más adelante tendrás tiempo de descubrir, hay otros
tipos de scripts (Perl, Python, PHP...) para los cuales deberemos indicar la
aplicación ayudante correspondiente.

Como ves, no importa que pongamos líneas en blanco, pues serán ignoradas.
Podemos ponerlas después de cada bloque de comandos que tengan cierta
relación, para dar claridad y legibilidad al conjunto de comandos del script.

Las dos siguientes líneas comienzan por el carácter #. En los scripts de bash, las
líneas que comienzan con este signo son ignoradas, y se llaman comentarios.
Podemos usarlas para explicar qué hace el grupo de comandos siguiente, de tal
forma que cuando editemos el script en el futuro nos sea más fácil descubrir qué es
lo que está haciendo en cada sitio; o podemos usarlos para dar cualquier otra
información importante de cara a la edición del archivo. Veremos más ejemplos de la
utilidad de los comentarios después.

Las dos últimas líneas son dos comandos, de los que luego serán ejecutados por
bash. Como sabemos, el comando echo saca por stdout (por defecto por pantalla)
lo que le pasemos como argumento, en este caso dos frases. Podemos añadir
cualquier comando normal de los que hemos visto, que será ejecutado normalmente.
Después escribiremos algunos scripts más complejos, para que te hagas una idea
de para qué pueden servirnos.

Guardemos el script y salgamos de vim. Ahora lo ejecutaremos. La primera forma

de hacerlo es como sigue:

Como ves, todos los comandos del script han sido ejecutados. Aunque la forma más
frecuente de ejecutar scripts es, darles primero permisos de ejecución, como ya
sabemos del capítulo de usuarios, grupos y permisos:

Al darle permisos de ejecución, podemos ejecutar ahora nuestro script como si de un

programa normal se tratase. Esto es posible gracias a la primera línea del script, que
hace que se llame inmediatamente a la aplicación ayudante para procesar los
comandos. Hemos podido observar que a nivel del shell, nuestro script es un
programa como otro cualquiera, que podemos ejecutar e incluso ponerlo en algún
directorio listado en la variable de entorno $PATH, como por ejemplo
/usr/local/bin y ejecutarlo como si de un programa del sistema se tratase,

Conceptos básicos de Linux JBS

3 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

simplemente tecleando su nombre. Creo que ya te vas imaginando la gran utilidad

de los scripts de shell...

Conceptos básicos de Linux JBS

4 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

2. Variables

Recordamos que una variable es un nombre al que le hacemos corresponder un

valor. Este valor puede ser un valor numérico o bien una cadena de texto
indistintamente en los scripts de shell. Los nombres de las variables conviene que
comiencen por una letra, después veremos por qué.

En el siguiente ejemplo aprenderemos a usar las variables en nuestros scripts:

Repasemos el ejemplo despacio. En primer lugar tenemos la línea que será siempre
la primera en nuestros scripts, y que ya conocemos, la que dice cuál es el programa
que ejecutará las instrucciones del script.

Siguiendo tenemos la asignación de algunas variables, esto es, estamos dando valor
a algunas variables que luego usaremos. Observa que entre el nombre y el valor,
NO HAY ESPACIOS, es variable=valor. Procura recordarlo. Ahora cada
variable tiene el valor que le hemos asignado. Podríamos cambiarlo simplemente de
la misma forma, pero poniendo otro valor distinto, que sobreescribiría a cualquiera
que tuviese antes la variable. Así, tercera=7 haría que el valor de la variable
tercera fuese de ahí en adelante 7.

Después encontramos el comando $[ ], que nos permite hacer operaciones

aritméticas, obteniendo el resultado. Luego veremos más detenidamente el hecho de
que un comando DEVUELVA un valor. De momento trata de comprender este
ejemplo. En la primera de esas líneas, la variable resultado1 se queda con el

Conceptos básicos de Linux JBS

5 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

valor resultante de efectuar la operación entre los números. En la línea siguiente,

vemos que para REFERIRNOS al valor que tiene una variable, colocamos delante
de su nombre el signo $. Dondequiera que pongamos ese signo delante del nombre
de una variable, todo ello será reemplazado por el valor de la variable. Así, la
expresión que se evalúa al final es la misma que la de la línea anterior, pues todas
las variables quedan sustituidas por sus valores reales antes de que se haga la
operación. Como ves, es bastante sencillo.

En las líneas siguientes usamos el ya conocido comando echo. Es muy conveniente

que en nuestros scripts pongamos entre comillas lo que echo debe sacar por
pantalla. Así, en la primera línea tenemos una forma sencilla posible para generar
una línea en blanco en la salida, como podremos apreciar cuando después
ejecutemos el script. Como ves, dentro de las comillas del argumento de echo,
podemos hacer que aparezca el valor de una variable procediendo como ya hemos
aprendido. El comando echo será nuestro mejor aliado para hacer que nuestro
script saque información por la pantalla.

A la variable frase le vamos a asignar una cadena de texto. Date cuenta de que
esta vez tampoco hay espacios en medio de la asignación y que EL TEXTO VA
SIEMPRE ENTRE COMILLAS, pudiendo ser simples o dobles. La estructura es
entonces variable="texto". En la línea siguiente, con el comando echo de
nuevo, podemos sacar por pantalla el texto que habíamos guardado en la variable.

Atención a la línea siguiente. El comando read será nuestra vía de comunicación

con el usuario en nuestros scripts. Funciona de este modo: primero, ponemos read,
el comando que hace todo el trabajo, y a continuación, ponemos el nombre de la
variable donde queremos que la entrada del usuario quede almacenada (en nuestro
caso, la variable es entrada_del_usuario). Cuando a la hora de ejecutarse, el
script llegue a esa línea, esperará a que el usuario escriba algo y presione la tecla
INTRO. En ese momento, lo que el usuario escribió antes de de presionar INTRO
quedará guardado en la variable, y luego podremos hacer uso de estos datos que el
usuario introdujo, como hacemos en la línea siguiente, sacarlos de nuevo por
pantalla.

Por último tenemos el comando exit. Este comando al final del script no es
especialmente útil, pero si pusiésemos cualquier cosa debajo de él ya no sería
ejecutada. Lo usaremos después cuando queramos que "si se da tal condición,
entonces que el programa (script) termine".

Para terminar de comprender este segundo script de ejemplo, ponlo en un fichero

llamado, por ejemplo, variables.sh con el editor vim. Dale permisos de ejecución
como hicimos antes y después ejecútalo:

Conceptos básicos de Linux JBS

6 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

Conceptos básicos de Linux JBS

7 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

3. Comandos posibles

Una duda que puede surgir es... ¿qué comandos puedo escribir en mis scripts?
¿Tengo alguna limitación?

De aquí otra de las bondades de los scripts en bash: todos los comandos que
escribiremos en bash pueden escribirse en un script de bash; esto incluye cualquier
programa, redirecciones de entrada o salida, pipes, etc. Usando comandos del
sistema, podemos hacer que nuestros scripts hagan casi cualquier cosa que
nosotros queramos, y que se comporten como si de complejísimos programas se
trataran. Esto es, para borrar un fichero dentro de un script, simplemente
necesitamos usar el comando rm, sin preocuparnos por cómo funciona rm
internamente. Con los comandos que ahora conocemos, nuestros scripts podrán:
listar ficheros o directorios, borrar, despreciar salidas, buscar en cadenas de texto,
pedir datos al usuario e interpretarlos...

Lo mejor, además de conseguir una secuencia automatizada (no será necesario

teclear todos los comandos que necesitemos para una determinada cosa todas las
veces; simplemente los escribiremos en un script y lo ejecutaremos con una sola
línea cada vez que lo necesitemos) es que podemos hacer que los argumentos que
le pasemos a un comando en el script sean variables. Poco a poco irás
comprendiendo lo ventajoso de que los argumentos de los programas que
ejecutemos en nuestros scripts sean variables.

Hacer notar una cosa. Cuando una de nuestras variables sea el argumento de un
programa, y si lo llamamos con muchos argumentos, es muy conveniente para evitar
errores extraños, entrecomillar la variable:

Cuidado, en este caso las comillas deben ser dobles.

Todavía hay muchos comandos que no conocemos, pero cuando aprendas algunos
nuevos, recuerda que pueden servir para dar funcionalidades extra a tus scripts.

Conceptos básicos de Linux JBS

8 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

4. Concepto de valor de retorno

Cuando un programa termina de ejecutarse, devuelve o retorna un valor. En el caso

de los programas, el valor de retorno es un número. El valor es cero (0) si el
programa finalizó con éxito o distinto de cero si el programa no finalizó con éxito.
Cada uno de los valores distintos de cero va asociado a una causa distinta
(sabiendo este valor podríamos saber por qué razón falló el programa), pero puede
que por ahora no lo necesites.

El valor de retorno es un concepto un poco abstracto, pero no es difícil de

comprender. El valor de retorno no se imprime por la pantalla, es decir, cuando un
programa termina no saca por pantalla un cero, pero nosotros podemos saber cuál
es ese valor.

En el shell bash (y por extensión, en nuestros scripts) el valor de retorno del último
programa o comando ejecutado queda almacenado en la variable especial $?.

Veamos un ejemplo:

Conceptos básicos de Linux JBS

9 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

En el primer caso, pedimos a ls que liste un archivo existente. Lo lista con éxito y
por tanto el valor de retorno vale cero. En el segundo caso le pedimos que liste un
archivo inexistente. Como eso no es posible, el comando no termina con éxito y el
valor de retorno es distinto de cero (en este caso 2).

La utilidad de conocer el valor de retorno al ejecutar un programa en nuestros scripts

salta a la vista: cuando veamos las sentencias condicionales podremos hacer que el
script haga una cosa u otra en función de si un programa terminó con éxito o no.

Volveremos a ver el valor de retorno cuando estudiemos las funciones.

Conceptos básicos de Linux JBS

10 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

5. Pasar y procesar argumentos

Los comandos que ejecutamos normalmente pueden recibir opciones y argumentos

(parámetros), como por ejemplo ls -l ./ . En ese ejemplo, ls es el comando, -l
es una opción y ./ es un argumento. En esta sección veremos las variables
especiales que nos permitirán luego hacer que nuestros scripts se comporten del
mismo modo, que puedan recoger opciones y argumentos.

Llama a este script args.sh y dale permisos de ejecución. Antes de ejecutarlo

vamos a explicarlo.

En primer lugar tenemos la barra invertida \. Usaremos la barra invertida para

escapar caracteres especiales. Si queremos sacar por pantalla con el comando
echo unas comillas o un signo del dolar, la única forma es anteponiéndole una barra
invertida, de otro modo sería interpretado como comillas de fin de cadena de texto o
como variable respectivamente.

Luego tenemos las variables $N, donde N es un número natural: 0, 1, 2, etc. $0

contiene el comando ejecutado, $1 el primer parámetro, $2 el segundo parámetro, y
así sucesivamente.

Por último tenemos la variable especial $#. Esta variable contiene un número entero,
que vale el número de parámetros que pasamos al script sin contar $0. Ejecutemos
el script de dos formas distintas para comprender todo esto:

Conceptos básicos de Linux JBS

11 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

Estas dos ejecuciones han debido servir para ilustrar cómo funcionan estas variables
especiales para recibir parámetros en nuestros scripts. Conforme sigamos
aprendiendo veremos cómo podemos hacer que nuestro script se comporte de una
forma u otra dependiendo de los parámetros que se le pasen. Cada vez más,
nuestros scripts se irán pareciendo a programas "de los buenos".

Todavía hay más... puede que no se te ocurra cómo listar todos los parámetros que
se le pasen al script, sean cuantos sean. El comando shift nos da la solución. Hay
algunas cosas que debemos saber antes de poder usar shift para listar los
parámetros pasados a un script. No obstante, hay un ejemplo en “Funciones”, que
aplica tanto a funciones como al script en sí mismo.

Variable de proceso

Hay que recordar que existe la variable especial $! . Esta variable contiene el ID de
proceso del último comando ejecutado.

Conceptos básicos de Linux JBS

12 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

6. Evaluación de condiciones

Muchas veces nos será necesario hacer que nuestro script se comporte de una
forma u otra según el usuario introduzca uno u otro argumento, o según una variable
tenga tal o cual valor. En esta sección pasamos a ver los comandos y estructuras
que nos permiten hacer esto.

El comando que nos permite evaluar condiciones en bash es test. El valor de

retorno de test será cero (0) si la expresión es VERDADERA (TRUE), y en cambio,
será uno (1) si la expresión que le pasamos a test es FALSA (FALSE).

Lo que queremos evaluar recibe el nombre de EXPRESIÓN. test recibe las

expresiones de un modo un tanto especial. En el siguiente ejemplo comprobamos si
dos números son iguales o no:

Primero, 7 -eq 7 es lo que se conoce como expresión. De esta forma tan peculiar
al principio le decimos a test que compruebe si 7 es igual a 7 (-eq, abreviatura de
'equals', 'es igual a'). Así que ese primer comando quiere decir: ¿Es 7 igual a 7?
Como ves, test no ha producido ninguna salida por la pantalla, sin embargo, si
comprobamos su valor de retorno, vemos que es cero (0), lo cual indica que la
expresión es verdadera, 7 es igual a 7, efectivamente.

En el siguiente comando estamos comprobando si 7 es igual a 8. Como era de

esperar, el valor de retorno de test es uno (1), lo cual indica que la expresión es
falsa; 7 no es igual a 8.

Ahora supón que antes de todos aquellos comandos hacemos:

Conceptos básicos de Linux JBS

13 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

y que repetimos todo lo anterior, pero en vez de usar 7 y 8, usamos las variables $a
y $b. No hay cambios, test reemplaza las variables por su valor y después efectúa
la comprobación, siendo el resultado final el mismo.

Para no tener que aprender de memoria la forma en que hay que introducirle las
expresiones a test, puedes consultar las páginas del manual: man test

Puedes moverte con las flechas de dirección y volver al shell pulsando la tecla q.

Entonces, para ver cómo y qué otras cosas se pueden evaluar con test, es muy
recomendable seguir el consejo arriba expuesto.

Existe además otra forma de llamar a test que no es con el comando, y que en
nuestros scripts puede ayudarnos a que con un sólo golpe de vista nos demos
cuenta de qué es la expresión que se evalúa. Esta otra forma consiste en poner
entre corchetes (y con espacio) la expresión a evaluar:

Conceptos básicos de Linux JBS

14 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

7. Estructuras condicionales con if

Hemos visto cómo evaluar condiciones con test. Con la ayuda de las estructuras
condicionales que crearemos con if y lo que ya hemos aprendido, podremos por fin
hacer que nuestros scripts se comporten de una forma u otra según las condiciones
que nosotros especifiquemos.

Las estructuras condicionales tienen este aspecto:

Este es el modelo más general con todas las opciones posibles. Si el valor de
retorno de EXPRESION1 es cero, las líneas de comandos de "Bloque 1" serán
ejecutadas. El resto del bloque if será ignorado en ese caso.

Si el valor de retorno de EXPRESION1 no es cero, pero el de EXPRESION2 sí que es

cero, entonces el "Bloque 1" no será ejecutado, mientras que el "Bloque 2" sí
que será ejecutado. El "Bloque 3" será ignorado.

Podemos poner tantos elif's como necesitemos.

Si ni EXPRESION1 ni EXPRESION2 ni cualquier otra de otros elif's que pongamos

retornan cero, entonces el "Bloque 3" será ejecutado.

Usamos fi para terminar la estructura condicional.

Como habrás supuesto, las EXPRESIONes son comandos con test.

Veamos un ejemplo sencillo:

Conceptos básicos de Linux JBS

15 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

En este sencillo ejemplo hacemos que el usuario introduzca un número que queda
guardado en la variable $input. Dependiendo de si el número es menor, igual o
mayor que 21, el script se comporta de una forma u otra (podemos añadir más
líneas de comandos después de los echo's que aparecen ahí). Si el usuario no
introduce nada o introduce una cadena de texto, lo que hay tras else es lo que será
ejecutado, pues ninguna de las condiciones anteriores se cumple.

Date cuenta que en las expresiones entre corchetes podrían haberse sustituidos
estos corchetes por test.

De todos modos, los elif y los else son opcionales, podemos crear una estructura
condicional sin ellos si no los necesitamos. Como muestra, el siguiente ejemplo:

Conceptos básicos de Linux JBS

16 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

Este ejemplo ya se va pareciendo a un programa de los buenos. Estudiémoslo en

detalle:

En primer lugar comprobamos que nos han pasado dos argumentos: el fichero
donde buscar y la cadena de búsqueda. Si no es así, le indicamos al usuario cómo
debe ejecutar el script y salimos.

A continuación comprobamos que el fichero existe. Si no es así, advertimos

convenientemente y salimos.

Ahora viene la línea que hace todo el trabajo: NUM_VECES=`cat "$FICHERO" |

grep --count "$BUSQUEDA"`. Al entrecomillar con las comillas inclinadas el
comando, su salida, en vez de salir por pantalla, quedará guardada en la variable
NUM_VECES. Así, mediante cat y el pipe, grep cuenta el número de veces que el
valor de $BUSQUEDA está en el fichero, que nos queda guardado en $NUM_VECES.

Lo siguiente habla por sí solo.

Coloca esas líneas en un script y dale permisos de ejecución. A continuación,

ejecútalo de las distintas formas posibles: sin argumentos, con un fichero inexistente,
con distintos patrones de búsqueda, etc.

Conceptos básicos de Linux JBS

17 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

Dentro de un bloque de una estructura condicional puedes poner otra (ifs

anidados), y dentro de esa otra puedes poner otra y así sucesivamente. También
podrás poner cuando las veamos, bucles y otras estructuras, así como condicionales
dentro de bucles, etc. Sólo la práctica te dará la suficiente soltura como para poder
hacer que tus scripts hagan cosas más o menos complicadas.

Conceptos básicos de Linux JBS

18 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

8. Comprobar el valor de una variable con case

Escribiendo scripts, es muchas veces necesario comprobar si el valor de una

variable coincide con alguno de los que nosotros estábamos esperando, y si así es,
actuar de una forma u otra dependiendo de este valor.

Ni que decir tiene que eso es posible hacerlo con if, y elseif, pero existe otra
forma más eficiente y cómoda de hacer esto: con la estructura case. Se usa como
sigue:

valor1 y valor2 son valores que nosotros esperamos que la variable pueda
contener, y Bloque 1 y Bloque 2 son los bloques de comandos con lo que
queremos que se haga en cada caso. Podemos poner tantos valores reconocibles
como queramos. Los puntos son precisamente para indicar esto. El * (asterisco) es
un comodín exactamente igual que hacíamos moviéndonos entre directorios en
capítulos anteriores, cualquier cosa que no haya coincidido en alguna de las de
arriba coincidirá aquí. Esto es completamente opcional. No obstante, en el ejemplo
siguiente te darás cuenta de su utilidad.

Los dos ";;" es necesario que se pongan al final de cada opción.

Conceptos básicos de Linux JBS

19 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

En este ejemplo se hace que las opciones tengan que ir precedidas de un doble
guión en forma larga (la única que reconoceremos en este caso), de esta forma
damos a nuestro script un aspecto y un comportamiento más "profesional". Los
argumentos no se suelen hacer preceder de ningún signo; aunque todo esto puedes
ponerlo como tú prefieras, lo importante es que aprecies cómo funciona este tipo de
estructura condicional.

Con exit salimos del script, haciendo que el valor devuelto sea 0 (éxito) o 1 (error)
según los parámetros fueran reconocidos o no.

Dentro de cada uno de los bloques de comandos se pueden poner estructuras

condicionales con if, o incluso otro case.

Conceptos básicos de Linux JBS

20 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

9. Bucles

Los bucles en bash-scripting difieren un poco de lo que son en la mayoría de los

lenguajes de programación, pero vienen a cumplir una misión similar; a solucionar el
problema de "Quiero que mi script haga esto mientras se de esta condición", o "Para
cada uno de los elementos siguientes, quiero que mi script haga esto otro".

Así, tenemos dos tipos de bucles diferentes en bash: for y while.

9.1. Bucles con for

De los propósitos explicados anteriormente a solucionar por los bucles, for viene a
solucionar el segundo. Veamos algunos ejemplos:

En primer lugar apreciamos que todo lo que se puede hacer en un script también se
puede hacer en bash. La estructura de for es la siguiente:

for nombre_var in LISTA; do

comando 1
comando 2
# y así los que queramos

done

nombre_var es el nombre de una variable (el que nosotros queramos, y sólo el

nombre, no precedida de $). LISTA es una lista de elementos, que se la podemos
dar como en el ejemplo anterior, ahí en ese comando, o podemos poner una variable
que ya contenga una lista de elementos (en este caso sí que la precederíamos de $,
para que sea reemplazada por los elementos de la lista que contiene). Después
aprenderemos otras formas posibles de expresar esa lista.

Con este bucle lo que conseguimos es: comando 1, comando 2, etc. se ejecutan
tantas veces como elementos haya en LISTA. Para la primera vez, $nombre_var
valdrá el primer elemento de la lista, para la segunda vez que se ejecuten los

Conceptos básicos de Linux JBS

21 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

comandos valdrá el segundo elemento de la lista, y asi sucesivamente hasta llegar al

último elemento en el que el bucle habrá terminado (y el script seguirá su flujo de
ejecución normal hacia abajo). Ahora ya deberíamos entender el ejemplo anterior.

LISTA puede ser una lista de archivos dada implícitamente. Más concretamente,
podemos usar los wildcards que ya conocemos para referirnos a varios archivos con
un nombre parecido:

Conceptos básicos de Linux JBS

22 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

.* hace referencia a todos los archivos y directorios ocultos de $DIR. Al detectar

for el wildcard, sabrá que los elementos de la lista son cada uno de los archivos
coincidentes. Ejecuta el ejemplo anterior si quieres ver cómo funciona. Puedes hacer
uso con este bucle de lo que ya sabes de wildcards referidos a archivos.

El elemento LISTA del bucle for, puede ser un comando entrecomillado con
comillas laterales; un comando tal que su salida sea una lista de elementos. Así,
sería lo mismo:

for i in *; do

que:

for i in `ls`; do

9.2. Bucles con while

El otro tipo de bucle posible en bash-scripting es el bucle while. Este bucle viene a
cumplir con el propósito de "quiero que se haga esto mientras que se dé esta
condición". Su estructura es la siguiente:

While test CONDICIÓN; do

# Comandos a ejecutar

done

Como ya sabemos usar el bucle anterior, este lo entenderemos con algunos pocos
ejemplos:

Este ejemplo es interesante. La condición para que el bucle se siga ejecutando es

que j valga menos de 10. Observa la forma mediante la cual en cada ciclo del bucle
sumamos 1 a la variable j.

Conceptos básicos de Linux JBS

23 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

Tanto en el bucle for como en el while, podemos usar break para indicar que
queremos salir del bucle en cualquier momento:

La condición es que el bucle se ejecute siempre (test 1 siempre retornará TRUE, y

el bucle se seguirá ejecutando). Pero, si el número introducido es el mismo que el
valor de $MINUM , break hará que se salga de el bucle y continúe ejecutando los
comandos que hubiera fuera del bucle.

Ten en cuenta que en bash scripting, usando la notación $[ ] para hacer cálculos
sólo podemos usar números enteros.

Además, dentro de un bucle while se puede utilizar cualquiera de los elementos ya

conocidos, siempre que se haga correctamente.

Conceptos básicos de Linux JBS

24 PROGRAMACIÓN BÁSICA DE SHELL SCRIPTING

Conceptos básicos de Linux JBS