Saltar al contenido principal

Modulos incluidos en la libreria local de golang

Modulo time​

Documentación oficial:

Fecha actual del servidor​

fmt.Println("La Hora Actual es:", time.Now())

Output:

La Hora Actual es: 2025-05-20 14:28:33.681341122 -0300 -03 m=+0.000118244

Mostrar año​

fecha := time.Now()

fmt.Println("El año es: ", fecha.Year())

Output:

El año es: 2025

Mostrar mes​

fecha := time.Now()

fmt.Println("El mes es: ", fecha.Month())

Output:

El mes es: May

Mostrar número de mes​

fecha := time.Now()

fmt.Println("El número del mes es: ", int(fecha.Month()))

Output:

El número del mes es:  5

Mostrar el día​

fecha := time.Now()

fmt.Println("El día es:", fecha.Day())

Output:

El día es: 20

Mostrar hora, minutos, segundos​

fecha := time.Now()

fmt.Println("La hora es:", fecha.Day())
fmt.Println("Los minutos son:", fecha.Minute())
fmt.Println("Los segundos son:", fecha.Second())

Output:

La hora es: 20
Los minutos son: 32
Los segundos son: 10

Tipo time.Time​

Este tipo de variable se debe usar en un struct si necesitas un tipo Time.

fmt.Printf("El tipo es: %T \n", fecha)

Output:

El tipo es: time.Time

Fecha en formato dd/mm/yyyy​

Este tipo de variable se debe usar en un struct si necesitas un tipo Time.

fmt.Printf("%v/%v/%v \n", fecha.Day(), int(fecha.Month()), fecha.Year())

Output:

Tuesday 20 de May de 2025 a las 14:36:16

Operaciones con fechas en formato dd/mm/yyyy​

ahora := time.Now()
fmt.Printf("%v/%v/%v \n", ahora.Day(), int(ahora.Month()), ahora.Year())
// 20/5/2025

// Suma 20 días a la fecha "ahora"
addedDays := 20
fecha1 := ahora.AddDate(0, 0, addedDays)
fmt.Printf("%v/%v/%v \n", fecha1.Day(), int(fecha1.Month()), fecha1.Year())
// 9/6/2025

// Resta 20 días a la fecha "ahora"
removedDays := 20
fecha2 := ahora.AddDate(0, 0, -removedDays)
fmt.Printf("%v/%v/%v \n", fecha2.Day(), int(fecha2.Month()), fecha2.Year())
// 30/4/2025

módulo strings​

Documentación oficial:

Convertir cadena a mayúsculas​

cadena := "mi muñeca me habla..."
fmt.Println(strings.ToUpper(cadena))
// MI MUÑECA ME HABLA...

Convertir cadena a minusculas​

cadena_may := "MI MUÑECA ME HABLA..."
fmt.Println(strings.ToLower(cadena_may))
// mi muñeca me habla...

Buscar índice de una palabra en la cadena​

// Obtener indice de una palabra en una cadena
post := strings.Index(cadena, "muñeca")
fmt.Println("Indice de la palabra muñeca en la cadena:", post)
// Indice de la palabra muñeca en la cadena: 3

Obtener todos los simbolos de la cadena en un array​

cadena := "mi muñeca me habla..."
simbolos := strings.Split(cadena, "")
fmt.Println(simbolos)
// [m i   m u ñ e c a   m e   h a b l a . . .]

Repetir la cadena dos veces​

cadena := "mi muñeca me habla..."
repetida := strings.Repeat(cadena, 2)
fmt.Println(repetida)
// mi muñeca me habla...mi muñeca me habla...

Reemplazo la cadena mi por la en la cadena original​

cadena := "mi muñeca me habla..."
cadena_nueva := strings.Replace(cadena, "mi", "la", -1)
fmt.Println(cadena_nueva)

Substrings​

// De la posicion 0 hasta la 5 sin incluirla
fmt.Println(string(cadena_nueva[0:5]))
// la mu

// De la posicion 5 hasta la 9 sin incluirla
fmt.Println(string(cadena_nueva[5:9]))
// ñec

Modulo math/rand​

Documentación:

// Numeros aleatorios desde 1 hasta 101
aleatorio := rand.Intn(101)
fmt.Println(aleatorio)

// Aleatorio entre un rango 1000 y 10000
min := 1000
max := 10000

aleatorio2 := rand.Intn((max - min) + min)
fmt.Println(aleatorio2)

Modulo OS​

Documentación:

Recibir argumentos en el comand "go run"​

flagName := "nombre"
flagValue := ""
flagUsage := "El nombre de la persona"

nombreFlag := flag.String(flagName, flagValue, flagUsage)

flagEdadName := "edad"
flagEdadValue := 18
flagEdadUsage := "la edad de la persona"

edadFlag := flag.Int(flagEdadName, flagEdadValue, flagEdadUsage)

flag.Parse()

fmt.Print("Tu nombre es:", *nombreFlag)
fmt.Print("\nTu edad es:", *edadFlag)
go run . -nombre Julian -edad 33

Tu nombre es:Julian
Tu edad es:33

Modulo log​

Este módulo es util para mostrar mensajes por salida de la terminal o guardarlos en un archivo de logs

log.Fatal("hola soy un error")
fmt.Println("Hola soy otro texto")

log.Fatal muestra un error por terminal y corto la ejecución no mostrando el texto "Hola soy otro texto"

182025/05/28 16:19:16 hola soy un error
exit status 1

Instanciar nuevo error y mostrarlo con Fatal​

err := errors.New("este es un error fatal")
log.Fatal(err)
182025/05/28 16:21:16 este es un error fatal
exit status 1

Mostrar mensaje por terminal​

log.Println("hola soy un log")
182025/05/28 16:22:12 hola soy un log

Fatal con formato​

log.Fatalf("%s Fatal: Fatal Error Signal", "Error Type")
2025/05/28 16:23:22 Error Type Fatal: Fatal Error Signal
exit status 1

Panic​

log.Panic("Error: Panic")
2025/05/28 16:23:52 Error: Panic
panic: Error: Panic
goroutine 1 [running]:
log.Panic({0xc00009bf10?, 0x0?, 0x2?})
        /usr/local/go/src/log/log.go:432 +0x5a
main.main()
        /home/julian/cursos/go/modulos/main.go:166 +0x1498
exit status 2

Panic vs Fatal​

alt text

PanicLn​

log.Panicln("Error: Panic")
2025/05/28 16:24:38 Error: Panic
panic: Error: Panic
goroutine 1 [running]:
log.Panicln({0xc00009bf10?, 0x0?, 0x2?})
        /usr/local/go/src/log/log.go:446 +0x5a
main.main()
        /home/julian/cursos/go/modulos/main.go:179 +0x1498
exit status 2

Panicf​

log.Panicf("error %s", err)
2025/05/28 16:26:23 error este es un error fatal
panic: error este es un error fatal
goroutine 1 [running]:
log.Panicf({0x4d0ae3?, 0x0?}, {0xc00009bf10?, 0xc00009bf20?, 0x2?})
        /usr/local/go/src/log/log.go:439 +0x65
main.main()
        /home/julian/cursos/go/modulos/main.go:193 +0x14d4
exit status 2

Guardar logs en un archivo​

f, err := os.OpenFile("logs.log", os.O_APPEND|os.O_CREATE|os.O_RDWR, 0666)

if err != nil {
	log.Fatal(err)
}

// Cerrar el archivo
defer f.Close()

log.SetOutput(f)
log.Printf("Error línea %v", 1)
  • s.O_APPEND: todos los datos escritos se añadirán al final del archivo (modo "append").
  • os.O_CREATE: si el archivo no existe, lo crea.
  • os.O_RDWR: abre el archivo para lectura y escritura.
  • 0666: son los permisos del archivo en octal
    • Es decir: rw-rw-rw-

Se deberia generar en un archivo logs.log en el mismo directorio, el cual contiene los logs generados por el main.

2025/05/28 16:26:23 error este es un error fatal
panic: error este es un error fatal
goroutine 1 [running]:
log.Panicf({0x4d0ae3?, 0x0?}, {0xc00009bf10?, 0xc00009bf20?, 0x2?})
        /usr/local/go/src/log/log.go:439 +0x65
main.main()
        /home/julian/cursos/go/modulos/main.go:193 +0x14d4
exit status 2

Modulos custom​

  1. Primero necesitamos el archivo go.mod creado
  2. Declarado el package main
  3. Crear carpeta del modulo (e.g "modulo_ejemplo")
  4. Dentro de esa carpeta crear un archivo go modulo_ejemplo.go
  5. Agregar en la primera linea package modulo_ejemplo
  6. Lo importo en el main con modulo_ejemplo

Modulo "modulo_ejemplo"​

package modulo_ejemplo

// La primer mayuscula hace publico el evento
func Ejemplo1() string {
	return "saluda"
}

func Ejemplo2(name string) string {
	return "saluda " + name
}
import (
	"fmt"
	mod "modulos/modulo_ejemplo"
)

fmt.Println(mod.Ejemplo1())
fmt.Println(mod.Ejemplo2("julian"))