A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Ciclo For

16/42
Recursos

Aportes 13

Preguntas 0

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

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.

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

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

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)
	}

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

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 鈥渇or of鈥

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

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

Un bucle parecido al 鈥渇or 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.