Go Academy · Lección

Hooks y scopes

Personalice consultas

Hooks y scopes es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

Hooks y scopes

GORM ofrece dos herramientas de personalización: los hooks ejecutan código automáticamente alrededor de los eventos del ciclo de vida, y los scopes encapsulan lógica de consulta reutilizable. Juntos mantienen limpio y coherente el acceso a los datos.

Qué son los hooks

Los hooks son métodos del modelo que GORM llama antes o después de una operación: BeforeCreate, AfterCreate, BeforeUpdate, BeforeDelete, entre otros.

Un hook BeforeCreate

Defina un método con la firma adecuada en el modelo. Aquí establecemos un UUID antes de insertar el registro.

func (u *User) BeforeCreate(tx *gorm.DB) error {
    u.UUID = uuid.NewString()
    return nil
}

Validación en hooks

Devuelva un error desde un hook para cancelar la operación. GORM revierte la transacción que la rodea, por lo que los datos no válidos nunca llegan a la base de datos.

func (u *User) BeforeSave(tx *gorm.DB) error {
    if u.Age < 0 {
        return errors.New("age cannot be negative")
    }
    return nil
}

Los hooks se ejecutan en una transacción

El argumento tx *gorm.DB es la transacción que utiliza GORM. Si escribe datos relacionados dentro de un hook, use este tx para que se confirmen o reviertan atómicamente junto con la operación principal.

Qué son los scopes

Un scope es una función que recibe y devuelve un *gorm.DB y encapsula un fragmento de consulta. Se aplica con db.Scopes(...) y se reutiliza en muchas consultas.

func ActiveUsers(db *gorm.DB) *gorm.DB {
    return db.Where("active = ?", true)
}

Aplicación de scopes

Pase uno o más scopes a Scopes. Se combinan entre sí, por lo que puede unir filtros de forma declarativa para crear la consulta final.

db.Scopes(ActiveUsers, Recent).Find(&users)

Simulación ejecutable de un hook y un scope

GORM necesita una base de datos, por lo que este ejemplo ejecutable simula un hook BeforeCreate y un filtro reutilizable similar a un scope mediante funciones simples.

package main

import (
    "errors"
    "fmt"
)

type User struct {
    Name   string
    Age    int
    Active bool
}

func beforeCreate(u *User) error {
    if u.Age < 0 {
        return errors.New("age cannot be negative")
    }
    if u.Name == "" {
        u.Name = "anonymous"
    }
    return nil
}

func activeOnly(users []User) []User {
    var out []User
    for _, u := range users {
        if u.Active {
            out = append(out, u)
        }
    }
    return out
}

func main() {
    u := User{Age: 30, Active: true}
    if err := beforeCreate(&u); err != nil {
        fmt.Println("error:", err)
        return
    }
    fmt.Println("created:", u.Name)
    all := []User{u, {Name: "Lin", Active: false}}
    fmt.Println("active count:", len(activeOnly(all)))
}

Scopes para paginación

Un scope habitual genera la paginación a partir de un número de página y encapsula Offset y Limit para que todos los endpoints de listas paginen de la misma manera.

func Paginate(page, size int) func(*gorm.DB) *gorm.DB {
    return func(db *gorm.DB) *gorm.DB {
        return db.Offset((page - 1) * size).Limit(size)
    }
}

Hooks frente a lógica de aplicación

Los hooks centralizan aspectos transversales como marcas de tiempo, slugs y campos de auditoría. Mantenga la lógica de negocio compleja en los servicios, no en los hooks, para que el comportamiento siga siendo predecible y fácil de probar.

Omitir hooks

En operaciones masivas puede desactivar los hooks con db.Session(&gorm.Session{SkipHooks: true}). Esto acelera las importaciones grandes, pero omite sus validaciones, así que úselo con cuidado.

Comprobación rápida

Ponga a prueba sus conocimientos sobre hooks y scopes.

Resumen

Ha aprendido sobre hooks y scopes:

Los hooks se ejecutan alrededor de eventos del ciclo de vida; devolver un error aborta la operación y revierte la transacción
Los hooks se ejecutan dentro de la transacción mediante el argumento tx
Los scopes son funciones reutilizables de *gorm.DB que se aplican con Scopes
Use scopes para filtros y paginación
SkipHooks omite los hooks en operaciones masivas

Preguntas frecuentes

¿La lección «Hooks y scopes» es gratis?

Sí — el texto completo de «Hooks y scopes» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Hooks y scopes»?

Personalice consultas Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Hooks y scopes»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Go Academy