Inicia tu carrera de programador en Go

¿Por dónde empezar?

No hay mejor opción que por la definición del lenguaje de programación Go. El llamado Go o anteriormente como Golang, es un lenguaje de programación de código abierto desarrollado por Google. Es un lenguaje compilado de tipo estático. Este lenguaje admite programación concurrente y también permite ejecutar múltiples procesos simultáneamente.

Instalando Go con Choco para Windows

En mi caso, estoy usando Windows como sistema operativo base, por lo que me será útil instalar Go de la manera más sencilla con Chocolatey.

Esta se instala desde PowerShell mediante la siguiente instrucción:

Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

La instalación de Go mediante Choco se hace de la siguiente manera:

choco install golang

También puede actualizar y desinstalar golang con Choco de la siguiente manera:

choco upgrade golang
choco uninstall golang

Instalando Go en GNU/Linux (Ubuntu)

Las siguientes instrucciones son obtenidas de la documentación oficial de go.dev.

sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf go1.17.7.linux-amd64.tar.gz

Se agrega la variable de entorno al $PATH

export PATH=$PATH:/usr/local/go/bin

En ambos casos, para comprobar que la instalación se haya resuelto correctamente, se mira la versión de Go.

go version

Sintaxis básica de Go

Escribiéndo el "Hello, World!" como el clásico ejercicio inicial.

Los objetivos son simples:

Escribir una función que retorne el string "Hello, World!".
Compilar el script y ejecutarlo.

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

El proceso de compilación es el siguiente:

go build hello_world.go

La ejecución se realiza por medio de la instrucción go run.

# Ejecutar sin compilar.
go run hello_world.go

# Ejecutar después de haber compilado.
./hello_world.exe

#Output
Hello, World!

Variables y declaración

Las variables sirven para asociar una tira de datos con un sector de la memoria, siendo esta, un identificador. En palabras sencillas, las variables guardan datos.

Definir variables con las palabras reservadas var y const.

Declarando constantes:

package main

import "fmt"

func main() {
    /* Palabra reservada + Nombre de variable + Tipo de dato + Valor */
    const PI float64 = 3.14
    const PI2 = 3.14

    fmt.Println("Pi:", PI, "\nPi2: ", PI2)

}

go run constantes.go

#Output
Pi: 3.14 
Pi2:  3.14

Declarando variables enteras

package main

import "fmt"

func main() {
    /* Declara la variable "Base", identifica el tipo de dato respecto al valor */
    Base := 10          //Primera forma
    var Altura int = 20 //Segunda forma
    var Area int        //Go no compila si las variables no son usadas

    fmt.Println("Base: ", Base, " | Altura: ", Altura, " | Area: ", Area)

    /*Si no hay valores definidos, Go le asigna un vacío.*/
    var a int     //0
    var b float64 //0.0
    var c string  //""
    var d bool    //false

    fmt.Println("a: ", a, " | b: ", b, " | c: ", c, " | d: ", d)
}

go run variables.go

#Output
Base:  10  | Altura:  20  | Area:  0
a:  0  | b:  0  | c:    | d:  false

Ejercicio

Calcular el área de un cuadrado e imprimirlo.

package main

import "fmt"

func main() {
    const BaseCuadrado = 10
    AreaCuadrado := BaseCuadrado * BaseCuadrado

    fmt.Println("El área del cuadrado es:", AreaCuadrado)
}

go run obtener_cuadrado.go

#Output
El área del cuadrado es: 100

Ejercicio

Realizar operaciones aritméticas, como sumar, restar, multiplicar y dividir.

package main

import "fmt"

func main() {
    /* Palabra reservada + Nombre de variable + Tipo de dato + Valor */
    var A int = 10
    var B int = 20

    Suma := A + B
    Resta := A - B
    Multiplicacion := A * B
    Division := A / B
    Modulo := A % B

    A++
    B--

    fmt.Println("Suma:", Suma)
    fmt.Println("Resta:", Resta)
    fmt.Println("Multiplicacion:", Multiplicacion)
    fmt.Println("Division:", Division)
    fmt.Println("Modulo:", Modulo)
    fmt.Println("Incremental:", A)
    fmt.Println("Decremental:", B)
}

go run operaciones_aritmeticas.go 

#Output
Suma: 30
Resta: -10
Multiplicacion: 200
Division: 0
Modulo: 10
Incremental: 11
Decremental: 19

Ejercicio

Calcular el área de un rectángulo, trapecio y círculo.

package main

import (
    "fmt"
    "math"
)

func main() {
    /* Declaracion de variables base */
    Base := 10
    BaseMayor := 20
    Altura := 30
    Radio := 20

    fmt.Println("El área del rectángulo es:", Base*Altura)
    fmt.Println("El área del trapecio es:", ((BaseMayor+Base)*Altura)/2)
    fmt.Println("El área del círculo es:", math.Pi*math.Pow(float64(Radio), 2))
}

go run calcular_area_rectangulo_trapecio_circulo.go

#Output
El área del rectángulo es: 300
El área del trapecio es: 450
El área del círculo es: 1256.6370614359173

Ejercicio

Crear un saludo modular. Para este escenario, crearemos 3 ficheros:

main.go

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")

    hello()
    bye()
}

hello.go

package main

import "fmt"

func hello() {
    fmt.Println("Hello, friend!")
}

bye.go

package main

import "fmt"

func bye() {
    fmt.Println("Goodbye, friend!")
}

Ejecucion:

go mod init Package/main
go run .

#Output
Hello, World!
Hello, friend!
Goodbye, friend!

Generará un fichero go.mod que contiene lo siguiente:

module Package/main

go 1.17

Tipos de datos

Estos son los tipos de datos y tipos compuestos que podemos encontrar en Go.

Basic Types
- Integers
  - Signed
    - int
    - int8
    - int16
    - int32
    - int64
  - Unsigned
    - uint
    - uint8
    - uint16
    - uint32
    - uint64
    - uintptr
- Floats
  - float32
  - float64
- Complex Numbers
  - complex64
  - complex128
- Byte
- Rune
- String
- Boolean
Composite Types
- Collection/Aggregation or Non-Reference Types
  - Arrays
  - Structs
- Reference Types
  - Slices
  - Maps
  - Channels
  - Pointers
  - Function/Methods
- Interface
  - Special case of empty Interface

Números enteros

//int = Depende del OS (32 o 64 bits)
//int8 = 8bits = -128 a 127
//int16 = 16bits = -2^15 a 2^15-1
//int32 = 32bits = -2^31 a 2^31-1
//int64 = 64bits = -2^63 a 2^63-1

Optimizar memoria cuando sabemos que el dato siempre será positivo

//uint = Depende del OS (32 o 64 bits)
//uint8 = 8bits = 0 a 127
//uint16 = 16bits = 0 a 2^15-1
//uint32 = 32bits = 0 a 2^31-1
//uint64 = 64bits = 0 a 2^63-1

Números decimales

// float32 = 32 bits = +/- 1.18e^-38 +/- -3.4e^38
// float64 = 64 bits = +/- 2.23e^-308 +/- -1.8e^308

Strings y booleanos

//string = ""
//bool = true or false

Números complejos

//Complex64 = Real e Imaginario float32
//Complex128 = Real e Imaginario float64
//Ejemplo : c:=10 + 8i

De esta manera ya puedes dar los primeros pasos con Go. En el próximo contenido, vamos a profundizar en cómo imprimir y usar el paquete fmt, así como manipular variables de entorno y funciones.

Recurso principal donde puedes ver adelantos, además de todos los programas escritos:

Repositorio: 30 días de Go.

Recursos donde puedes seguir educándote sobre estos temas, precisamente en el nivel que muestra este documento.

Qué es Go o Golang | OpenWebinars

Go vs Python: Diferencias y puntos fuertes | OpenWebinars

Introduction · GitBook

GoLang Tutorials: Table of Contents

All data types in Golang with examples - Welcome To Golang By Example

Algunos vídeos en YouTube.

Golang Tutorial for Beginners | Full Go Course TechWorld With Nana

Go / Golang Crash Course - YouTube

Antonio Moreno

Inicia tu carrera de programador en Go

John Rosenberg

Short profile description