Go: Sintaxis

En este módulo, exploraremos en profundidad la sintaxis del lenguaje de programación Go, también conocido como Golang. Go es un lenguaje compilado y concurrente desarrollado por Google, diseñado para crear software eficiente y escalable. Comprender su sintaxis es fundamental para aprovechar al máximo sus capacidades.

Estructura básica de un programa en Go

Un programa en Go se compone de paquetes. El punto de entrada de cualquier aplicación es el paquete main, que contiene la función main().

package main

import "fmt"

func main() {
    fmt.Println("Hola, mundo")
}

Explicación:

• package main: Define el paquete principal del programa.
• import "fmt": Importa el paquete fmt, que proporciona funciones de formato de E/S.
• func main(): Función principal donde comienza la ejecución.

Declaración de variables

Go es un lenguaje estáticamente tipado. Las variables se pueden declarar de varias maneras.

Declaración explícita

var nombre string
nombre = "Juan"

Declaración con inicialización

var edad int = 30

Inferencia de tipos

altura := 1.75

El operador := declara e inicializa la variable, infiriendo el tipo automáticamente.

Tipos de datos

Go ofrece varios tipos de datos básicos:

• Enteros: int, int8, int16, int32, int64
• Flotantes: float32, float64
• Booleanos: bool
• Cadenas: string

Ejemplo:

var contador int = 10
var precio float64 = 99.99
var activo bool = true
var mensaje string = "Bienvenido"

Constantes

Las constantes se declaran con la palabra clave const.

const Pi = 3.1416
const Usuario = "admin"

Operadores

Go soporta operadores aritméticos, lógicos y relacionales.

• Aritméticos: +, -, *, /, %
• Relacionales: ==, !=, >, <, >=, <=
• Lógicos: &&, ||, !

Ejemplo:

a := 10
b := 20

// Operador aritmético
suma := a + b

// Operador relacional
esMayor := a > b

// Operador lógico
resultado := (a < b) && (b > 15)

Estructuras de control

Sentencia if

if condicion {
    // Código si la condición es verdadera
} else {
    // Código si la condición es falsa
}

Ejemplo:

edad := 18

if edad >= 18 {
    fmt.Println("Es mayor de edad")
} else {
    fmt.Println("Es menor de edad")
}

Sentencia switch

El switch en Go es una alternativa concisa a múltiples condiciones if-else.

switch variable {
case valor1:
    // Código
case valor2:
    // Código
default:
    // Código por defecto
}

Ejemplo:

dia := "lunes"

switch dia {
case "lunes", "martes", "miércoles", "jueves", "viernes":
    fmt.Println("Es un día laborable")
case "sábado", "domingo":
    fmt.Println("Es fin de semana")
default:
    fmt.Println("Día desconocido")
}

Bucles

Bucle for

Go utiliza el bucle for como su única estructura de bucle.

for inicialización; condición; post {
    // Código a ejecutar
}

Ejemplo:

for i := 0; i < 10; i++ {
    fmt.Println(i)
}

También se puede utilizar for como un bucle while.

i := 0
for i < 10 {
    fmt.Println(i)
    i++
}

Rango en bucles

Para iterar sobre arreglos, slices, mapas o cadenas, se utiliza for range.

Ejemplo con slice:

numeros := []int{1, 2, 3, 4, 5}

for indice, valor := range numeros {
    fmt.Printf("Índice: %d, Valor: %d\n", indice, valor)
}

Funciones

Las funciones en Go se declaran con la palabra clave func.

func nombreFuncion(parametros) tipoRetorno {
    // Código
    return valor
}

Ejemplo:

func sumar(a int, b int) int {
    return a + b
}

Múltiples valores de retorno

Una función puede devolver múltiplos valores.

func operaciones(a int, b int) (int, int) {
    suma := a + b
    resta := a - b
    return suma, resta
}

Uso:

suma, resta := operaciones(10, 5)
fmt.Println("Suma:", suma)
fmt.Println("Resta:", resta)

Funciones anónimas y closures

Go admite funciones anónimas y closures.

Ejemplo:

incrementar := func(x int) int {
    return x + 1
}

resultado := incrementar(5)
fmt.Println(resultado) // Imprime 6

Paquetes e importaciones

Los paquetes permiten organizar el código y reutilizar funcionalidades.

Creación de un paquete:

Supongamos un archivo en la ruta matematica/operaciones.go.

package matematica

func Sumar(a int, b int) int {
    return a + b
}

Importación y uso:

package main

import (
    "fmt"
    "matematica"
)

func main() {
    resultado := matematica.Sumar(2, 3)
    fmt.Println(resultado)
}

Punteros

Go soporta punteros, que son referencias a ubicaciones de memoria.

Declaración de punteros:

var puntero *int

Asignación de dirección:

var numero int = 10
puntero = &numero

Desreferenciación:

fmt.Println(*puntero) // Imprime 10

Estructuras (Structs)

Las estructuras permiten crear tipos de datos compuestos.

Declaración:

type Persona struct {
    Nombre string
    Edad   int
}

Instanciación y uso:

p := Persona{
    Nombre: "Ana",
    Edad:   25,
}

fmt.Println(p.Nombre)

Métodos

Se pueden definir métodos asociados a tipos.

func (p Persona) Saludar() {
    fmt.Printf("Hola, soy %s\n", p.Nombre)
}

Uso:

p.Saludar()

Interfaces

Las interfaces definen comportamientos mediante la especificación de métodos.

Declaración:

type SerVivo interface {
    Respirar()
}

Implementación:

func (p Persona) Respirar() {
    fmt.Println("La persona está respirando")
}

Manejo de errores

Go maneja errores mediante el uso de valores de error retornados.

Ejemplo:

func dividir(a float64, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("no se puede dividir entre cero")
    }
    return a / b, nil
}

Uso:

resultado, err := dividir(10, 0)
if err != nil {
    fmt.Println(err)
} else {
    fmt.Println("Resultado:", resultado)
}

Goroutines y concurrencia

Go incorpora concurrencia mediante goroutines y canales.

Goroutines:

go func() {
    fmt.Println("Esto se ejecuta concurrentemente")
}()

Canales:

canal := make(chan int)

go func() {
    canal <- 5
}()

valor := <-canal
fmt.Println(valor) // Imprime 5

Comentarios

Los comentarios son esenciales para documentar el código.

• Comentario de una línea: // Esto es un comentario
• Comentario multilinea:

/*
Esto es un comentario
multilínea
*/

Este módulo cubre los aspectos fundamentales de la sintaxis en Go. Comprender estos conceptos es crucial para desarrollar aplicaciones sólidas y eficientes en este lenguaje. Se recomienda practicar cada sección y consultar la documentación oficial de Go para profundizar en cada tema.