Repaso general: variables, condicionales, slices y map

Codigo de la clase:

package main

import (
	"fmt"
	"strconv"
)

func main() {

	var x int
	x = 8
	y := 7
	fmt.Println(x)
	fmt.Println(y)

	// Capturando valor y error
	myValue, err := strconv.ParseInt("NaN", 0, 64)

	// Validando errores.
	if err != nil {
		fmt.Println("%v\n", err)
	} else {
		fmt.Println(myValue)
	}

	// Mapa clave valor.
	m := make(map[string]int)
	m["key"] = 6
	fmt.Println(m["key"])

	// Slice de enteros.
	s := []int{1, 2, 3}
	for index, value := range s {
		fmt.Println(index)
		fmt.Println(value)
	}
	s = append(s, 16)
	for index, value := range s {
		fmt.Println(index)
		fmt.Println(value)
	}
}

Que bien que explicas Néstor, personalmente comprendí más con estos repasos que cuando estudié por primera vez estos conceptos jeje.

Código con explicación

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var x int //variable explicita
	x = 8
	y := 7 //variable implicita
	fmt.Println(x)
	fmt.Println(y)
	myValue, err := strconv.ParseInt("Nan", 0, 64) //convertir string a int
	if err != nil {                                //manejo de errores
		fmt.Printf("%v\n", err)
	} else {
		fmt.Println(myValue)
	}
	m := make(map[string]int) //los mapas son estructuras de llave valor
	m["Key"] = 6
	fmt.Println(m["Key"])
	s := []int{1, 2, 3}           //creación de slice de enteros
	for index, value := range s { //range sirve para hacer iteraciones
		fmt.Println(index)
		fmt.Println(value)
	}
	s = append(s, 16)             //agregamos con append un nuevo elemento al slice
	for index, value := range s { //recorremos nuevamente el slice
		fmt.Println(index)
		fmt.Println(value)
	}
}

Agregue tambien borrar de un slice, y estructuras 😄

import (
	"fmt"
	"strconv"
)

func main() {
	var x int
	x = 8
	y := 7

	fmt.Println(x)
	fmt.Println(y)

	// Handling errors
	myValue, err := strconv.ParseInt("Nan", 0, 64)
	if err != nil {
		fmt.Printf("%v\n", err)
	} else {
		fmt.Printf("%v\n", myValue)
	}

	// Map
	m := make(map[string]int)
	m["Key"] = 6
	fmt.Println(m["Key"])

	// Slice
	s := []int{1, 2, 3, 4, 5}
	for i, v := range s {
		fmt.Println(i, v)
	}

	fmt.Println()

	// Append slice
	s = append(s, 6)

	// Range
	for i, v := range s {
		fmt.Println(i, v)
	}

	fmt.Println()

	// Delete from slice
	s = append(s[:2], s[3:]...)

	// Range
	for i, v := range s {
		fmt.Println(i, v)
	}

	// Struct
	type Person struct {
		Name string
		Age  int
	}
	p := Person{"Bob", 20}
	fmt.Println(p.Name)
	fmt.Println(p.Age)

}

<code> 

Código con comentarios de los ejercicios de la clase (っ◕‿◕)っ:

package main

import (
	"fmt"
	"strconv"
)

func main() {

	var x int
	x = 8
	y := 7
	fmt.Println(x)
	fmt.Println(y)

	// Capturando valor y error
	myValue, err := strconv.ParseInt("NaN", 0, 64)

	// Validando errores de manera explicita“.
	// Nil = valor nulo
	if err != nil {
		fmt.Printf("%v\n", err)
	} else {
		fmt.Println(myValue)
	}

	// Mapa: estructura de clave valor, con Make especificar un map que mapee llaves de tipo string a valores de tipo entero
	m := make(map[string]int)
	//Key= string, 6= int
	m["key"] = 6
	fmt.Println(m["key"])

	// Slice: Estructura como un array
	s := []int{1, 2, 3}
	// Con el for recorremos el slice
	for index, value := range s {
		//index: valor en memoria que estamos accediendo
		fmt.Println(index)
		//value: valor almacenado en el slice
		fmt.Println(value)
	}
	// Agregar un valor nuevo al final del slice
	s = append(s, 16)
	for index, value := range s {
		fmt.Println(index)
		fmt.Println(value)
	}
}

Genial

Código comentado

package main

import (
	"fmt"
	"strconv"
)

func main() {
    var x int // declaracion de un variable sin asignarle un valor
    x = 5 // asignación de un valor a unva variable
    fmt.Println(x) // imprimir variable en nueva linea

    // declaracion y asignacion de una variable
    result, err := strconv.ParseInt("7", 0, 64) // parsear un string a entero

    if err != nil { // si el error es distinto a nil, entonces es que ha existido un error al realizar la acción anterior
        fmt.Errorf("error al parsear el string: %q", err)
    }

    fmt.Printf("resultado del parging: %d\n", result) // imprimimos con un string formateado

    m := make(map[string]int) // declaramos un map. Los Map son objetos del tipo key/value

    m["Key"] = 6 // asignamos un valor a una key

    fmt.Println(m)
    fmt.Println(m["Key"])

    s := []int{1,2,3} // declaramos y asignamos un slice. los slices son los tipicos array en otros lenguajes

    // con un for podemos recorrer los slices. La función `range` nos permite descontruir en index/value 
    for index, value := range s {
        fmt.Println(index)
        fmt.Println(value)
    }

    // tambien se puede usar el blank identifier '_' cuando se utiliza range para omitir el uso del index si no se va utilizar
    for _, value := range s {
        fmt.Printf("valor en el slice %d\n", value)
    }
 
    // para utilizar solo en index no es necesario utilizar el blank identifier
    for index := range s {
        fmt.Printf("index en el slice %d\n", index)
    }
}

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var x int
	x = 5
	fmt.Println(x)

	myValue, error := strconv.ParseInt("y", 0, 8)

	if error != nil {
		fmt.Printf("%v\n", error)
	} else {
		fmt.Println(myValue)
	}

	mapa := make(map[string]int)

	mapa["llave"] = 15

	fmt.Println(mapa["llave"])

	mySlice := []int{6, 5, 4}

	for index, value := range mySlice {
		fmt.Println(index)
		fmt.Println(value)
	}

	mySlice = append(mySlice, 12)
	for index, value := range mySlice {
		fmt.Println(index)
		fmt.Println(value)
	}
}

gran iniciooo!!

Super bien explicado, gracias

Muchisimas gracias por este repaso me ayudo muchisimo ya que en el curso basico se terminan viendo nuevos conceptos y estos te quedan en el apuntes golazo!
Saludos.

var explicita
var nameVar string

var implícita
nameVar := int

exelente exxplicacion

exelente explicacion me encanta este curso