Domina los loops anidados en Bash para automatizar tareas repetitivas con precisión. Aprenderás a usar un for primario que recorre archivos y un for secundario que itera un rango {1..4}, concatenando resultados con un simple echo. El enfoque es directo, práctico y aplica a entornos como Ubuntu con scripts .sh.
¿Qué son los loops anidados en Bash y para qué sirven?
Los loops anidados son una sentencia de iteración dentro de otra. Funcionan de forma similar a los IF anidados, pero con bucles: un bucle externo recorre una lista y un bucle interno procesa cada elemento con otra lista o rango. Así se multiplican combinaciones y se automatiza trabajo repetitivo.
¿Cómo se construye el for primario y el for secundario?
La secuencia parte de crear un nuevo programa .sh, imprimir un título y luego armar el bucle externo e interno. Se enfatiza reutilizar conceptos previos del for y mantener el formato con do/done para cada bucle.
Pasos clave:
Ejemplo de fragmento en Bash:
echo "loops anidados" # for primario: recorre archivos del directorio actual for file in *; do # for secundario: recorre un rango del 1 al 4 for nombre in {1..4}; do echo "nombre del archivo: ${file}_${nombre}" done done
Claves técnicas:
¿Qué resultado se obtiene y qué aprendizajes clave deja?
Al ejecutar el script, se imprime cada nombre de archivo del directorio cuatro veces, una por cada valor del rango. La salida evidencia que el for interno se repite por cada iteración del for externo, confirmando el patrón de iteración dentro de iteración.
Aprendizajes clave:
¿Tienes otros usos de loops anidados en Bash o variaciones con rangos distintos? Comparte tus ideas y ejemplos en los comentarios.
Gustavo Wilgenhoff
Programa para listar las líneas de codigo de todos los archivos
for file in $(ls *.sh) do echo "--------------- $file ---------------------" while read -r linea; do echo "$linea" done < "$file" done
Jordan Arellano Rosero
Fredy Mendoza Vargas
Gracias por el aporte
David Rodriguez
De 00:00 hrs a 23:59 hrs
for ((i=00; i<24; i++)) do for ((ii=0; ii<60; ii++)) do contador=$(($contador+1)) if [ $i -lt 10 ]; then hour="0$i" else hour=$i fi if [ $ii -lt 10 ]; then min="0$ii" else min=$ii fi hourarray[$contador]="$hour:$min" done done echo "Valores Array : ${hourarray[*]}" echo "Tamaño Array : ${#hourarray[*]}"
Jordan Arellano Rosero
nice
Juan Esteban Velez Muñoz
4 de los 3 minutos del video dijo tema
Reinaldo Mendoza
no se si antes no lo hacia pero ahora lo escucho todo el tiempo, jaja
Miguel Angel Reyes Moreno
¿4 de los 3 minutos? Sería 3 de los 4 minutos xD
Reinaldo Mendoza
d + $ les permite eliminar desde donde esta el cursor hasta el final de la linea en vim
DAVID EDUARDO BAEZ SANCHEZ
Entendido
#!/bin/bash # Programa para utilizar While # DBZ echo "Loops Anidados" for fil in $(ls) do for nombre in {1..4} do echo "Nombre archivo:$fil _ $nombre" done done
Este ejemplo que pusieron me parece super interesante
for file in $(ls *.sh) do echo "--------------- $file ---------------------" while read -r linea; do echo "$linea" done < "$file" done
In Bash, each of these notations serves a different purpose:
1. $\[ something ]: This notation is deprecated and should not be used. It was used for arithmetic expansion in older versions of Bash. The preferred modern syntax for arithmetic expansion is $(( something )).
2. ${ something }: This notation is used for variable expansion and allows you to specify the boundaries of a variable name explicitly. It's useful when you want to concatenate a variable with other text or when the variable name might be ambiguous. For example, ${var}iable would expand to the value of the variable $var followed by the string iable.
3. $( something ): This notation is used for command substitution. It allows you to execute a command and use its output as part of another command or expression. For example, $(date) would execute the date command and substitute its output (the current date and time) into the command or expression.
4. $(( something )): This notation is used for arithmetic expansion. It allows you to perform arithmetic operations and evaluate arithmetic expressions. For example, $(( 2 + 3 )) would evaluate to 5.
To summarize:
- ${ something }: Variable expansion
- $( something ): Command substitution
- $(( something )): Arithmetic expansion
The $\[ something ] notation is outdated and should be avoided in favor of $(( something )) for arithmetic operations.
Berly Danilo Quispe Yana
La verdad esta clase si no ententi :(
German Tellez Vanegas
Buena explicación, se podría mejorar utilizando ejemplos más útiles.
Marvin Javier Santos Fernández
Miguel Angel Reyes Moreno
Esto me recordó mucho a Python...
import os \# Programa para ejemplificar el uso de loops anidados def main():   print("Loops anidados")   \# Iterar sobre los archivos en el directorio actual   for file in os.listdir('.'):   \# Iterar en un rango de 1 a 4   for nombre in range(1, 5):   print(f"nombre archivo: {file} \_ {nombre}") if \_\_name\_\_ == "\_\_main\_\_":   main()
Mario Alexander Vargas Celis
Los loops anidados en Bash son bucles que se ejecutan dentro de otros bucles. Esto significa que, por cada iteración del bucle externo, el bucle interno se ejecutará completamente.
### Ejemplo de loops anidados en Bash:
\#!/bin/bash for i in {1..3} # Bucle externo do   echo "Bucle externo, i = $i"   for j in {1..2} # Bucle interno   do   echo " Bucle interno, j = $j"   done done
### Salida esperada:
Bucle externo, i = 1   Bucle interno, j = 1   Bucle interno, j = 2 Bucle externo, i = 2   Bucle interno, j = 1   Bucle interno, j = 2 Bucle externo, i = 3   Bucle interno, j = 1   Bucle interno, j = 2
### Explicación:
- El bucle externo (for i in {1..3}) se ejecuta tres veces.
- Por cada iteración del bucle externo, el bucle interno (for j in {1..2}) se ejecuta completamente, lo que significa que imprimirá los valores de j dos veces antes de que el bucle externo pase a la siguiente iteración.
Este concepto es útil cuando se necesita trabajar con estructuras repetitivas o matrices multidimensionales.
Joan Benavides Olivera
Script escrito y probado en Ubuntu 18.04 #Programa para mostrar la serie de Fibonacci hasta la posición introducida 5 declare -i loop_control=2 #declare "loop_control" as Integer 6 declare -i fib_num_A=0 7 declare -i fib_num_B=1 8 declare -i limit_serie=3 9 declare -i stop=0 10 11 echo "FIBONACCI SERIE" 12 read -p "Enter the length of fibbonacci serie (min. 3): " limit_se rie 13 #echo -e "" 14 15 while (( $stop == 0 )) 16 do 17 if (( $limit_serie < 3 )); then 18 19 echo -e "Limit must be at least 3!!" 20 read -p "Enter the length of fibbonacci serie (min. 3): " limit_serie 21 22 else 23 # The serie is printed 24 25 echo "Num 1: $fib_num_A" 26 echo "Num 2: $fib_num_B" 27 28 while (( $loop_control < $limit_serie )) # -ne. Not Equal 29 do 30 aux=$((fib_num_A+fib_num_B)) 31 echo "Num $((loop_control+1)): $aux" 32 33 fib_num_A=$fib_num_B 34 fib_num_B=$aux 35 36 loop_control=$loop_control+1 37 done 38 stop=1 #stop the main while loop 39 fi 40 done
Jose Miguel Diaz
Compi te recomiendo que cuando compartas un codigo uses la herramienta de la caja de comentarios "</> Código" ya que de la manera que lo compartes es visualmente molesto.
Eddie Andres Rios Elgueta
En Bash scripting, puedes ejecutar comandos de la terminal utilizando la sintaxis de comillas invertidas (````) o la sintaxis $(). Ambas formas permiten ejecutar un comando y capturar su salida para ser utilizada en tu script.
Ejemplo con comillas invertidas:
resultado=`ls -l` echo "El contenido del directorio es: $resultado"
Ejemplo con $():
resultado=$(ls -l) echo "El contenido del directorio es: $resultado"
Ambos ejemplos son equivalentes. La salida del comando ls -l se captura en la variable resultado, y luego se imprime en el siguiente comando echo. Puedes utilizar cualquiera de las dos formas según tu preferencia o necesidades. La forma $() es más moderna y se recomienda generalmente por ser más legible y fácil de anidar.
Eddie Andres Rios Elgueta
En Bash scripting, puedes ejecutar comandos de la terminal utilizando la sintaxis de comillas invertidas () o la sintaxis $()`. Ambas formas permiten ejecutar un comando y capturar su salida para ser utilizada en tu script.
Ejemplo con comillas invertidas:
resultado=`ls -l` echo "El contenido del directorio es: $resultado"
Ejemplo con $():
resultado=$(ls -l) echo "El contenido del directorio es: $resultado"
Ambos ejemplos son equivalentes. La salida del comando ls -l se captura en la variable resultado, y luego se imprime en el siguiente comando echo. Puedes utilizar cualquiera de las dos formas según tu preferencia o necesidades. La forma $() es más moderna y se recomienda generalmente por ser más legible y fácil de anidar.
Juan Manuel Hincapié
Ejemplo
#!/bin/bash #Programa para ejemplificar el uso de los Loops Anidados #Author: Juan Manuel echo "Loops Anidados" for fil in $(ls) do for nombre in {1..4} do echo "Nombre Archivo: $fil _ $nombre" done done
Diego Andrés Beltrán Garavito
Hola, dejo mi script
# ! /bin/bash # Programa para uso de loops anidados # Author Diego Beltran histagram @diegodevelops echo "Loops anidados" for fil in $(ls) do for nombre in {1..4} do echo "nombre del archivo es:$fil y cuenta del anidado es $nombre" done done``` Saludos
Jose Suarez
Codigo:
# ! /bin/bash # Programa para ejemplificar el uso de los loops anidados # Autor: Jose Suarez echo "Loops Anidados" for fil in $(ls) do for nombre in {1..4} do echo "Nombre Archivo: $fil _ $nombre" done done
Oscar Aragón Juárez
Los colores de vim no ayudan mucho, no se ve a veces que es lo que anda escribiendo
Juan Pablo Izquierdo Clavijo
Debes aumentar el contraste de pantalla para notar mejor las letras en azul….
Juan David Cajamarca Acuña
#!/bin/bash for file in $(ls) do for number in {1..4} do echo "Filename: $file-$number" done done
Solo muestra las líneas de operaciones no de los comentarios, buen programa, en el done del while se lee como finaliza cuando sea menor a todos los $files del for
# !/bin/bash for file in $(ls *.sh) do echo"--------------- $file ---------------------" while read -r linea; do echo"$linea" done < "$file" done
