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

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")
	}
}

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
		}
	}
}

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

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
		}

	}
}

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.

** 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.

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.

Defer es como el finally en java

package main

import (
	"fmt"
)

func main() {
	//Defer
	defer fmt.Println("Hola") // It is executed at the end of the code, it is recommended to use a maximum of one defers per function
	//In the case there is more than one defer, they will be treated as a stack (LIFO)
	defer fmt.Println("Que tal")
	fmt.Println("Mundo")

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

		//continue
		if i == 2 {
			fmt.Println("Es 2")
			continue //It jumps to the next iteration without executing the code below
		}

		fmt.Println(i)

		if i == 8 {
			fmt.Println("Break")
			break //It breaks the loop without executing the next iterations
		}
	}

}

Ahora se donde se aplica ‘defer’

En la llamada de una función puede haber más de un defer, en ese caso se ejecutaran en orden inverso al llegar al final de la funcion con los contiene:

package main

import "fmt"

func main() {
    fmt.Println("Comienzo de la función principal")
    defer fmt.Println("Primero en defer")
    defer fmt.Println("Segundo en defer")
    defer fmt.Println("Tercero en defer")
    fmt.Println("Fin de la función principal")
}

Su salida sera:

Comienzo de la función principal
Fin de la función principal
Tercero en defer
Segundo en defer
Primero en defer

el keyword defer tambien se utiliza en html para cargar el JS en la cabecera y no al final del body

defer: keyword para indicar que se ejecute al final de nuestro codigo, equivalente a la sección finally de un try … except … finally
continue: si encuentra este keyword, regresará a evaluar la condición del ciclo for y si cumple entra al for y sino terminará el for. Lo importante del continue, es que ya no ejecuta el código que se encuentre después o abajo del continue.
break: al encontrar esta keyword, termina si o si con el ciclo for, sin importar ninguna condición.

La explicación del continue no está muy clara. En realidad se utiliza para omitir el resto de la función y saltar directo a la siguiente iteración.

Esta mal explicado el continue, ya que el continue se usa para ‘frenar’ la iteracion actual y regresa a la siguiente iteracion (no deja de ejecutar el codigo a diferemcia de break).

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

		//Continue
		if i == 2 {
			continue
			fmt.Println("Hemos llegado al numero 2 pero no se ejecuta este print porque pusimos un continue en la linea anterior")

			// No frena a la ejecucion como lo haria break.
		}

Se debería repetir el video y modificar el ejemplo del uso de keyword continue, porque genera confusión.

Otro uso del breack interesante es el break <label> donde poemos etiquetar una zona e ciclos aunque esten anidados y con el llamado del break salir de todos los ciclos anidados a la vez,

Este truco de los labels sirve también para otras cosas con el uso del goto, es mas orientado a programación estructurada, pero es un tip interesante.

func main() {
label:
	for i := 0; i < 100; i++ {
		fmt.Println("i = ", i)
		for j := 0; j < 10; j++ {
			fmt.Println("j = ", j)
			if i+j == 3 {

				break label
			}
		}
	}
	fmt.Println("Salí de los ciclos")
}

Creo que el en tendimiento del CONTINUE es un poco confuso debido a al println que tiene antes pero, si quieres entiende el CONTINUE como si fuera un SKIP es mas un salto a otro es decir si cumple una condicion ya no deberia imprimir eso sino saltar al siguiente es decir en este caso cuando evalue el 2 deberia imprimir lo siguiente 0, 1, 3, 4… espero les ayude

Creo que hay un error en tu explicación referente al continue.

Estoy aprendiendo GO, pero ya manejo otros lenguajes, así que con seguridad te puedo mencionar que la palabra “continue” sirve para saltar una iteración, no para continuar un código que tenga errores, es decir, en tu caso tienes que si i == 2 lo salte, sí, lo hace, pero como tienes el printLn antes de esa condición, aún así te sigue apareciendo en terminal. Saludos.

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

😎

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