Curso Bsico de GO

Curso Básico de GO
Status
Fecha de Creación @May 31, 2022 8:50 PM
Date
Autor
Notes
Related to Day (Cursos)
Related to Platzi Master Path (Property)
¿Que es Go?
Compilado y estaticamente tipado
Creado por Google.
Go/Golang.
Programadores: Gophers.
Mascota: Gopher.
Curso Básico de GO 1
Gopherize yourself
Generate a Gopher pic that's as unique as you
https://gopherize.me/
¿Por qué Go?

Gran velocidad.
Alto rendimiento para tareas pesadas.
Soporte nativo para concurrencia.
Top 5 más amados y mejores pagados (2020).
Instalando GO
export GOPATH=$HOME/go # entorno donde desarrollaremos nuestros programas
export GOBIN=$GOPATH/bin # Donde estarán todos los binarios a ejecutar
export GOROOT=/usr/local/go # o /usr/lib/go Aquí esta el ejecutador de GO
export PATH=$PATH:$GOBIN:$GOROOT/bin # Agregando estas variables al PATH
Luego de esto ejecutamos. source .zshrc o source .bashrc Dependiendo de nuestra

shell.
Ahora crearemos los directorios necesarios para nuestro proyecto con el siguiente
comando.
mkdir -p $HOME/go/{bin,pkg,src}
Hola Mundo con Go

package main
import "fmt"
func main() {
fmt.Println("Hola Mundo")
}
Para comenzar debemos definir que nuestro paquete es el principal, usando package
main .
Luego importamos la libreria fmt , la cual nos permite mostrar texto por pantalla.
Para terminar creamos una función (debe tener siempre el nombre main la funcion a
ejecutar) que contenga la llamada a la función Println de la libreria fmt . Al igual que
en otros lenguajes, le pasamos lo que queremos mostrar como argumento.
Variables, Constantes y Zaro Values

Constantes
package main
import "fmt"
func main() {
const pi float64 = 3.14
const pi2 = 3.1415
fmt.Println(pi, pi2) // 3.14 3.1415

}
Para declarar constantes podemos definir su tipo o no (dejando que el compilador las
infiera)
En este caso declaramos la constante pi como float64 y le asignamos el valor de

3.14 . Tambien inicializamos (ya que no especificamos tipo) la variable pi2 y le dimos
el valor 3.1415 .
Variables
base := 12 // Declarada sin tipo ni keyword usando el operador :=
var altura int = 14 // Declarda usando var, definiendo su tipo y valor.
var area int // Declarada pero sin darle valor
area = 12 // Dando valor a una variable ya declarada
En Go no podemos dejar variables sin usar dado a que el lenguaje nos marca error en
compilación cuando las variables declaradas no son usadas.
package main
import "fmt"
func main() {
base := 12
var altura int = 14 Este error error se lanza al
var area int
area = 12 momento de compilar y evita
} que gastemos espacio
(aunque sea minimo) en
variables no usadas.
Para evitar este error debemos usar las variables o comentarlas.
package main
import "fmt"
func main() {
base := 12
var altura int = 14
var area int
area = 12
fmt.Println(base, altura, area)

}
Zero Values
package main
import "fmt"
func main() {
var a int
var b float64
var c string Por defecto los valores que nos entregan
var d bool
las variables no inicializadas (sin darles
fmt.Println(a, b, c, d) valor) poseen los siguientes valores.
}
int :0
float :0
string : (un espacio)
bool : false
Operadores aritmeticos
package main
import "fmt"
func main() {
x := 10
y := 5
// Suma
result := x + y
fmt.Println("suma:", result) Fijarse que en el primer
// Resta
result usamos el operador
result = x - y
fmt.Println("resta:", result) para inferir tipos ( := ).
// Multiplicacion
result = x * y Y en las siguientes lineas
fmt.Println("multiplicacion:", result)
(donde modificamos la
// Division
result = x / y variable result ) solo usamos
fmt.Println("division:", result)
el operador de asignación
// Modulo
result = y % x ( = ).
fmt.Println("modulo:", result)
} Esto se debe a que al usar :=
estamos diciendo el tipo que

será (para el resto del
programa) nuestra variable.
Incremental y Decremental
var x int
x++ // Le suma 1 a la variable x
x-- // Le resta 1 a la variable x
Quiz
Calcular area de rectangulo, trapecio y circulo.
package main
import "fmt"
func main() {
const base int = 30
const base_2 int = 28
const altura int = 15
const radio int = 3
const pi float32 = 3.1415
// Area rectagunlo
area_rect := base * altura
fmt.Println("area rectangulo:", area_rect)
// area trapecio
area_trap := ((base + base_2) * altura) / 2
fmt.Println("area trapecio:", area_trap)
// area circulo
area_circ := pi * float32(radio) // radio (int) -> radio (float32) dada la mult con pi
fmt.Println("area circulo:", area_circ)
}
Valores Primitivos
Enteros
int = Depende de la arquitectura del OS si es 32bits o 64bits
int8 = 8 bits = [-128, 127]
int16 = 16 bits = [-2^15, 2^15 - 1]
int32 = 32 bits = [-2^31, 2^31 - 1]
int64 = 64 bits = [-2^63, 2^63 - 1]
Enteros Positivos
uint = Depende del OS (32 o 64bits)
uint8 = 8 bits = [0, 2^8 - 1]
uint16 = 16 bits = [0, 2^16 - 1]
uint32 = 32 bits = [0, 2^32 -1]
uint64 = 64bits = [0, 2^64 -1]
Decimales
float32 = 32bits = +/- 1.18e^-38 a +/- 3.4e^38
float64 = 64bits = +/- 2.23e^-308 a +/- 1.8e^308
Strings y Bool
string = “” En Go siempre las strings llevan comillas “dobles”
bool = true o false
Números Complejos
complex64 = Real o imaginario float32
complex128 = Real o imaginario float64
Ejemplo: c := 10 + 8i
Paquete FMT
Además de poder usarlo para mostrar texto por consola tiene otras utilidades.
Println
package main
import "fmt"
func main() {
// Println
hello := "Hello"
world := "world!"
fmt.Println(hello, world)
fmt.Println(hello, world)
}
Con Println podemos escribir variables directamente en la consola, además esta

agrega por defecto un salto de línea. El salto de línea puede ser escrito como “ \n ”.
Printf
package main
import "fmt"
func main() {
// Printf
nombre := "pablo"
edad := 18
fmt.Printf("%s tiene %d años\n", nombre, edad)

fmt.Printf("%v tiene %v años\n", nombre, edad)
}
Con Printf podemos escribir variables junto con texto, agregandolas con el caracter
% , el cual se acompaña de la abreviación del tipo de dato o se usa v para que se
infiera e imprima cuando no sabemos que tipo de datos es.
%s Imprimir cadenas.
%d Imprimir enteros.
%f Imprimir flotantes.
%v Imprimir todos los tipos de datos.
Además de eso, con Printf podemos saber el tipo de dato de nuestras variables.
package main
import "fmt"
func main() {
// Printf
// tipo de dato
nombre := "pablo"
edad := 18
fmt.Printf("%T", edad) // nos muestra el tipo de dato

fmt.Println() // dar saltos de linea
fmt.Printf("%T", nombre)
fmt.Println() // dar saltos de linea
fmt.Printf("%T", true)
}
El simbolo % al final de la palabra bool significa que ahí se ubica el final del texto
(dado que no usamos un println al final para dar el salto de línea).
Sprintf
Con esta utilidad podemos crear strings o cadenas para que luego puedan ser
impresas.
package main
import "fmt"
func main() {
// Sprintf
nombre := "pablo"
edad := 18
message := fmt.Sprintf("%s tiene %v años", nombre, edad)

fmt.Println(message)
}
Usando la misma lógica que en printf creamos strings envez de imprimirlas.
Funciones
package main
import "fmt"
func sayHello() {
fmt.Println("Hello!")
}
func sum(a int, b int) {

fmt.Printf("La suma de %d + %d es %d\n", a, b, a+b)
}
func sum3(a, b, c int) {

fmt.Printf("La suma de %d + %d + %d es %d\n", a, b, c, a+b+c)
}
func returnString(a string) (b string, c string) {

mundo := "Mundo"
return a, mundo
}
func return2() (a int, b bool) {

return 3, true
}
func main() {
sayHello()
sum(4, 6)
sum3(10, 20, 30)
hola, mundo := returnString("Hola")

fmt.Println(hola, mundo)
num, _ := return2() // con _ evitamos que Go nos pida usarlo
fmt.Println(num)
}
En este snippet se ve como podemos usar funciones que no retornarn valores,

funciones que retornan un (y más de un) valor y funciones que reciben como parametro
más de 1 valor.
Tambien vemos como evitar que Go nos moleste con los valores que retornan las
funciones y que no usaremos usando _ .
Go doc: La forma de ver documentación

Standard library
Package des implements the Data Encryption Standard (DES) and the Triple Data Encryption Algorithm (TDEA)
as defined in U.S. Federal Information Processing Standards Publication 46-3.
https://pkg.go.dev/std
pkg.go.dev
Go is an open source programming language that makes it easy to
build simple, reliable, and efficient software.
https://pkg.go.dev/?utm_source=godoc
Ciclos
En el caso de Go solo poseemos un ciclo iterativo. For
package main
import "fmt"
func main() {
// For condicional
for i := 0; i < 10; i++ {
fmt.Println(i)
}
// For while
counter := 0
for counter < 10 {
fmt.Println(counter)
counter++
}
// For forever
counterForever := 0
for {
fmt.Println(counterForever)
counterForever++
}
For Condicional
El tipico uso de For en lenguajes como Javascript, C y C++.
Necesita de una variable iterar, condición y cantidad a sumar/restar a este iterable.
For While
Implementación de el bucle while sin usar ese keyword. Simplmente se usa el for
seguido de una condición.
For Forever
Al igual que un while true este se ejecutará por siempre. La implementación se basa en
solo un for seguido de un bloque de código {} .
Operadores lógicos y de comparación

Son operadores que nos permiten hacer una comparación de condiciones y en caso de
cumplirse como sino ejecutarán un código determinado. Si se cumple es
VERDADERO/TRUE y si no se cumple son FALSO/FALSE.
Operadores de comparación
Son aquellos que retornan TRUE o FALSE en caso de cumplirse o no una expresión.
Son los siguientes:
valor1 == valor2: Retorna TRUE si valor1 y valor2 son exactamente iguales.
valor1 != valor2: Retorna TRUE si valor1 es diferente de valor2.
valor1 < valor2: Retorna TRUE si valor1 es menor que valor2
valor1 > valor2: Retorna TRUE si valor1 es mayor que valor2
valor1 >= valor2: Retorna TRUE si valor1 es igual o mayor que valor2
valor1 <= valor2: Retorna TRUE si valor1 es menor o igual que valor2.
Operadores lógicos
Son aquellos que retorna TRUE o FALSE si cumplen o no una condición
utilizando puertas lógicas.
Operador AND && :

Este operador indica que todas las condiciones declaradas deben cumplirse para
poderse marcar como TRUE. En Go, se utiliza este símbolo && .
Ejemplo1: 1>0 && 2 >0 Esto retornará TRUE porque tanto la primera como la segunda
condición son verdaderas.
Ejemplo2: 2<0 && 1 > 0 Esto retornará FALSE porque una de las condiciones no es
verdadera.
Operador OR || :
Este operador indica que al menos una de las condiciones debe cumplirse para
marcarse como TRUE. En Go, se representa con el símbolo || .
Ejemplo: 2<0 || 1 > 0 Esto retornará TRUE porque la segunda condición se cumple, a
pesar que la primera no.
Operador NOT:
Este operador retornará el opuesto al boleano que está dentro de la variable. Ejemplo:
myBool :=true
fmt.Println(!myBool) // Esto retornará false
Condicional If
La sintaxis que debemos tener en cuenta para escribir condicionales es la siguiente:
if <condicion>{
// codigo
} else {
// codigo
}
Podemos no incluir el else si no es necesario. Pero si lo incluimos siempre debe ir el

} seguido en la misma línea de el else .
package main
import "fmt"
func main() {
// If
valor1 := 1
if valor1 == 1 {
fmt.Println("Es 1")
} else {
fmt.Println("No es 1")
}
// AND
valor2 := 2
if valor1 == 1 && valor2 == 2 {

fmt.Println("Es 1 y 2")
} else {
fmt.Println("No es 1 ni 2")
}
// OR
if valor1 == 0 || valor1 == 2 {
fmt.Println("Es 0 ó es 2")
} else {
fmt.Println("No es 0 ó 2")
}
// NOT
if valor1 != 1 {
fmt.Println("No es 1")
}
Conversion de tipos
Para estas conversiones necesitamos de la libreria strconv . La cual debemos importar.
Texto a Número
// Texto a numero ASCII to integer

value, err := strconv.Atoi("4")
if err != nil { // si existe error err = nil
log.Fatal(err)
}
fmt.Println(value) // 4
Importando la librería strconv y usando Atoi con un parametro como string este nos
retornará ese valor pero en entero.
Además de eso, la función Atoi ascii to int nos devuelve el valor y el error (posible).
Si el error ( err ) es igual a nil significa que el valor dado como parametro ES VALIDO.
Entonces creamos una condición la cual verifique si es diferente a este valor, y si lo es,
que nos muestre un error por pantalla (usando log.Fatal(err) )
Número a Texto
i := strconv.Itoa(33)
fmt.Println(i) // "33"
Al usar Itoa int to ascii solo necesitamos recibir un valor, a diferencia de recibir el error
como en Atoi .
Parse…
Para covertir una string a booleanos usamos ParseBool(str) .
Para convertir una string en flotante usamos ParseFloat(str, bits) .
strconv
Package strconv implements conversions to and from string representations of basic data types. Numeric
Conversions ¶ The most common numeric conversions are Atoi (string to int) and Itoa (int to string). i, err :=
strconv.Atoi("-42") s := strconv.Itoa(-42) These assume decimal and the Go int type.
https://pkg.go.dev/strconv
Switch
Con switch podemos evitar tener multiples condiciones if anidadas.
Con condición
package main package main
import "fmt" import "fmt"
func main() { func main() {

modulo := 4 % 2
switch modulo := 4 % 2; modulo { switch modulo {
case 0: case 0:
fmt.Println("Es Par") fmt.Println("Es Par")
default: default:
fmt.Println("Es impar") fmt.Println("Es impar")
} }
} }
Usualmente cuando trabajamos con sentencias switch la variable se declara en la

parte donde normalmente va la variable.
Con case podemos definir que hacer a partir del valor que demos, como este caso,
hacemos un caso para cuando la variable modulo sea 0 y un caso por defecto default
para cuando ningún caso corresponda.
package main
import "fmt"
func main() {
text := "y"
switch text {
case "x", "y", "z":
fmt.Println("X, Y ó Z")
default:
fmt.Println("Una letra")
}
}
Una forma de omitir escribir multiples veces casos que solo cambie su condición y su
código a ejecutar sea el mismo es declarar casos con sus condiciones seguidads por
comas.
Tenemos que en el caso de que sea x , y o z la variable text se ejecutará el mismo
bloque de código.
Sin condición
package main
import "fmt"
func main() {
// Sin condicion
value := 4
switch {
case value > 10:
fmt.Println("Mayor que 10")
case value < 0:
fmt.Println("Menor que 0")
default:
fmt.Println("Entre 0 y 10")
}
}
Otra forma de usar switch es usarlo directamente como un if sin darle una
variable/condición al iniciar el bloque.
Defer, Break y Continue

Defer
package main
import "fmt"
func main() {
defer fmt.Println("Mundo")
fmt.Println("Hola")
Este keyword nos sirve para ejecutar una línea de código al final de la ejecución del
programa.
Continue
Con el keyword continue podemos producir que un bucle salte/continue a la siguiente
iteración.
package main
import "fmt"
func main() {
// continue
for i := 1; i < 6; i++ {
if i%2 == 0 {
fmt.Printf("El %d es par\n", i)
continue
}
fmt.Println(i)
}
}
En este código ocurre que al ser nuestra variable i par escribiremos que su valor es
par y continuaremos a la siguiente iteración (siguiente valor de i ). Evitando que el
código de más abajo imprima los valores pares.
Break
Con break podemos parar la ejecución de los bucles.
package main package main
import "fmt" import "fmt"
func main() { func main() {

// break // break
i := 0
for i := 0; ; i++ { for {
if i > 100000 { if i > 100000 {
fmt.Println("Very Large Number") fmt.Println("Very Large Number")
break break
} }
fmt.Println(i) fmt.Println(i)
} i++
} }
}
En estos ejemplos vemos el uso de break en for while escritos de distinta forma en Go.
Cada vez que llegamos a 100.000 en ambos programas la iteración se detiene.
Arrays y Slices
Arrays
Los arrays o listas tienen un largo definido al crear el array. Este no puede recibir más
valores que los especificados en la declaración del array y debe ser de un unico tipo,
especificado en la declaración.
var nombre_array [largo_array]tipo_de_dato

var numeros [4]int
Para agregar valores simplemente lo asignamos como si de una variable se tratara.
var numeros [4] int

numeros[0] = 1
numeros[1] = 2
Por defecto los arrays al ser creados rellenan los valores vacios (en este caso enteros)
con ceros.
Si fuera un array de strings este se llenaria con espacios " " vacios.
package main
import "fmt"
func main() {
// arrays
var array [4]int
array[0] = 1
array[1] = 2
array[2] = 3
array[3] = 4
fmt.Println(array)
fmt.Println(len(array), cap(array))
fmt.Println(array[0:2])
fmt.Println(array[2:4])
}
Al imprimir los arrays este nos los muestra de la forma [x x x x] .
Poseemos funciones que nos permiten ver el largo de un array (elementos usados).
len(array)
Y tambien podemos ver la capacidad de un array (elementos totales creados).

cap(array)
Además de esto podemos tomar porciones de arrays usando la siguiente notación:
array[inicio:termino] // toma hasta antes del valor termino

array[0:2] // [1 2] -> toma elementos de indice 0 y 1
💡 Los arrays son inmutables, lo que significa que su largo no puede ser
modificado, pero no significa que los valores que contenga el array no
puedan ser cambiados.
Slices
Los slices a diferencia de los arreglos pueden ser declarados a una variable con los
datos incluidos y sin necesidad de darle un largo predefinido.
package main
import "fmt"
func main() {
// Slices
var slice = []int{0, 1, 2, 3, 4, 5, 6}
fmt.Println(slice)
fmt.Println(len(slice), cap(slice))
// metodos en el slice
fmt.Println(slice[0])
fmt.Println(slice[:3])
fmt.Println(slice[2:4])
fmt.Println(slice[4:])
Los slices comparten casi las mismas caracteristicas que los arreglos pero estos
pueden ser más faciles de aplicar cuando no tenemos claro el largo que necesitamos.
💡 La principal diferencia entre slices y arrays es que a los slices podemos

agregarle valores (ya que no es necesario que tengan un largo especifico)
Agregar valores a Slices

Para agregar valores a nuestros slices usamos la función append la cual recibe como
primer parametro nuestro slice y como segundo parametro recibe el valor (o slice) a
agregar.
slice := []int{1,2,3,4}
slice = append(slice, 5)
fmt.Println(slice) // [1 2 3 4 5]
Agregar slice dentro de un slice.
slice1 := []int{1,2,3,4}
slice2 := []int{5,6,7,8}
slice1 = append(slice1, slice2...)
fmt.Println(slice) // [1 2 3 4 5 6 7 8]
Al usar ... estamos descomprimiendo este slice en elementos separados.

Lo que es similiar a escribir esto:
slice3 := []int{1, 2, 3, 4}
slice3 = append(slice3, 5, 6, 7, 8)
fmt.Println(slice3) // [1 2 3 4 5 6 7 8]
Recorrido de Slices con range

package main
import "fmt"
func main() {
slice := []string{"Tierra", "Marte", "Venus"}
for index, value := range slice {

fmt.Println(index, value)
}
fmt.Println("*********")
for _, value := range slice {
fmt.Println(value)
}
fmt.Println("*********")
for i := range slice {
fmt.Println(i)
}
}
El primer for : Al usar la función range y pasandole como parametro el slice, esta
función nos devolverá 2 iterables. Los cuales corresponen al indice y valor de nuestro
slice.
for index, value := range slice {

fmt.Println(index, value)
}
El segundo for : Como sabemos, en Go no podemos dejar ninguna función sin usar.
Dado eso usamos el _ para indicar que no usaremos dicha variable, con lo cuál
podemos mostrar solo los valores del slice por pantalla.
for _, value := range slice {

fmt.Println(value)
}
El tercer for : Es una simplificación del segundo for , si solo queremos el indice, solo
debemos definir una variable receptora. Esto propociona que solo se entregen indices.
for i := range slice {

fmt.Println(i)
}
Palindromos
package main
import (
"fmt"
"strings"
)
func clearText(str string) string {
var newString string

for _, value := range str {
if string(value) == "," || string(value) == " " {
continue
} else {
newString += string(value)
}
}
return newString
}
func esPalindromo(str string) bool {

strg := clearText(str)
var text string
for i := len(strg) - 1; i >= 0; i-- {
text += string(strg[i])
}
if strings.ToLower(strg) == strings.ToLower(text) {
return true
} else {
return false
}
}
func main() {
string := "Ema, si vas, avisame"
fmt.Printf("La palabra '%s' ", string)
if esPalindromo(string) {
fmt.Println("Es Palindromo")
} else {
fmt.Println("No es Palindromo")
}
strings
Package strings implements simple functions to manipulate UTF-8 encoded strings. For information about UTF-
8 strings in Go, see https://blog.golang.org/strings.
https://pkg.go.dev/strings?utm_source=godoc#example-Join
LLave valor con Maps

En el caso de Python se llaman diccionarios, en Go son llamados Mapas.
Recorrer Maps
func main() {
m := make(map[string]int)
m["Jose"] = 14
m["Pedro"] = 16
m["Maria"] = 23
m["Emma"] = 3
fmt.Println(m)
// recorrer maps
for i, val := range m {
fmt.Println(i, val)
}
}
Los maps al usar de forma nativa la concurrencia suponen una diferencia frente a los
slices, además de no tener indices, teniendo por su parte llaves y valors, estos no
tienen un orden especifico.
Cada vez que llamemos a la función main esta nos imprimirá un orden distinto del Map.
La declaración fmt.Println(m) nos retorna el mapa ordenado (no como nosotros

ingresamos valores) pero de una forma consistente en ambas ejecucciones.
Por otro lado, cuando recorremos el mapa con la función range esta es devuelta de
forma aleatoria dada la naturaleza de la concurrencia en Go (distintos procesos
ejecutados a la vez, el que termina primero es impreso por consola antes).
Encontrar valores
Para encontrar valores solo debemos saber la llave. En estos casos las llaves
disponibles erían “Jose” , “Maria” , “Emma” y “Pedro” .
// encontrar valores
value := m["Jose"]
value = m["Pablo"] // "Pablo" no existe

value, ok := m["Pablo"]
fmt.Println(value, ok) // 0 false
Dada la forma de manejo de errores de Go podemos, en los casos donde ingresemos

llaves que no existen, requerir que Go nos devuelva el valor de error.
Recibiendo como primer retorno el valor (o ZeroValue) y como segundo retorno un
booleano que nos indica si es un valor usable o no (Si es verdadero significa que es un
valor correcto, si es un valor falso nos indica que la llave no existe)
Al “Pablo” no existir en el Map nos devuelve por defecto el ZeroValue del tipo de dato
usado (int) y con la variable ok recibimos el posible error. Luego de esto seguiría
comprobar si ok es verdadero o falso para indicar al usuario si la llave es o no valida.
if ok{
fmt.Printf("El valor de la llave %s es %d", "Pablo", value)
} else{
fmt.Println("La llave no existe")
}
maps
This section is empty. This section is empty. This section is empty.
https://pkg.go.dev/github.com/ross-oreto/go-list-map?utm_source=godoc
Structs: La forma de hacer clases en Go

En muchos lenguajes, como Python, Java o C++ existen Clases.
En Go existen los structs.

Para crear un struct lo hacemos fuera de nuestra función main y usando el keyword
type seguido del nombre del struct y del keyword struct .
type nombreStruct struct { type car struct {

} brand string
year int
color string
}
Luego abrimos bloque de código con los
curly brackets.
Para usar este Struct debemo instanciarlo:
Instanciando: Primera forma
package main
import "fmt"
type car struct {

brand string
year int
color string
}
func main() {
// instanciar
firstCar := car{brand: "Honda", year: 2021, color: "blue"}
fmt.Println(firstCar)
}
Al instanciar de esta forma estamos llenando todos los valores del struct.
Instanciando: Segunda forma
package main
import "fmt"
type car struct {

brand string
year int
color string
}
func main() {
// otra forma de instanciar
var secondCar car
secondCar.brand = "Tesla"
fmt.Println(secondCar)
}
Al instanciar de esta forma estamos creando una variable con su tipo de dato dado por
car .
var nombreVar nombrStruct
Además de eso, no estamos llenando todos los valores del struct, estamos solo
dandole una marca al usar la dot notation para acceder a sus atributos (variables de
una clase).
instancia.atributo = valor
Al no tener todos los valores llenos con un valor estos tendrán por defecto el ZeroValue
de su tipo.
Recordemos que el ZeroValue de una string es un espacio vació “” .
Modificadores de Acceso

Curso Bsico de GO

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Curso Bsico de GO

Cargado por

Copyright:

Formatos disponibles

Curso Básico de GO

Fecha de Creación @May 31, 2022 8:50 PM

Related to Day (Cursos)

Related to Platzi Master Path (Property)

Creado por Google.

¿Por qué Go?

Alto rendimiento para tareas pesadas.

Soporte nativo para concurrencia.

Top 5 más amados y mejores pagados (2020).

export PATH=$PATH:$GOBIN:$GOROOT/bin # Agregando estas variables al PATH

Luego de esto ejecutamos. source .zshrc o source .bashrc Dependiendo de nuestra

Hola Mundo con Go

Variables, Constantes y Zaro Values

fmt.Println(pi, pi2) // 3.14 3.1415

En este caso declaramos la constante pi como float64 y le asignamos el valor de

var altura int = 14 // Declarda usando var, definiendo su tipo y valor.

var area int // Declarada pero sin darle valor

area = 12 // Dando valor a una variable ya declarada

Para evitar este error debemos usar las variables o comentarlas.

fmt.Println(base, altura, area)

string : (un espacio)

estamos diciendo el tipo que

int8 = 8 bits = [-128, 127]

int16 = 16 bits = [-2^15, 2^15 - 1]

int32 = 32 bits = [-2^31, 2^31 - 1]

int64 = 64 bits = [-2^63, 2^63 - 1]

uint8 = 8 bits = [0, 2^8 - 1]

uint16 = 16 bits = [0, 2^16 - 1]

uint32 = 32 bits = [0, 2^32 -1]

uint64 = 64bits = [0, 2^64 -1]

float64 = 64bits = +/- 2.23e^-308 a +/- 1.8e^308

bool = true o false

complex128 = Real o imaginario float64

Con Println podemos escribir variables directamente en la consola, además esta

fmt.Printf("%s tiene %d años\n", nombre, edad)

infiera e imprima cuando no sabemos que tipo de datos es.

%v Imprimir todos los tipos de datos.

fmt.Printf("%T", edad) // nos muestra el tipo de dato

message := fmt.Sprintf("%s tiene %v años", nombre, edad)

Usando la misma lógica que en printf creamos strings envez de imprimirlas.

func sum(a int, b int) {

func sum3(a, b, c int) {

func returnString(a string) (b string, c string) {

func return2() (a int, b bool) {

sum3(10, 20, 30)

hola, mundo := returnString("Hola")

num, _ := return2() // con _ evitamos que Go nos pida usarlo

En este snippet se ve como podemos usar funciones que no retornarn valores,

Go doc: La forma de ver documentación

seguido de una condición.

Operadores lógicos y de comparación

valor1 == valor2: Retorna TRUE si valor1 y valor2 son exactamente iguales.

valor1 != valor2: Retorna TRUE si valor1 es diferente de valor2.

valor1 < valor2: Retorna TRUE si valor1 es menor que valor2

Operador AND && :

Podemos no incluir el else si no es necesario. Pero si lo incluimos siempre debe ir el

if valor1 == 1 && valor2 == 2 {

// Texto a numero ASCII to integer

package main package main

import "fmt" import "fmt"

func main() { func main() {

Usualmente cuando trabajamos con sentencias switch la variable se declara en la

Defer, Break y Continue