Repaso general: variables, condicionales, slices y map

3/30
Recursos

Aportes 9

Preguntas 3

Ordenar por:

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

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 comentarios de los ejercicios de la clase (銇b棔鈥库棔)銇:

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

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 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)
	}
}
esto pinta re melo
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)
	}
}

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

Genial