Go desde cero

Curso para aprender Go

20 November 2020

Qué es Go?

Lenguaje de programación moderno caracterizado por su simplicidad, manejo de memoria (garbage collection) y buen manejo en equipos grandes.

Inspiración para Go

• OOP de Smalltalk
• Sintaxis de Algol
• Garbage Collection de Limbo
• Concurrencia de Newsqueak
• Legibilidad y facilidad de uso de Python

Hello World

Hello World

package main

import "fmt"

func main() {
    var s string = "Hello, 世界"
    fmt.Println(s)            
}

La primera línea establece el nombre del paquete que estamos ecribiendo:

package main

La segunda línea indica que vamos a usar cosas de la librería fmt.

import "fmt"

Al ejecutarse, el programa llama a la función main:

func main() {
    var s string = "Hello, 世界"
    fmt.Println(s)            
}

• Se declara s de tipo string y se le asigna el valor "Hello, 世界"
• A través de la sintaxis fmt.Println seleccionamos la función Println del paquete que importamos antes. Esa función imprime uno o más valores a consola.

Los programas ejecutables siempre tienen "package main" y tienen una función llamada "main()" que no tiene argumentos como en el ejemplo.

Los paquetes diseñados para ser importados por otros no tienen esa restricción. Pueden llamarse package pizza si se quiere.

Variables y Tipos

Variables y tipos básicos

Una variable es un identificador que representa un valor.

Toda variable tiene un tipo, en otras palabras información acerca de qué valores pueden ser guardados y cuales no.

//+build non-slide OMIT

package main

import "fmt"

func main() { 
    var s string = "Hello, 世界"
    s = 1
    fmt.Println(s)             

} 

# _/tmp/present-492636790
./prog.go:13:7: cannot use 1 (type untyped int) as type string in assignment

Program exited: exit status 2

Aquí s es de tipo string y guarda el valor "Hello World".

Intentar asignarle un valor de 1 (un int) es un error.

Diferentes maneras de declarar variables.

• Para declarar solamente:

    var s string

• Para declarar Y asignar:

    var s string = "Hello world"
    var s = "Hello World" 
    s := "Hello World"

Las tres son equivalentes. El compilador puede inferir que "Hello World" es un string, por eso no hace falta aclarar. s:= es sólo una sintaxis más corta para var s =.

• Para asignar solamente (cambiar el valor que ya tiene):

    s = "Hola Mundo"

Tipo int

Go tiene los siguientes operadores básicos para números enteros: + - * / %

package main

import "fmt"

func main() {
    var a int = 2
    var m int = 4
    var c int = a + m 
    fmt.Println(c)
}

6

Program exited.

Más corto, usando lo anterior:

//+build ignore OMIT
package main

import "fmt"

func main() {
    a, m := 2, 4
    c := a + m
    fmt.Println(c)
}

Tipo string

Se pueden concatenar strings con los operadores + y +=

//+build ignore OMIT

package main

import "fmt"

func main() {
    var greeting string
    greeting = "Hola "
    greeting = greeting + "Roberto Bolaño"
    fmt.Println(greeting)

}

Hay otros tipos básicos además del string e int. Lista completa:

int     uint    float32   complex64   bool
int8    uint8   float64   complex128  string
int16   uint16                        byte // alias para uint8
int32   uint32                        rune // alias para int32 (unicode)
int64   uint64
        uintptr

if, for, y func

if

Ejecuta un bloque de código si se cumple una condición.

//+build ignore OMIT

package main

import "fmt"

func main() {
    var a = "pizza" 
    if a=="pizza" {
        fmt.Println("a es pizza 🍕")
    }

}

El bloque delimitado por {} se ejecuta sólamente si a es igual a pizza.

A  == B   // true si A es igual B
A  != B   // true si A es distinto B
A   > B   // true si A es mayor a B
A  >= B   // true si A es mayor o igual a B
B1 && B2  // true si B1 y B2 son ambas true
B1 || B2  // true si alguna de B1 o B2 es true

//+build ignore OMIT

package main

import "fmt"

func main() {
    var a = "papas🍟" 
        if a=="pizza" {
            fmt.Println("a es pizza🍕")
        } else {
            fmt.Println("a no es pizza 🍕😣")
        }

	}

/* OPERATORS_S OMIT
Comparación  y Lógicos | Matemáticos       |  Bits               | Pointers
>   <   ==             |  +   -    *   /   |  &  |   ^  &^       |  *   &
>=  <=  !=             |  +=  -=   *=  /=  |  &= |=  ^=          |  Canales
||  &&   !             |  %        %=      |  <<  >>  <<=  >>=   |  <-  ->
*/ // OPERATORS_E OMIT

for

Ejecuta un bloque de código una y otra vez mientras la condición sea verdadera. La sintaxis incluye la posibilidad de inicializar variables antes de empezar, y también de modificar variables cada vez que se termina de ejecutar el bloque.

//+build ignore OMIT

package main

import "fmt"

func main() {
    for i := 1; i <= 10; i++ {
        fmt.Println("i es ", i)
    }

}

/* OPERATORS_S OMIT
Comparación  y Lógicos | Matemáticos       |  Bits               | Pointers
>   <   ==             |  +   -    *   /   |  &  |   ^  &^       |  *   &
>=  <=  !=             |  +=  -=   *=  /=  |  &= |=  ^=          |  Canales
||  &&   !             |  %        %=      |  <<  >>  <<=  >>=   |  <-  ->
*/ // OPERATORS_E OMIT

Aquí se inicializa i, se verifica que i<10, y se corre el bloque, que ente caso simplemente imprime i. Luego, se le suma 1 y se verifica la condición nuevamente.

func

Una función es un bloque de código que queremos reutilizar. Un ejemplo clásico es una función que devuelve la suma de dos números

package main

import "fmt"

func Sumar(x int, y int) int {
    return x + y
}

Ahora en cualquier lugar de nuestro código que queramos sumar dos números, podemos hacerlo de esta manera:

//+build ignore OMIT
// PROG_S OMIT
package main

import "fmt"

func Sumar(x int, y int) int {
	return x + y
}
// PROG_E OMIT

func main() {
    suma := Sumar(1, 2)
    fmt.Println(suma)
}

Retorno de múltiples valores

package main

import "fmt"

func main() {
    miDiv, miResta := DivResta(10, 4)
    fmt.Println(miDiv, miResta)
}

func DivResta(x int, y int) (float64, int) {
    div := float64(x) / float64(y)
    resta := x % y
    return div, resta
}

Bloques { } y Scope (alcance)

//+build OMIT
package main

import "fmt"

func main() {
    yo := "Ismael"
    {
        tu := "Fulano"
        fmt.Println(yo, tu)
    }
    fmt.Println(yo) // Se puede imprimir la variable "tu" aquí?
}

// FUNC_S OMIT
// FUNC_E OMIT

Hay una tres reglas muy simples que indican si se puede acceder a una variable en un cierto lugar o no:

1. El caracter { abre un bloque y } lo cierra.

2. En una función, una variable se puede utilizar desde que se declara, hasta que cierra el bloque que la contiene.

3. Una variable declara fuera de la función (en el top level) siempre es accesible, independientemente del orden.

Últimos comentarios