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 18

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.

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