Uso de Keywords Defer, Break y Continue en Go
Contenido del curso
José Patricio Saavedra Vergara
Juan Camilo Espitia
Cristian Blandon
Róger Antonio Ordóñez Flores
Emanuel Alvarado Godinez
Royer Guerrero Pinilla
Julian Camilo Hermida Delgado
Nicolas Pereyra
Osmandi Gomez
Gerardo Ruben Marin Riveroll
Enzo Venturi
jhon.ochoa
Luis Daniel Hernández Guevara
Eliaz Bobadilla
Ivan Aranda
Wilson Fernando Antury Torres
Gerardo Manuel Reyes Fernández
Willem Franco
Daniel Miguel Ruiz Tinajero
Juan Sebastián Agudelo
BALFRE VAZQUEZ CASTREJON
Jonathan David Olivos
Nicolás Peralta Páez
Said Hernandez
Osvaldo Frias
Osvaldo Frias
Manuel Roa Ojeda
Guillermo Leonardo Rossi
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 } } }
prueba este codigo en la consola cuando lo ejecutes te daras cuenta que el no recorre las lineas sino hasta que llega al continue y corta la ejecucion dentro del bloque del loop y pasa al siguiente iterador.
<code> for i := 0; i < 10; i++ { //continue if i == 2 { fmt.Println("llegue a 2") continue } //break if i == 8 { fmt.Println("llegue a 2") break } fmt.Println(i) }
Creo que la definición lo complica más 😅
Mi forma de entender continue es pensar que si la ejecución del ciclo toca el continue, justo esa iteración actual parará, la variable iteradora se incrementará y pasaremos de una a la siguiente iteración sin ejecutar lo que quede del ciclo.
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.
Este artículo te podría interesar sobre defer y el funcionamiento por detrás.
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") } }
En c++ el continue sirve para saltear la ejecucion de la vuelta actual del ciclo hasta la siguiente es decir podria ser por ejemplo:
func a(x int){ for i := 0;i< 10;i++ { if i == x { continue } fmt.Println("i = ",i) } }
El codigo anterior haria por ejemplo que se mostraran por consola todos los numeros de i exceptuando a aquel que sea igual al parametro x, ya que saltearia a la ejecucion de la siguiente vuelta.
o por lo menos asi seria en c++, alguien sabe si en go es igual?
Así es, continue en Go dentro de un ciclo for lo que hace es pasar a la siguiente iteración de dicho ciclo.
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.
Definición visual de defer:
Defer es como el finally en java
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.
## Dejo mi aporte para que se entienda un poco más el continue
for i := 1; i \<= 10; i++ { 	if i%2 { 	 continue // Salta a la siguiente iteración si el numero es par 	} 	fmt.Println(i) // Imprime solo números pares }
La explicación del CONTINUE/BREAK no fue muy clara. El break se utiliza cuando necesitamos por alguna razón detener el ciclo totalmente. Por otro lado, el continue se utiliza cuando quieres que cierto código no se ejecute pero solo para el valor actual, es decir, el código que sigue no se ejecutará para el valor actual, y <u>continuamos</u> con el siguiente valor.
Concuerdo con esta explicación, nos podrían ayudar a mejorar esta explicación del continue o en sus revisiones del curso debido a que genera confusión. Gracias.
Igualmente creo que por eso esta la comunidad y aqui podran ver los estudiantes para que no se confundan con el continue.
Piensen en el continue como un skip, cuando se cumple la condicion para que haga un continue el codigo sencillamente salta a la siguiente iteracion y no continua con el resto del codigo que hay dentro del bloque del for
aqui mi ejemplo de defer conectando a DB
package main import ( "fmt" "strings" ) func openDBConn(db string) string { fmt.Println("Abriendo conexion con ", db) return strings.ToUpper(db) } func closeDBConn(db string) string { fmt.Println("Cerrando conexion con ", db) return strings.ToLower(db) } func openFile(filename string) { fmt.Println("Abriendo", filename) } func closeFile(filename string) { fmt.Println("Cerrando", strings.ToUpper(filename)) } func step1(db string) { myFile := "Untitle.txt" defer closeDBConn(db) db = openDBConn(db) contenido := leeArchivo(myFile) insert(db, myFile, contenido) } func insert(db, filename, contenido string) { fmt.Printf("Insertando en %s el contenido del archivo %s\n", db, filename) fmt.Println(contenido) } func leeArchivo(filename string) string { defer closeFile(filename) openFile(filename) fmt.Println("Se leyo el archivo con exito") return "Este es contenido es ..." } func main() { // Ejemplo de abrir la conexion a bd // leer un arhcivo e // insertar en la DB myDB := "Oracle" step1(myDB) } ```package main import ( "fmt" "strings") func openDBConn(db string) string { fmt.Println("Abriendo conexion con ", db) return strings.ToUpper(db)} func closeDBConn(db string) string { fmt.Println("Cerrando conexion con ", db) return strings.ToLower(db)} func openFile(filename string) { fmt.Println("Abriendo", filename)} func closeFile(filename string) { fmt.Println("Cerrando", strings.ToUpper(filename))} func step1(db string) { myFile := "Untitle.txt" defer closeDBConn(db) db = openDBConn(db) contenido := leeArchivo(myFile) insert(db, myFile, contenido)} func insert(db, filename, contenido string) { fmt.Printf("Insertando en %s el contenido del archivo %s\n", db, filename) fmt.Println(contenido)} func leeArchivo(filename string) string { defer closeFile(filename) openFile(filename) fmt.Println("Se leyo el archivo con exito") return "Este es contenido es ..."} func main() { // Ejemplo de abrir la conexion a bd // leer un arhcivo e // insertar en la DB myDB := "Oracle" step1(myDB)}
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 } } }
Fan de tus apuntes, ojala los siga viendo :D
Ahora se donde se aplica 'defer'
...defer is especially useful for releasing resources that must be released under any conditions...
También el profesor lo menciona, sirve para liberar recursos por ejemplo la conexión de una BD.
Es buena práctica escribir el defer al final o al principio ?? Según su función para mí es más lógico escribirlo al final. Qué opinan ??
en el ejemplo de continue, si no lo pongo funciona igual, entonces cual es la diferncia en poner o no continue?
