Ciclo For

Para tener en cuenta, hay mas formas de hacer for, se puede usar como un while en otros lenguajes, ya que hasta donde se no existe en go

number := 1
for number < 10 {
	fmt.Println("First", number)
	number++
}

for number = 1; number <= 10; number++ {
	fmt.Println("Second", number)
}

number = 1
for {
	fmt.Println("Continue")
	fmt.Println("Insert number: ")
	fmt.Scanln(&number)
	if number == 100 {
		break
	}
}

// Sintaxis clásica para definir un ciclo for
for i := 0; i < len(list.tasks); i++ {
    fmt.Println("Index:", i, "task:", list.tasks[i].name)
}

Este sintaxis se divide en 3 partes divididas por punto y coma:

• i := 0 es la variable que servirá como indice para el ciclo y cual será su valor inicial.
• i < len(list.tasks) condición para terminar el ciclo.
• i++ indica como crecerá el ciclo.

Se puede acceder directamente al nombre de una task, debido a que list.task[index] regresa directamente un struct tipo task que tiene la propiedad name.

// Sintaxis utilizando range
for index, task := range list.tasks {
    fmt.Println("Index:", index, "task:", task.name)
}

Características de range:

• Es equivalente a foreach en otros lenguajes de programación
• Regresa 2 valores: el índice de la estructura de datos y el valor contenido. En caso de no usar el índice, se puede reemplazar con un guión bajo (_).
• Éste puede iterar sobre valores de tipo string, array, slice, channel ó map.

for i := 0, i < 5; i++ {
	if i == 1 {
		continue
	}
	if i == 3 {
		break
	}
	fmt.Println(i)
}
// imprime:
// 0
// 2

Las palabras reservadas break y continue tienen como función romper un ciclo con comportamientos diferentes. break sirve para romper por completo un ciclo, mientras que continue termina la iteración en ejecución continuando con las siguientes.

Para los del barrio que sabemos C, aqui los punteros se destructuran automaticamente, por lo tanto no hay nesecidad de acceder a la direccion del puntero para luego re acceder al donde apunta el segundo puntero, cosa que simplificabamos en C con el simbolo “->”, aqui en golang se accede como si fuera directo, algo que podria hacer que si alguien sabe Go y luego va a aprender C le va a dar dolores de cabeza, pero alguien que viene de C le va a costar adaptarse a esa abstraccion, por lo general yo prefiero ser explicito y utilizar el methodo largo de C, asi indico que a donde accedo es un puntero y no la variable en si

(*struct).prop

ese for con range es similar a un foreach de otros programas.

lo curioso es que al concatenar no debemos usar el espacio como los demás lenguajes

Other example with continue:

Output:

Excelentes los tres ejemplos del uso de for

	for i:= 0; i < len(lista.tasks); i++ {
		fmt.Println("index->", i, "nombre->", lista.tasks[i].nombre)
	}

	for index, tarea := range lista.tasks {
		fmt.Println("index:", index, "nombre:", tarea.nombre)
	}

	for i:= 0; i < 10; i++ {
		if i == 5 {
			break
		}
		fmt.Println("contador:", i)
	}

Task list
https://go.dev/play/p/ACBzrkFTdHN

DIFERENTES FORMAS DE HACER UN BUCLE EN GO

Bucle infinito

for {
	// No dejara de ejecutarse
}

Bucle infinito con contador

for i := 0; ; i++ {
	fmt.Println(i) // "i" aumenta de 1 en 1 asta el infinito
}

Un bucle parecido al “for of”

arr := [...]string{"H", "o", "l", "a"}

for _, v := range arr {
	fmt.Println(v) // Imprime el valor
}

Un bucle parecido al “for in”

arr := [...]string{"H", "o", "l", "a"}

for i, _ := range arr {
	fmt.Println(i) // Imprime el indice
}

Bucle while

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

package main

import (
	"fmt"
)

type taskList struct {
	tasks []*task
}

func (t *taskList) agregarALista(tl *task) {
	t.tasks = append(t.tasks, tl)
}

func (t *taskList) eliminarDeLista(index int) {
	// ... desempaquetar los elementos
	t.tasks = append(t.tasks[:index], t.tasks[index+1:]...)
}

type task struct {
	nombre      string
	descripcion string
	completado  bool
}

func (t *task) marcarCompleta() {
	t.completado = true
}

func (t *task) actualizarDescripcion(desc string) {
	t.descripcion = desc
}

func (t *task) actualizarNombre(nombre string) {
	t.nombre = nombre
}

func main() {
	t0 := &task{
		nombre:      "Completar curso go",
		descripcion: "Completar el curso de go en esta semana",
	}
	t1 := &task{
		nombre:      "Completar curso Python",
		descripcion: "Completar el curso de go en esta semana",
	}
	t2 := &task{
		nombre:      "Completar curso Mongo",
		descripcion: "Completar el curso de go en esta semana",
	}

	lista := &taskList{
		tasks: []*task{
			t0, t1,
		},
	}

	fmt.Println(lista.tasks[0])

	fmt.Println(len(lista.tasks))

	lista.agregarALista(t2)

	for i, e := range lista.tasks {
		fmt.Println("Indice", i, "Elemento", e.nombre)
	}

}

range es un iterador de golang

break rompe el flujo o lo detiene

continue solo rompe la iteracion que regresa true

Super útil 😃 por poco pense que o tendriamos un for each… aparecio range 😎

A el ejemplo de @David Esteban Solorzano Taborda, creo que al primer for le falto un : cuando definió el indice del for, es decir…

es for i := 1, y no for i = 1

que alguien me confirme esto por favor.