Golang, a menudo llamado simplemente Go, es un lenguaje de programación de código abierto diseñado por Google y publicado en 2009. Creado por Robert Griesemer, Rob Pike y Ken Thompson, este lenguaje busca ofrecer una solución rápida, eficiente y fácilmente mantenible para el desarrollo de software moderno, especialmente en sistemas distribuidos, la nube y las infraestructuras de back-end.
¿Para qué campos de aplicación?
El lenguaje Go es de particular interés en diferentes campos, incluyendo específicamente:
- Sistemas en la nube y distribuidos: Go es frecuentemente utilizado en entornos de cloud computing donde es especialmente valorado para aplicaciones en la nube nativa y microservicios.
- Infraestructuras de back-end: Siendo un lenguaje compilado muy eficiente, Go es una excelente opción para los back-end de plataformas de gran envergadura, tales como los sistemas de gestión de datos y las API.
- Servicios web: Muchas empresas lo utilizan para desarrollar programas Go que son confiables y escalables, como Docker o Kubernetes.
Ventajas y desventajas
Golang presenta numerosas ventajas, pero también tiene desventajas que es importante considerar.
Ventajas
Desventajas
Simplicidad: Su sintaxis es simple, clara y fácil de leer.
Ausencia de genéricos: Hasta hace poco, Go no ofrecía genéricos, lo que podía hacer que algunas estructuras de datos fueran más complejas de manejar.
Altas performances: Go es un lenguaje compilado, lo que lo hace rápido en la ejecución, cercano al nivel de performance del C o C++.
Sintaxis rudimentaria: La simplicidad puede tener un costo. Por ejemplo, al lenguaje le faltan algunas abstracciones avanzadas que se encuentran en otros lenguajes.
Gestión de la concurrencia: Las goroutines son un mecanismo poderoso que permite la concurrencia de manera eficiente y simple.
Gestión de errores: El manejo de errores es deliberadamente extenso, lo que puede hacer que el código Go sea más largo y más difícil de leer.
Cross-compilation: Go permite compilar código fuente para múltiples plataformas con gran facilidad.
Rico ecosistema de bibliotecas: Ofrece un ecosistema rico en bibliotecas y herramientas.
Estructura del lenguaje
Go es un lenguaje relativamente cercano al C en términos de sintaxis.
Los paquetes
Un paquete (package) es una unidad de modularidad y distribución. Cada archivo Go es parte de un paquete, y los paquetes permiten reutilizar código de una manera estructurada.
- package main: Este paquete particular indica el punto de entrada de un programa ejecutable. Si desarrollas una aplicación, esta debe incluir el paquete main.
- Los otros paquetes pueden ser importados para proporcionar funcionalidades adicionales, como fmt para la gestión de entradas/salidas.
Las importaciones
Las importaciones en Go permiten utilizar paquetes externos o paquetes de la biblioteca estándar para enriquecer las funcionalidades de tu programa.
Por ejemplo, el siguiente código importa un paquete (fmt) de la biblioteca estándar:
import "fmt"
Las importaciones múltiples son posibles de la siguiente forma:
import (
"fmt"
"time"
)
Las funciones
Las funciones en Go son bloques de código que realizan una tarea específica. La función main es obligatoria ya que constituye el punto de inicio de todo programa Go.
La siguiente función, llamada Hello toma un nombre como parámetro y devuelve un saludo:
func hello(name string) string {
return "Hello, " + name
}
Las variables
Las variables se declaran con la palabra clave var, pero también pueden ser definidas más sucintamente con el operador := para una declaración implícita.
El siguiente ejemplo muestra una primera variable declarada explícitamente como una cadena de caracteres, y una segunda declarada implícitamente como un entero.
var message string = "Hello World!"
nombre := 42
El tipado
Go es un lenguaje con tipado estático: cada variable se determina al momento de la compilación.
El control de flujo
En Go, el control de flujo incluye las instrucciones clásicas como if…else, for y switch. Sin embargo, no posee un bucle while, aunque for puede ser usado de manera similar.
Aquí, el bucle imprime los números del 0 al 9:
for i := 0; i < 10; i++ {
fmt.Println(i)
}
El bucle if siguiente muestra si el número es par o impar:
number := 7
if number%2 == 0 {
fmt.Println("The number is even")
} else {
fmt.Println("The number is odd")
}
La instrucción switch siguiente evalúa el valor de la variable day y ejecuta el bloque correspondiente:
day := "tuesday"
switch day {
case "monday":
fmt.Println("Start of the week")
case "tuesday":
fmt.Println("Second day of the week")
case "wednesday":
fmt.Println("Middle of the week")
default:
fmt.Println("Day not specified")
}
Estructura de datos
Se pueden utilizar diversas estructuras de datos, como los arrays, los slices, los maps y los structs.
- Los slices permiten manipular secuencias de datos de manera flexible:
numbers := []int{1, 2, 3, 4, 5}
fmt.Println(numbers)
- Los maps son una colección de pares clave-valor, similar a los diccionarios en otros lenguajes:
capitals := map[string]string{"France": "Paris", "Italy": "Roma"}
fmt.Println(capitals["France"])
Comandos básicos
Golang dispone de varios comandos básicos para facilitar la gestión y ejecución del código:
- go fmt: Formatea automáticamente el código Go para hacerlo más legible.
- go run: Compila y ejecuta el código Go directamente.
- go test: Proporciona un framework integrado para escribir y ejecutar pruebas unitarias.
- go build: Compila el código fuente para producir un ejecutable.
capitals := map[string]string{"France": "Paris", "Italy": "Roma"}
fmt.Println(capitals["France"])
Goroutine y concurrencia
Una de las características más poderosas de Go es su capacidad para gestionar la concurrencia a través de las goroutines. Estas son funciones que se ejecutan de manera concurrente con el resto del programa. Para iniciar una goroutine, basta con anteponer la palabra clave go a una llamada de función.
Aquí hay un ejemplo:
package main
import (
"fmt"
"time"
)
func worker(mytask string) {
for i := 0; i < 3; i++ {
fmt.Printf("%s : iteration %d\n", mytask, i)
time.Sleep(500 * time.Millisecond)
}
}
func main() {
go worker("Task1")
go worker("Task2")
worker("Main task")
// Waiting for goroutine to end
time.Sleep(2 * time.Second)
}
Las goroutines Task1 y Task2 se ejecutan en paralelo con Main task.
Conclusión
Golang es un lenguaje poderoso. Su simplicidad, su gestión eficaz de la concurrencia a través de las goroutines, y la calidad de sus herramientas y bibliotecas lo convierten en una opción atractiva para muchos proyectos modernos.
