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 28

Preguntas 2

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Reg铆strate o inicia sesi贸n para participar.

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

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

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