Empezaremos con un repaso general de conceptos clave vistos en cursos anteriores que resultan cruciales para avanzar en este curso. Dominaremos estos principios para comprender cómo se integran en el aprendizaje de las nuevas características de Go.
Los temas específicos que revisaremos incluyen:
Structs: Cómo definirlos y darles funcionamiento.
Apuntadores: El manejo y significado del ampersand (&) y del asterisco (*).
Google Teams: Cómo crearlas y usarlas.
Canales (Channels): Utilizarlos para comunicar entre Go Routines y bloquear el programa según sea necesario.
¿Cómo preparar nuestro entorno de desarrollo con Go?
Para este curso, utilizaremos Visual Studio Code (VS Code) como editor de texto, y es importante tener instalada la extensión de Go. Configura tu entorno siguiendo estos pasos:
Abre VS Code y busca en la pestaña de extensiones “Go”.
Instala la extensión adecuada para asegurar una experiencia fluida en el desarrollo de tus aplicaciones.
¿Cómo estructura un programa básico en Go?
Para arrancar con un programa básico en Go, sigue los siguientes pasos:
Crea un archivo nuevo llamado main.go.
Define un paquete principal:
package main
funcmain(){// Punto de entrada del programa}
Este archivo será el punto de entrada de tu aplicación, crucial para su compilación y ejecución.
¿Cómo se declaran variables en Go?
Go ofrece múltiples maneras de declarar variables, tanto de forma explícita como implícita:
Explicita: Utiliza var, el nombre y el tipo de la variable.
var x int=8
Implícita: Mediante el uso de :=.
y :=8
Ambas formas tienen su uso, dependiendo de si deseas ser explícito respecto al tipo de tu variable para evitar errores de compatibilidad.
¿Cómo se manejan los errores en Go?
A diferencia de otros lenguajes, Go maneja los errores de manera explícita, sin las tradicionales estructuras try y catch.
El manejo explícito permite identificar claramente el error que se produce y gestionarlo adecuadamente.
¿Cómo crear y manejar mapas en Go?
Los mapas en Go son estructuras clave-valor que se definen como sigue:
m :=make(map[string]int)m["clave"]=6fmt.Println(m["clave"])
Asegúrate de que el tipo de las llaves y los valores coincida con lo especificado al crear el mapa para evitar errores de compilación.
¿Cómo utilizar slices en Go?
Los slices son similares a arreglos pero con más flexibilidad. Se crean y se pueden iterar de la siguiente manera:
s :=[]int{1,2,3}for index, value :=range s { fmt.Printf("Index: %d, Value: %d\n", index, value)}
Puedes agregar más elementos usando la función append:
s =append(s,16)
Esto te permite modificar la longitud del slice dinámicamente.
Con esto, hemos cubierto las bases de variables, manejo de errores, mapas y slices en Go. Recuerda, en la próxima lección, avanzaremos con más contenido emocionante sobre Go Routines y canales, así que sigue practicando y nos vemos en la próxima clase. ¡No te lo pierdas!
Fundamentos de Programación en Go: Structs, Apuntadores y Manejo de Errores
Empezaremos con un repaso general de conceptos clave vistos en cursos anteriores que resultan cruciales para avanzar en este curso. Dominaremos estos principios para comprender cómo se integran en el aprendizaje de las nuevas características de Go.
Los temas específicos que revisaremos incluyen:
Structs: Cómo definirlos y darles funcionamiento.
Apuntadores: El manejo y significado del ampersand (&) y del asterisco (*).
Google Teams: Cómo crearlas y usarlas.
Canales (Channels): Utilizarlos para comunicar entre Go Routines y bloquear el programa según sea necesario.
¿Cómo preparar nuestro entorno de desarrollo con Go?
Para este curso, utilizaremos Visual Studio Code (VS Code) como editor de texto, y es importante tener instalada la extensión de Go. Configura tu entorno siguiendo estos pasos:
Abre VS Code y busca en la pestaña de extensiones “Go”.
Instala la extensión adecuada para asegurar una experiencia fluida en el desarrollo de tus aplicaciones.
¿Cómo estructura un programa básico en Go?
Para arrancar con un programa básico en Go, sigue los siguientes pasos:
Crea un archivo nuevo llamado main.go.
Define un paquete principal:
package main
func main() {
// Punto de entrada del programa
}
Este archivo será el punto de entrada de tu aplicación, crucial para su compilación y ejecución.
¿Cómo se declaran variables en Go?
Go ofrece múltiples maneras de declarar variables, tanto de forma explícita como implícita:
Explicita: Utiliza var, el nombre y el tipo de la variable.
var x int = 8
Implícita: Mediante el uso de :=.
y := 8
Ambas formas tienen su uso, dependiendo de si deseas ser explícito respecto al tipo de tu variable para evitar errores de compatibilidad.
¿Cómo se manejan los errores en Go?
A diferencia de otros lenguajes, Go maneja los errores de manera explícita, sin las tradicionales estructuras try y catch.
El manejo explícito permite identificar claramente el error que se produce y gestionarlo adecuadamente.
¿Cómo crear y manejar mapas en Go?
Los mapas en Go son estructuras clave-valor que se definen como sigue:
m := make(map[string]int)
m["clave"] = 6
fmt.Println(m["clave"])
Asegúrate de que el tipo de las llaves y los valores coincida con lo especificado al crear el mapa para evitar errores de compilación.
¿Cómo utilizar slices en Go?
Los slices son similares a arreglos pero con más flexibilidad. Se crean y se pueden iterar de la siguiente manera:
s := []int{1, 2, 3}
for index, value := range s {
fmt.Printf("Index: %d, Value: %d\n", index, value)
}
Puedes agregar más elementos usando la función append:
s = append(s, 16)
Esto te permite modificar la longitud del slice dinámicamente.
Con esto, hemos cubierto las bases de variables, manejo de errores, mapas y slices en Go. Recuerda, en la próxima lección, avanzaremos con más contenido emocionante sobre Go Routines y canales, así que sigue practicando y nos vemos en la próxima clase. ¡No te lo pierdas!
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)
}
}
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 :D
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)
}
}
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 =8y:=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.
si el explica muy bien
esto pinta re melo
Código con explicación
package main
import("fmt""strconv")func main(){var x int //variable explicita x =8y:=7//variable implicita fmt.Println(x) fmt.Println(y) myValue,err:= strconv.ParseInt("Nan",0,64)//convertir string a intif 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 enterosfor 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 slicefor index,value:= range s {//recorremos nuevamente el slice fmt.Println(index) fmt.Println(value)}}
Agregue tambien borrar de un slice, y estructuras :D
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 =8y:=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 nuloif 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 enterom:=make(map[string]int)//Key= string, 6= int m["key"]=6 fmt.Println(m["key"])// Slice: Estructura como un arrays:=[]int{1,2,3}// Con el for recorremos el slicefor 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)}}
¿Podrías ayudarme diciéndome que función tiene
"%v\n" en esa linea de código?
fmt.Printf("%v\n", err)
Tengo entendido que es como para tratar string o algo similar pero no lo recuerdo y quisiera llenar ese hueco de información que tengo. Gracias.
Hola Cristian, con todo gusto.
El utilizar %v a la hora de imprimir con formato nos ayudara a visualizar de mejor manera un struct utilizando el Printf y el \n es para que haga un salto de linea al final, puedes echar un ojo a la documentación haciendo click aquí o hacerme saber alguna otra duda que tengas.
Sirve para mostrar por output el error, es similar a como se hace en c, básicamente puedes usar:
%v -> Mostrar cualquier valor
%s -> Mostrar string
%d -> Mostar enteros
%g -> Decimal
En conclusion te permite formatear los datos en un print, similar a como .format() en Python o los string literals en JavaScript ${}
Genial
Código comentado
package main
import("fmt""strconv")funcmain(){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 enteroif 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 utilizarfor_, value :=range s { fmt.Printf("valor en el slice %d\n", value)}// para utilizar solo en index no es necesario utilizar el blank identifierfor 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)}}
me gusta mas declarar los maps así
m := map[string]int{
"key": 6,
}
Tengo problemas con mi visual STUDIO CODE, no me sugiere código ni puedo ver la documentación.
Hola Cristian, te recomiendo actualizar tu VSCode y reinstalar la extensión en caso de ser necesario.
Para autocomplite prueba el CTRL + SPACE y revisa tener la extension de golang instalada
En los cursos anteriores como el de go (la actualización) y el de programacióń básica con go no se explica muy bien el paquete strconv, aquí les dejo material:
Básicamente strconv.Parseint() recibe tres parámetros, el primero es la cadena a covertir, el segundo es la base (decimal, binario, o hexadecimal, si se pasa un 0 se le dice al paquete que lo infiera de acuedo al string) y por último el tamaño (el mismo de las variables).
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
¿Alguien sabe cual es el tema de vs code que utiliza el profesor?