Hola mundo en Go

1

Introducción al Curso de Golang

2

¿Qué es, por qué y quienes utilizan Go?

3

Instalar Go en Linux

4

Instalar Go en Mac

5

Instalar Go en Windows

6

Nuestras primeras líneas de código con Go

Variables, funciones y documentación

7

Variables, constantes y zero values

8

Operadores aritméticos

9

Tipos de datos primitivos

10

Paquete fmt: algo más que imprimir en consola

11

Uso de funciones

12

Go doc: La forma de ver documentación

Estructuras de control de flujo y condicionales

13

El poder de los ciclos en Golang: for, for while y for forever

14

Operadores lógicos y de comparación

15

El condicional if

16

Múltiple condiciones anidadas con Switch

17

El uso de los keywords defer, break y continue

Estructuras de datos básicas

18

Arrays y Slices

19

Recorrido de Slices con Range

20

Llave valor con Maps

21

Structs: La forma de hacer clases en Go

22

Modificadores de acceso en funciones y Structs

Métodos e interfaces

23

Structs y Punteros

24

Stringers: personalizar el output de Structs

25

Interfaces y listas de interfaces

Concurrencia y Channels

26

¿Qué es la concurrencia?

27

Primer contacto con las Goroutines

28

Channels: La forma de organizar las goroutines

29

Range, Close y Select en channels

Manejo de paquetes y Go Modules

30

Go get: El manejador de paquetes

31

Go modules: Ir más allá del GoPath con Echo

32

Modificando módulos con Go

Despedida del curso

33

Despedida

Bonus

34

Cheat Sheet Go

35

Librerías para desarrollo web con Go

36

Data Science con Go

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

El poder de los ciclos en Golang: for, for while y for forever

13/36
Recursos

Aportes 66

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

También existe el for range que es cuando se tiene una colección de un objeto

Por ejemplo

listaNumerosPares := []int{2, 4, 6, 8, 10, 12, 14, 16, 18, 20}
	for i, par := range listaNumerosPares {
		fmt.Printf("posicion %d número par: %d \n", i, par)
	}

Solución del Reto

for i := 10; i > 0; i-- {
		fmt.Println(i)
	}

El for forever casi hace despegar hacia marte mi compu
🤣🤣🤣

Aquí dejo el código de la clase mas todos las formas de realizar un ciclo en Golang:

  • For condicional
  • For while
  • For forever
  • For Range
  • For con funciones
  • For con goto tags

Si existe otras que conozcas ponlo en los comentarios 😄 !

package main

import "fmt"

func main() {

	fmt.Println("-------------For condicional-------------")
	// For condicional
	for i := 0; i <= 5; i++ {
		fmt.Println(i)
	}

	fmt.Println("-------------For while-------------")
	// For while
	counter := 0
	for counter < 10 {
		fmt.Println(counter)
		counter++
	}

	fmt.Println("-------------For forever-------------")
	//For forever
	counterForever := 0
	for {
		fmt.Println(counterForever)
		counterForever++
		if counterForever > 12 {
			break
		}
	}

	fmt.Println("-------------For Range-------------")
	//For Range
	arreglo := [8]int{0, 1, 4, 6, 10, 9}
	fmt.Println("Arreglo:", arreglo)

	fmt.Println("Primer ejemplo")
	for i, j := range arreglo {
		fmt.Printf("indice i: %d tiene como valor #%d\n", i, j)
	}

	fmt.Println("Segundo ejemplo")
	for i := range arreglo {
		fmt.Printf("Valor de i: %d\n", i)
	}

	fmt.Println("Tercer ejemplo")
	for _, j := range arreglo {
		fmt.Printf("Valor de i: %d\n", j)
	}

	fmt.Println("-------------For con funciones-------------")
	// For con funciones
	for i := preFor(); condicion(i); i = postFor(i) {
		fmt.Printf("Valor de i: %d", i)
		if i == 7 {
			fmt.Printf(" así que saldremos del ciclo...\n")
			break /// este ejemplo es para usar el break
		}
		fmt.Printf("\n")
	}

	fmt.Println("-------------For con goto tags-------------")
	var i int
CICLO:
	fmt.Println("estamos fuera del for")
	for i < 10 {
		if i == 6 {
			i = i + 3
			fmt.Println("Saltando a etiqueta CICLO con i = i + 3")
			goto CICLO2
		}
		fmt.Printf("Valor de i: %d\n", i)
		i++
	}
CICLO2:
	fmt.Printf("ciclo 2 Valor de i: %d\n", i)
	if i == 9 {
		fmt.Printf("Valor de i: %d\n", i)
		i = i + 3
		fmt.Println("Saltando a etiqueta CICLO con i = i + 3")
		goto CICLO
	}
	fmt.Printf("terminamos\n")

	fmt.Println("-------------Reto for decreciente-------------")
	// Reto for decreciente
	for i := 10; i >= 0; i-- {
		fmt.Println(i)
	}

}

func preFor() int {
	fmt.Println("prefor i")
	return 0
}
func postFor(i int) int {
	fmt.Println("postFor sumemos i")
	i++
	return i
}
func condicion(i int) bool {
	fmt.Println("condicion i")

	return (i < 10)
}

  • un for condicional tiene la siguiente estructura:

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

for es el keyword el i := 0 indica que el indice va a empezar en 0, va a ejecutarse mientras que 1<10 y en cada ciclo iterativo le va a sumar 1 al i.

  • Un for while tiene la siguiente estructura

counter := 0
for counter < 10 {
fmt.Println(counter)
counter++
}

Un for hasta que una condición se cumple.

  • For forever, va a seguri iterando hasta la eternidad

counteForever := 0
for {
fmt.Println(counteForever)
counteForever++
}

En go solo existe un solo ciclo iterativo.

For inverter

package main

import "fmt"

func main()  {
	// For inverter
	counterBreak := 10
	for {
		fmt.Println(counterBreak)
		if counterBreak == 0 {
			break
		}
		counterBreak--
	}
}

Comparto el código visto en la clase:

package main

import "fmt"

func main() {

	//For conditional
	for i := 0; i <= 10; i++ {
		fmt.Println(i)
	}

	fmt.Println("\n")

	// For while
	counter := 0
	for counter < 10 {
		fmt.Println(counter)
		counter++
	}

	// For forever
	counterForever := 0
	for {
		fmt.Println(counterForever)
		counterForever++
	}

}

For inverso:

for reverseCounter > 0 {
		fmt.Println(reverseCounter)
		reverseCounter--
	}
	for i := 10; i > 0; i-- {
		fmt.Println(i)
	}
package main

import "fmt"

func main() {
	for i := 20; i > 0; i-- {
		fmt.Println(i)
	}
}

Es bastante curioso que solo exista el ciclo for, verdaderamente algo remarcable de go.
Cada vez me gusta más este lenguaje.

Solución al reto:

for i := 10; i > 0; i-- {
		fmt.Println(i)
}

solución del reto:

counter := 10
	for counter > 0 {
		fmt.Println(counter)
		counter--
	}
for i := 10; i >= 0; i-- {
	fmt.Println(i)
}

me imagino que el counter forever se debe usar para recorrer estructuras de datos que debe tener una longitud establecida o algo así, como el for in de python, puede ser muy util

Mi solucion del reto

for i := 10; i > 0; i-- {
	fmt.Println("Oh, you missed that one. Try another!")
}
fmt.Println("Nice shooting! Try another one")
package main

import "fmt"

func main(){
	counterBack := 10
	for{
		fmt.Println(counterBack)
		if counterBack != 0
		counterBack--
	}
}

Reto

package main

import "fmt"

func main() {
	const initValue int = 10
	for i := initValue; i >= 0; i-- {
		fmt.Println(i)
	}
}

Hice un nuevo reto para aplicar todo lo aprendido cree 3 funciones 2 reciben un valor entero para recorrerlo con un ciclo y sacar numeros pares e impares y una tercera funcion que hace lo mismo pero saca los valores de una lista.

package main

import (
	"fmt"
)

func numeroImpar(cant int) {

	for i := 1; i <= cant; i++ {
		if i%2 == 1 {
			fmt.Printf("Numero impar: %d\n", i)
		}
	}
}

func numeroPar(cant int) {
	for i := 1; i <= cant; i++ {
		if i%2 == 0 {
			fmt.Printf("Numero par: %d\n", i)
		}
	}
}

func numeroParConListas() {
	lista := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

	for i, numero := range lista {
		if numero%2 == 0 {
			fmt.Printf("Posicion: %d numero par: %d\n", i, numero)
		}
	}
}

func main() {
	numeroImpar(5)
	numeroPar(5)
	numeroParConListas()
} 

Hola chicos!

Hay una instrucción más que se utiliza para hacer un for más estructurado de manera interna.
Quizás les resulte familiar el break y continue en un for.

//Break loop: Instrucción más interna para for
	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)

También podemos utilizar:

for range

	//Utilizando índice y variable
	nums := []int{2, 3, 4, 8}
	for index, num := range nums {
		fmt.Println(index, "->", num)
	}

	fmt.Println()
	
	//Ignorando el índice
	for _, num := range nums {
		fmt.Println(num)
	}
for i := 9; i >= 0; i-- {
	fmt.Println(i)
}

counter := 9
for counter >= 0 {
	fmt.Println(counter)
	counter--
}

Reto cumplido, con más tiempo se puede mejorar.

package main
import "fmt"

func forConditional (index, condition int) {
	fmt.Println("For")
	for i := index; i > -10; i-- {
		fmt.Print(i)
	}
	fmt.Println("")
}

func forWhile (index, condition int) {
	fmt.Println("For while")
	for index > condition {
		fmt.Print(index)
		index--
	}
	fmt.Println("")
}

func forever (start, exit int) {
	fmt.Println("For forever, (with exit)")
	for {
		if start < exit {
			break
		}
		fmt.Print(start)
		start--
	}
	fmt.Println("")
}

func main () {
	forConditional(0, -10)
	forWhile(0, -10)
	forever(0, -10)
}

Ciclo Decremental

for decremental := 10; decremental > 0; decremental-- {
		fmt.Println(decremental)
	}

Ejercicios (algo modificados) de la clase:

func bucleFor(iterator int){
  for i := iterator ; i > 0; i--{
    fmt.Println(i)
  }
}

func bucleWhile(counter int){
  for counter < 50 {
    fmt.Println(counter)
    counter++
  }
}

func bucleForever(counter int){
  for {
    fmt.Printf("Output: %d \n", counter)
    counter++
  }
}
func main(){
//      bucleFor(4)
//      bucleWhile(0)
    bucleForever(0)
}

Reto:

// [...]
func main(){
    for i := 5; i >= 0; i-- {
            fmt.Printf("Countdown: %d \n", i)
     }
}

Parte de mi código:

func ciclos() {

	//En reversa
	counterReverse := 10
	for counterReverse >= 0 {
		fmt.Println(counterReverse)
		counterReverse--
	}

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

	//For while
	counter := 0
	for counter < 10 {
		fmt.Println(counter)
		counter++
	}

	//For forever
	/*counterForever := 0
	for {
		fmt.Println(counterForever)
		counterForever++
	}*/
}

Mi aporte

// Practica: For invertido
	fmt.Println("For while invertido")
	counterDrecemental := 10
	for counterDrecemental > 0{
		fmt.Println(counterDrecemental)
		counterDrecemental --
	}

😃

For Forever 😎

😎

Aquí se puede observar más calmadamente cada segundo el loop For forever, haciendo uso del package time

package main

import (
	"fmt"
	"time"
)

func main() {
// For forever
	counter := 1
	for {
		fmt.Println(counter)
		counter++
		time.Sleep(1 * time.Second)
	}
}

Reto

	for j := 25; j > 0; j-- {
		fmt.Println(j)
	}

Código del reto:

import "fmt"
func main () {

	fmt.Println("Ciclo decremental")
	for j := 10; j > 0; j-- {
		fmt.Println(j)
	}

}

Reto 😄

<
package main

import "fmt"

func main() {

// Reto for decremento
	for i := 10; i >= 0; i-- {
		fmt.Println(i)
	}

> 
	for i := 10; i > 0; i-- {
		fmt.Println(i)
	}

	for i := 10; i >= 1; i-- {
		fmt.Println(i)
	}
counter := 10
for counter >= 0 {
	fmt.Println(counter)
	counter--
}

Clase pseudo interactiva. Se puede probar ejecutando este código

package main

import "fmt"

func main() {

	fmt.Println()
	fmt.Println("====================")
	fmt.Println("Estructura Iterativa")
	fmt.Println("====================")
	fmt.Println()

	fmt.Println("En su forma básica, es similar a C y Java-kotlin, solo que las indicaciones del ciclo no están" +
		" entre paréntesis")
	fmt.Println()

	fmt.Println("for i:= 0; i < 10; i++ { fmt.Println(\"A la cuenta de...\", i) }")
	fmt.Println()

	fmt.Println("lo anterior produce:")
	fmt.Println()

	for i := 0; i < 10; i++ {
		fmt.Println("A la cuenta de...", i)
	}

	fmt.Println()
	fmt.Println("A continuación los resultados de un par de experimentos (ver el código fuente):")
	fmt.Println()

	fmt.Println("Experimento 1 - Sin definir inicio de la variable de control:")
	fmt.Println("_____________________________________________________________")
	fmt.Println()

	fmt.Println("Con saltos de 2 en 2")
	fmt.Println()

	var variable int8 = 0

	for ; variable < 10; variable = variable + 2 {

		fmt.Println("De dos en dos son:", variable)
	}

	fmt.Println()

	fmt.Println("Experimento 2 - Aplicando el Fin del Ciclo de otra forma:")
	fmt.Println("_________________________________________________________")
	fmt.Println()

	fmt.Println("Ver el uso de la misma variable estableciéndola de nuevo en cero.")
	fmt.Println()

	for variable = 0; ; variable = variable + 2 {

		fmt.Println("Sumo otros dos:", variable)

		if variable > 10 {
			break
		}
	}

	fmt.Println()
	fmt.Println("Experimento 3 - Conservando en la definición del FOR solo el incremento de la variable.")
	fmt.Println("_______________________________________________________________________________________")
	fmt.Println()

	variable = 0

	for ; ; variable = variable + 3 {

		if variable > 12 {
			break
		}

		fmt.Println("De 3 en 3 son", variable)
	}

	fmt.Println()
	fmt.Println("======================================")
	fmt.Println("<> Retomando el video:::: FOR While <>")
	fmt.Println("======================================")
	fmt.Println()

	fmt.Println("Este se puede definir de la siguiente forma y funciona:")
	fmt.Println()

	fmt.Println("for ; otraVariable > 0 ; { fmt.Println(\"Countdown...\", otraVariable); otraVariable-- } ")

	fmt.Println()
	fmt.Println("Pero al guardar el archivo el Plugin le quita los ';', quedando:")
	fmt.Println()

	fmt.Println("for otraVariable > 0 { ... }")
	fmt.Println()

	fmt.Println("Resultados::::::::::::")
	fmt.Println()

	var otraVariable int8 = 10

	for otraVariable > 0 {
		fmt.Println("Countdown...", otraVariable)
		otraVariable--
	}

	fmt.Println()
	fmt.Println("<> FOR forever <>")
	fmt.Println("-----------------")
	fmt.Println()

	fmt.Println("Se puede definir de la siguiente forma:")
	fmt.Println()

	fmt.Println("for ; ; { fmt.Println(otraVariable); otraVariable-- }")

	fmt.Println()
	fmt.Println("Pero al guardar el editor lo deja como:")
	fmt.Println()

	fmt.Println("for { fmt.Println(otraVariable); otraVariable-- }")
	fmt.Println()
}

una lógica mala de un for también podría hacer un loop infinito

for i := 0; i < 1; i–

Aqui mi reto!

	for c:= 10; c > 1; c-- {
		fmt.Println(c)
	}

Reto completado 😃

reto:

package main
import("fmt")
func main(){
decre := 100
for decre > 0{
fmt.Println(decre)
decre--
    }
}

reto completado

func main() {
	counter := 10
	for counter >= 0 {
		fmt.Println(counter)
		counter--

	}
}
package main
import "fmt"

func main() {
  //cuenta regreciva
  contador := 10
  for contador >= 0 {
    fmt.Println(contador)
    contador--
  }
  
}```
package main

import "fmt"

func main() {
	// For condicional
	for i := 0; i <= 10; i++ {
		fmt.Println(i)
	}

	fmt.Printf("\n")

	// for while
	counter := 0
	for counter < 10 {
		fmt.Println(counter)
		counter++
	}

	// for forever
	var counterForever int8 = 0
	//counterForever := 0
	for {
		fmt.Println(counterForever)
		counterForever++
	}
}

Asumecha, los cores del profe van a la velocidad de Flash

	counter = 10
	for counter >= 0 {
		fmt.Println(counter)
		counter--
	}

// For condicional
for i := 10; i >= 1; i-- {
fmt.Println(i)
}
// For while
counter := 10
for counter >= 1 {
fmt.Println(counter)
counter–
}

package main

import "fmt"

func main(){
	for i:=10; i >= 0; i--{
		fmt.Println(i)
	}
}

Ejemplo de las diferentes formas de usar el For

package main

import "fmt"

func main() {

	//Un for normal
	fmt.Printf("***** Ejemplo de un ciclo For *****\n")
	for i := 0; i < 10; i++ {
		fmt.Printf("El valor de i -> %d \n", i)
	}

	fmt.Printf("***** Ejemplo de un ciclo while *****\n")
	//Simula un while como se conoce en otros lenguajes
	counter := 0
	for counter < 10 {
		fmt.Printf("El valor de i -> %d \n", counter)
		counter++
	}

	fmt.Printf("***** Ejemplo de un ciclo Forever *****\n")
	fmt.Printf("***** Corralo bajo su propio riesgo *****\n")
	// counter = 0
	// for {
	// 	fmt.Printf("El valor de i -> %d \n", counter)
	// 	counter++
	// }

	fmt.Printf("***** Ejemplo de un ForEach  *****\n")
	numerosPrimos := [6]int{2, 3, 5, 7, 11, 13}
	fmt.Println("Posición->[Valor]")
	for index, element := range numerosPrimos {
		fmt.Printf("%d->[%d]\n", index, element)
	}

	fmt.Printf("***** Reto de recorrer de forma inversa *****\n")
	counter = 9
	for counter >= 0 {
		fmt.Printf("El valor de i -> %d \n", counter)
		counter--
	}
}

La forma en la que resolví el reto 😃

package main

import "fmt"

func main() {
	for i := 10; i >= 0; i-- {
		fmt.Println(i)
	}
}

Un ejemplo del uso de “for range”:

CODIGO:

package main

import "fmt"

func invertirTexto(texto string) string {
	textoInvertido := ""
	for _, c := range texto {
		textoInvertido = string(c) + textoInvertido
	}
	return  fmt.Sprintf("\"%s\"", textoInvertido)
}

func main() {
	texto := "Curso Básico de Programación en Go"
	fmt.Printf("Texto = \"%s\"\n", texto)
	fmt.Println("Texto Invertido = ", invertirTexto(texto))
}

RESULTADO:

Texto = "Curso Básico de Programación en Go"
Texto Invertido =  "oG ne nóicamargorP ed ocisáB osruC" 

CODIGO:

package main import "fmt" func main() { 	// for contrario 	for i := 10; i > 0; i-- { 		fmt.Println(i) 	} }

RESULTADO:

10
9
8
7
6
5
4
3
2
1

Reto:

package main

import "fmt"

func main() {
	// for contrario
	for i := 10; i >= 0; i-- {
		fmt.Println(i)
	}
}
10
9
8
7
6
5
4
3
2
1
0

Aquí mi solución al reto

		// Challenge
	start := 20
	for i := start; i >= 0; i-- {
		fmt.Println(i)
	}

package main

import “fmt”

func main() {

//for condicional
for i := 10; i >= 0; i-- {
	fmt.Println(i)
}

}

Solución al reto en una función:

El counter forever he visto que se usa para cosas como buffers de información, como escuchar eventos

Solución al reto:

for i := 20; i >= 0; i-- {
		fmt.Println(i)
	}
//For a la inversa
	for i := 10; i >= 0; i-- {
		fmt.Println(i)
	}

Asi resolvi el reto:

package main

import "fmt"

func main() {
	var i int = 70
	for i > 0 {
		fmt.Println(i)
		i--
	}
}

Challenge inverse for

func forChallenge() {
	for i := 50; i >= 0; i-- {
		fmt.Println(i)
	}
}```

Solución del reto

package main

import "fmt"

func main()  {

	// Reto: cuenta regresiva usando for
	counter := 5
	fmt.Println("Cuenta regresiva usando GO:")
	for counter > 0 {
		fmt.Println(counter)
		counter--
	}

}
for i := 10; i > 0; i-- {
		fmt.Println(i)
	}

for i := 10; i >= 0; i-- {
		fmt.Println(i)
	}

utlizar unicamente for para los ciclos me gusta bastante

for inverso

for i := 10; i > 0; i-- {
	fmt.Println(i)
}