No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

El uso de los keywords defer, break y continue

17/36
Recursos

Aportes 39

Preguntas 4

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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 鈥渟tack鈥 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 鈥渄efer鈥 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 鈥榙efer鈥

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 鈥榝renar鈥 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 鈥渃ontinue鈥 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