Bienvenido a la cuarta parte de la serie de tutoriales de secuencias de comandos de shell de HowtoForge (haga clic aquí para leer la parte 1, la parte 2 y la parte 3 del tutorial). En esta parte, cubriremos las diferentes estructuras de control de repetición del shell bash y cómo usar cada estructura proporcionando algunos ejemplos. Comencemos.
Introducción
La estructura de control de repetición, también conocida como estructura de control de bucle, es un tipo de estructura de control en lenguajes de programación que se utiliza para simplificar tareas repetitivas o recursivas. Las declaraciones de bucle optimizan cualquier código al proporcionar una forma de minimizar el código, lo que facilita la resolución de problemas que el código no estructurado que proporciona el mismo resultado. Hay tres tipos de sentencias de bucle que admite bash shell:los bucles for, while y till.
bucles for
El bucle for es una declaración de bucle que utiliza la palabra clave for para declarar una declaración repetitiva. bash admite diferentes sintaxis para la declaración de bucle for:
Sintaxis 1:Estructura For-in
for <varName> in <list>
do
#### your statement here
done
Esta sintaxis comienza con la palabra clave for, seguida de un nombre de variable, la palabra clave in y la lista de valores posibles para la variable. Cada valor de la lista se separará con un espacio y el inicio de las líneas de código que se repetirán se define en do y finaliza con una palabra clave done.
Vamos a crear una instrucción de bucle for simple que le permitirá al usuario ingresar 5 valores y obtener la suma de los números:
#!/bin/bash
result=0;
input=0;
for var in 1 2 3 4 5
do
printf "Input integer %d : " $var
read input
result=$((result+input))
done
echo "the result is " $result
En este ejemplo, la variable var sirve como contador de nuestro bucle. Su valor se define en la lista de números después de la palabra clave in y el shell cambia los valores de la variable var después de cada ejecución del ciclo en la declaración de bucle. Dado que solo hay cinco valores enteros en nuestra lista, Shell ejecutará los códigos dentro de nuestra declaración de bucle solo cinco veces.
Sintaxis 2:Para la instrucción en bucle con valores de lista de cadenas
También puede declarar una variable que contenga la lista de elementos de su contador. Por ejemplo, considere el siguiente código:
#!/bin/bash
list="var1 var2 var3 var4"
var=""
mkdir sample
cd sample
echo creating the "directories...."
for var in $list
do
mkdir $var
done
La línea list="var1 var2 var3 var4" define los valores de la variable de lista. Luego se asignó a var en la línea para var en $list y finalmente, los directorios se crearon en la línea mkdir $var.
Sintaxis 3:sentencia For loop con lista como archivo
También puede recuperar una lista de un archivo existente para usarla en una declaración de bucle en lugar de declararla dentro de su código usando el comando cat. Por ejemplo, abra su editor de texto favorito y luego enumere al menos cinco nombres de directorio.
A continuación, abra una nueva pestaña en el mismo editor de texto y cree un nuevo script. Este script debe guardarse en el mismo directorio donde se guarda la lista de directorios que creó anteriormente.
#!/bin/bash
dirList=$(cat list)
echo "creating directories...."
for var in $dirList
do
mkdir $var
done
Este ejemplo se vuelve útil cuando tienes que crear cientos de directorios en tu computadora con Linux, ¿no crees?
Sintaxis 4:Sintaxis similar a C
for((initialization; boolean_test; increment/decrement))
do
#### your code goes here
done
Quizás, la estructura más familiar del bucle for que admite el shell es la estructura tipo C. El ciclo comienza con la inicialización de la variable de contador y luego el shell evalúa la expresión booleana declarada después de la inicialización. Si el resultado de la expresión booleana es verdadero, entonces el shell ejecutará el conjunto de declaraciones dentro de la cláusula do; de lo contrario, finaliza la declaración en bucle y continúa con la línea después de la palabra clave done. El shell procederá a la siguiente iteración a través de la declaración de incremento o decremento declarada después de la prueba booleana. Como ejemplo, reconstruyamos nuestro primer ejemplo usando esta estructura.
#!/bin/bash
result=0
input=0
for((var=1;var<=5;var++))
do
printf "Input integer %d : " $var
read input
result=$((result+input))
done
echo $result
Instrucción de bucle while
La declaración while es un tipo de estructura repetitiva en bash que utiliza la palabra clave while. A diferencia de la sintaxis de tipo C de la estructura de bucle for, la estructura de control repetitiva while separa la inicialización, la prueba booleana y la declaración de incremento/decremento.
Sintaxis 1:estructura while con declaraciones condicionales basadas en símbolos aritméticos
<initialization>
while(condition)
do
###your code goes here
<increment/decrement>
done
Para poder diferenciar while de las otras declaraciones en bucle, construyamos nuestro primer ejemplo para la declaración while.
#!/bin/bash
result=0
input=0
var=1
while((var <= 5))
do
printf "Input integer %d : " $var
read input
result=$((result+input))
var=$((var+1))
done
echo "the result is " $result
Mirando nuestro ejemplo, la instrucción while comienza con una inicialización de nuestra variable de contador var. A continuación, la prueba booleana se declara después de la palabra clave while y el conjunto de sentencias que se repetirán se declarará dentro de las sentencias do y done. En declaraciones while, el intérprete solo iniciará y ejecutará la repetición de códigos si el resultado de la prueba booleana es verdadero. Por otro lado, la declaración de bucle solo terminará la iteración de códigos cuando la expresión booleana resulte falsa.
Sintaxis 2:While Looping Statement con declaración condicional basada en mnemónicos
<initialization>
while [ <condition> ]
do
####your code goes here
<increment/decrement>
done
También puede declarar una declaración condicional basada en mnemónicos dentro de una declaración de ciclo while. Para la declaración, se utilizará un corchete en lugar de un paréntesis. (Revise las declaraciones condicionales basadas en mnemónicos aquí) Por ejemplo:
#!/bin/bash
var=1;
while [ $var -le 5 ]
do
printf "Input integer %d : " $var
read input
result=$((result+input))
var=$((var+1))
done
echo "the result is " $result
Sintaxis 3:Instrucción de bucle while con instrucción condicional basada en archivo
while read <variable_name>
do
####your code goes here
done <<path to the text file>
Al igual que hicimos en la declaración de bucle for, también puede abrir un archivo de texto y asociarlo en la declaración de bucle while. Por ejemplo:
#!/bin/bash
mkdir sample2
cd sample2
echo "creating directories..."
while read var
do
mkdir $var
done<list
En este ejemplo, he reciclado la lista que creamos hace un tiempo y he creado un nuevo script en el mismo directorio. Tenga en cuenta que si su archivo de texto se encuentra en un directorio diferente, debe proporcionar la ruta exacta del archivo después del símbolo <.
Hasta declaración de bucle
Otro tipo de declaración de bucle que admite bash es la estructura hasta. La declaración hasta ejecuta todos los comandos dentro del ciclo hasta que la expresión booleana declara que los resultados son falsos. Es todo lo contrario de la instrucción while.
Sintaxis 1:Hasta bucle con declaración condicional basada en símbolos aritméticos
until ((<conditional_statement>))
do
####set of commands
done
Pongamos un ejemplo:
result=0
input=0
var=1
until((var > 5))
do
printf "Input integer %d : " $var
read input
result=$((result+input))
var=$((var+1))
done
echo "the result is " $result
Sintaxis 2:Hasta declaración de bucle con declaración condicional basada en mnemónicos
<initialization>
until [ <condition> ]
do
####your code goes here
<increment/decrement>
done
Dado que la declaración hasta es justo lo contrario de la declaración de bucle while, también puede declarar una declaración condicional basada en mnemónicos en la estructura hasta. Sin embargo, para terminar, debe declarar una declaración condicional opuesta, es decir, hacer que la declaración condicional se evalúe como falsa.
!/bin/bash
result=0
input=0
var=1
until [ $var -gt 5 ]
do
printf "Input integer %d : " $var
read input
result=$((result+input))
var=$((var+1))
done
echo "the result is " $result
Conclusión
Esta parte del tutorial cubre las tres estructuras de bucle que admite bash:la declaración de bucle for, while y till. Cada una de estas declaraciones tiene diferente estructura, uso y ventajas. bash es compatible con diferentes estructuras, brindando más opciones a los programadores y, por lo tanto, facilitando la codificación de scripts de shell.