El uso de los keywords defer, break y continue

No entendí mucho el Continue. Pero esta definición me la dejó claro:

La instrucción continue se usa cuando se busca omitir la parte restante del bucle, volver a la parte superior de este y continuar con una nueva iteración.

Aquí un mejor ejemplo:

package main

import "fmt"

func main(){
	// Continue y break
	for i := 0; i < 10; i++{
		fmt.Println(i)
		if i == 4 {
			fmt.Println("Es 4")
			continue
		}

		// Break
		if i == 4 {
			fmt.Println("Break")
			break
		}
	}
}

Nota importante para la instrucción defer

Algo importante que se debe tomar en cuenta con el uso del defer, es que si dentro de una misma función usas más de un defer, estos son tratados como una pila o en inglés “stack” uno encima del otro lo que genera que los defer se ejecuten con el principio LIFO (Last In First Out / Último en entrar, primero en salir) y hay que ser cuidadosos en ese aspecto.

Aquí dejo un ejemplo donde se puede apreciar mejor el asunto:

package main

import "fmt"

func main() {
   fmt.Println("Inicio")
      for i := 0; i < 5; i++ {
      defer fmt.Println(i)
   }
   fmt.Println("Fin")	
}

Si revisas la salida verás lo siguiente:

Inicio
Fin
4
3
2
1
0

y no

Inicio
Fin
0
1
2
3
4

Como tal vez se podría pensar.

El defer me recuerda al atributo que hay a la hora de llamar un script a HTML que sirve para llamar al archivo luego de cargar el DOM

<script src="app.js" defer></script>

Sin embargo no lo relacione sino hasta que se explicó en la clase es interesante como conceptos de algunos lenguajes se ven en otros de una u otra forma

Para un mejor ejemplo del break es salir de un ciclo for

	for i := 0; i < 10; i++ {
		if i == 7 {
			fmt.Println("Es 7")
			break
		}
		fmt.Println((i))
	}

En el ejemplo se rompe el ciclo y ya no se realizan las demas iteracciones.

El continue es para omitir una iteración de un bucle, dada una condición. Aquí un mejor ejemplo:

package main

import "fmt"

func main() {
	// Continue
	for i := 0; i < 10; i++ {
		if i == 2 {
			continue
		}
		fmt.Print(i, "\n")
	}
}

** defer: ** ejecuta la parte de código especificada al final de la ejecución de la función o método. Como buena práctica usar solo una sentencia “defer” dentro de un bloque.

Vengo del futuro : GO parece fácil pero no lo es del todo XD . Si lees esto animo nada es imposible a mi me encantó el lenguaje ! Saludos! :33

Por ahi se entiende mejor el continue haciendo que imprima i despues del if, porque continue salta a la proxima iteracion sin ejecutar lo que sigue debajo. Ej.

package main

import "fmt"

func main() {
	// Defer: deja para ultimo momento, ejecuta antes de terminar el programa
	// se usa por ejemplo, para cerrar una conexion con una BD, un archivo
	// o para cerrar una conexion de red
	defer fmt.Println("Hola")
	fmt.Println("Mundo")

	// Continue y break
	for i := 0; i < 10; i++ {

		// Continue
		if i == 2 {
			fmt.Println("es 2")
			continue // el Println de abajo no se ejecuta, vuelve al for
		}

		fmt.Println(i)

		// Break
		if i == 5 {
			break
		}
	}
}

Ahora se donde se aplica ‘defer’

Defer:

package main

import "fmt"

func main() {
	defer fmt.Println("Ejecutado al final pese a estar al comienzo gracias a 'Defer'.")
	fmt.Println("Hola Mundo")
}

Continue:

package main

import "fmt"

func main() {
	var i uint8 = 0
	for i < 10 {
		fmt.Println(i)
		i++

		// Continue
		if i == 2 {
			fmt.Println("¡El número que sigue es par!")
			continue
		}

	}
}

Break:

package main

import "fmt"

func main() {
	var i uint8 = 0
	for i < 10 {
		fmt.Println(i)
		i++

		// Break
		if i == 8 {
			fmt.Println("¡Break!")
			break
		}

	}
}

Se pueden tener varios defer, y se ejecutan en orden inverso

package main

import "fmt"

func main() {
	// 2 execute 
	defer fmt.Println("1")
	// 1 execute
	defer fmt.Println("2")
}

El ejemplo del continue es poco claro, falto prepararlo

comentando el keyword continue se obtiene el mismo resultado, el ejemplo no es tan claro, pero lo que indica que se puede hacer con el tiende a dar un poco más de luces en su uso

El instructor no explica bien el uso de CONTINUE. Lo correcto es que, si el flujo del programa encuentra una sentencia CONTINUE dentro del ciclo FOR, no continúa leyendo las sentencias siguientes sino que vuelve al inicio del ciclo FOR y comienza una nueva iteración incrementando la variable del ciclo.

les comparto mi versiòn

package main

import "fmt"

func main() {
	//Defer
	defer fmt.Println("Hola")
	fmt.Println("Mundo")

	for i := 0; i < 10; i++ {
		// break
		if i == 8 {
			fmt.Println("Break")
			break
		}

		if i == 2 {
			fmt.Println("I am 2")
			continue
		}
		fmt.Println(i)

	}
}

resultado

Mundo
0
1
I am 2
3
4
5
6
7
Break
Hola

Definición visual de defer:

La teoría es un poco caótica, pero yo entiendo a la instrucción** continue** como una banderilla que normalmente la utilizamos en una estructura condicional para regresar a la iteración y seguir haciendo algo hasta que se rompa dicha condición.

Acá un ejemplo:

sum := 0
	for i := 1; i < 5; i++ {
		//Omitimos a numeros impares
		if i%2 != 0 {
			continue
		}
		sum += i
	}
	fmt.Println("Suma de pares:", sum)

Como pueden notar, el continue obliga a seguir ejecutando el for hasta que la condición se cumpla (i<5 y onmitir a los impares para que sum tenga el 2+4 esperado = 6)

Muy interesante

😎

Me parece que sería más fácil entender el _continue _si se agregara un print después pero antes del break para ver que eso ya no lo revisaría y es en parte para lo que se utilizaría. Que ya no nos interesa correr lo demás pero que siga adelante el loop.

Buena practica: usar defer por funcion

Esta es una mejor forma de mostrar como funciona continue, es casi el mismo código.

package main

import "fmt"

func main() {
	for i := 1; i <= 10; i++ {
		if i == 2 {
			fmt.Println("Es dos")
			continue
		}

		fmt.Println(i)
	}
}

Apuntes:
El uso de los keywords defer, break y continue

• defer: funciona para hacer que se ejecute la linea de ultimo antes de que muera el programa (sirve para desconectarnos de bases de datos, cerrar un archivo que estemos usano, etc.) Es mala practica usar defer mas de una vez por funcion
• continue: se utiliza cuando segun una condicion dada dentro del ciclo for, puede ser algo que te interese que continue (por ejemplo un error controlado)
• break: se utiliza cuando quieres detener la ejecución del ciclo.

// El uso de keywords
	// defer
	defer fmt.Println("Hola")
	fmt.Println("Mundo")

	// continue y break
	for i := 0; i < 10; i++ {
		fmt.Println(i)

		// Continue
		if i == 2 {
			fmt.Println("Es 2")
			continue
		}

		//break
		if i == 8 {
			fmt.Println("Break")
			break
		}
	}

Aquí una extensión de la clase… código pseudo interactivo y auto explicativo:

package main

import "fmt"

func diferirClase17() {

	fmt.Println("func diferir() { >>> ***** SIMULANDO EL CIERRE DE UNA CONEXIÓN >>> func mainDiferirClase17() {")
}

func diferirOtraFuncion() {

	fmt.Println("func diferirOtraFuncion() { ...... debe imprimirse al final de la 'otraFuncion()'")
	fmt.Println()
}

func otraFuncion() {
	defer diferirOtraFuncion()

	fmt.Println("func otraFuncion() { >>> Os saluda.")
	fmt.Println()
}

func mainDiferirClase17() {

	fmt.Println()
	fmt.Println("===========================")
	fmt.Println("Comando >>> defer funcion()")
	fmt.Println("===========================")
	fmt.Println()

	defer diferirClase17()

	fmt.Println("Este comando ejecuta la función indicada cuando se ha terminado de recorrer toda la función 'padre' de la que " +
		"se hace parte. Útil para cerrar recursos como lo es una conexión a base de datos o un archivo.")
	fmt.Println()

	fmt.Println("Es buena práctica el uso de un solo 'defer' por función.")
	fmt.Println()
	fmt.Println()

	fmt.Println("func mainDiferirClase17() { >>> ***** SIMULANDO LA APERTURA DE UNA CONEXIÓN *****")
	fmt.Println()

	otraFuncion()
}

func funcionContinueBreak() {

	fmt.Println()
	fmt.Println("====================================")
	fmt.Println("Palabras claves 'continue' y 'break'")
	fmt.Println("====================================")
	fmt.Println()

	fmt.Println("Hacen parte del ciclo iterativo FOR... que es el único existente en GO")
	fmt.Println()
	fmt.Println()

	fmt.Println("Se plantea iterar del 0 al 9 pero se saltará la impresión del número 2 y se romperá el ciclo luego de impreso el" +
		" número 7.")
	fmt.Println()

	for i := 0; i < 10; i++ {

		if i == 2 {
			fmt.Println("... Se salta el ciclo antes de imprimir el control de iteración ...")

			continue
		}

		fmt.Println("la iteración va en el número:", i)

		if i == 7 {

			fmt.Println("... se rompe el ciclo ...")

			break
		}
	}
}

func main() {

	mainDiferirClase17()

	funcionContinueBreak()

	fmt.Println()
}

Por si no entendieron break o continue usen este codigo y miren como se comporta

for i := 0; i < 10; i++ {
		if i == 2 {
			fmt.Println(" Es dos! ")
			continue
		}

		// Break
		if i == 8 {
			fmt.Println("Break")
			break
		}

		fmt.Println(i)
	}

package main

import "fmt"

func main() {
	defer fmt.Println("Hola")
	fmt.Println("Mundo")
	

	for i := 0; i < 10; i++ {
		fmt.Println(i)

		if i == 2 {
			fmt.Println("Es 2")
		}

		if i == 8 {
			fmt.Println("Break")
			break
		}
	}
}

Interesante el keyword continue

Dejo mi aporte para entender un poco mejor tanto el Continue como el Break

package main

import "fmt"

func main() {
  // Defer. Ejecuta una función justo al finalizar el programa
  defer fmt.Println("Este al final")
  fmt.Println("Este primero")

  // Continue y Break. Ambos se usan en ciclos
  // Continue se usa cuando se busca omitir el restante de un ciclo.
  for i := 0; i < 15; i++ { //Este ciclo debería llegar hasta 14
    // Continue
    if 2 <= i && i <= 4 {
      fmt.Println("Estoy entre 2 y 4")
      continue
      //Hace un skip del resto del ciclo for.      
    }

    // Break
    if i == 8 {
    fmt.Println("Acabo de llegar a 8, ejecuto un break")
      break
      //Esta instruccion mata el ciclo tan pronto como llega.
    }
    fmt.Println(i)
  }
}

Resultado:

Este primero
0
1
Estoy entre 2 y 4
Estoy entre 2 y 4
Estoy entre 2 y 4
5
6
7
Acabo de llegar a 8, ejecuto un break
Este al final