No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Programación en Bash Shell

Curso de Programación en Bash Shell

Marco Antonio Toscano Freire

Marco Antonio Toscano Freire

Loop Anidados

26/43
Recursos

Aportes 19

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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

Aquí una explicación que me ayudo a entender mejor la clase
https://blogs.upm.es/estudiaciencia/bucles-y-condicionales/

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[*]}"

4 de los 3 minutos del video dijo tema

d + $ les permite eliminar desde donde esta el cursor hasta el final de la linea en vim

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.

La verdad esta clase si no ententi 😦

Buena explicación, se podría mejorar utilizando ejemplos más útiles.

Esto me recordó mucho a Python... ```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() ```
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: ```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.

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

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: ```bash resultado=`ls -l` echo "El contenido del directorio es: $resultado" ``` Ejemplo con `$()`: ```bash 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.
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: ```bash resultado=`ls -l` echo "El contenido del directorio es: $resultado" ``` Ejemplo con `$()`: ```bash 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.
<h5>Ejemplo</h5>
#!/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

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

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

Los colores de vim no ayudan mucho, no se ve a veces que es lo que anda escribiendo

#!/bin/bash

for file in $(ls)
do
    for number in {1..4}
    do
        echo "Filename: $file-$number"
    done
done