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

Róger Antonio Ordóñez Flores

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

Cristian Camilo Sanchez Ardila

esto pinta re melo

Benjamin Eduardo De La Torre Rojas

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

Carlos Nassif Trejo Garcia

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>

Lorena Cardona Tovar

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

Oscar Jaramillo

Genial

Marcos Corona

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

Victor Hugo Cruz Carballo

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

Andres Montes

gran iniciooo!!

Adán

Super bien explicado, gracias

Agustin Dedico

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.

Angelo Monasterios

var explicita
var nameVar string

var implícita
nameVar := int

Moises Abel Avila Garcia

exelente exxplicacion

Moises Abel Avila Garcia