En Go, existe una regla de propiedad absoluta: solo puedes definir métodos para tipos declarados en el mismo paquete. Si intentas añadir un método a un http.Request o a un time.Time, el compilador te detendrá con un error de tipo cannot define new methods on non-local type.
Esta restricción no es una limitación de diseño accidental, sino una decisión deliberada para garantizar la estabilidad y la predictibilidad del sistema. En lenguajes como Python o Ruby, es posible realizar lo que se conoce como monkey patching, que consiste en modificar el comportamiento de clases existentes en tiempo de ejecución. En un ecosistema de microservicios complejo, si dos librerías distintas pudieran inyectar métodos con el mismo nombre en tipos estándar de Go, el comportamiento de tu aplicación dependería de cuál librería se cargue primero, creando un caos imposible de depurar. Go prefiere la explosión en tiempo de compilación antes que la ambigüedad en tiempo de ejecución.
Cuando necesites añadir funcionalidad a un tipo que no te pertenece, tienes tres caminos: crear una función libre que reciba el tipo como argumento, definir un nuevo tipo basado en el original (si quieres que el tipo sea distinto) o, lo más común en producción, usar embedding para crear un “wrapper” que componga el tipo original.
package main
import (
"fmt"
"net/http"
"strings"
)
// CustomRequest utiliza embedding para "extender" http.Request.
// Al embeber el puntero *http.Request, CustomRequest hereda todos sus campos
// y métodos, permitiéndonos delegar llamadas automáticamente.
type CustomRequest struct {
*http.Request
}
// GetUserID es un método que sí podemos definir porque el receptor
// es CustomRequest, un tipo que pertenece a este paquete.
func (r *CustomRequest) GetUserID() string {
// Accedemos al campo Header que es parte de http.Request
// gracias a la promoción de campos por el embedding.
return r.Header.Get("X-User-ID")
}
// ValidateToken es una función libre. Es la opción ideal cuando no
// quieres crear un nuevo tipo complejo y solo necesitas una utilidad.
func ValidateToken(r *http.Request, token string) bool {
return strings.HasPrefix(token, "valid_")
}
func main() {
// Simulamos una petición que llega a nuestro servidor
req, _ := http.NewRequest("GET", "/api/data", nil)
req.Header.Set("X-User-ID", "user_99")
req.Header.Set("Authorization", "valid_secret_token")
// 1. Uso de Embedding (Wrapper)
// Envolvemos el request original dentro de nuestro nuevo tipo.
customReq := CustomRequest{Request: req}
// Podemos usar nuestro nuevo método
userID := customReq.GetUserID()
// Podemos seguir usando los métodos originales de http.Request
// porque el compilador los "promociona" al nivel superior de CustomRequest.
method := customReq.Method
fmt.Printf("Request: %s | User: %s\n", method, userID)
// 2. Uso de Función Libre
// Es más directo si solo necesitamos una validación rápida.
token := req.Header.Get("Authorization")
if ValidateToken(req, token) {
fmt.Println("Token es válido")
} else {
fmt.Println("Token inválido")
}
}
En el ejemplo anterior, CustomRequest no es una copia de http.Request, sino un contenedor que incluye un puntero al original mediante embedding. Cuando llamas a customReq.Method en la línea 45, el compilador busca Method en CustomRequest; al no encontrarlo, busca en los campos embeberados y lo encuentra en el *http.Request original. Esto se llama promoción de métodos.
Es vital notar que GetUserID no es una modificación de http.Request, sino la adición de un comportamiento a CustomRequest. Si intentas pasar un *http.Request estándar a una función que espera un *CustomRequest, el compilador te dará un error de tipos. El wrapping es una técnica poderosa para el patrón Decorator, permitiéndote interceptar o extender la lógica de tipos de terceros de forma segura y explícita.
El error frecuente
Un error muy común ocurre cuando intentas aplicar un “cast” o conversión de tipo para intentar “engañar” al compilador.
// ESTO NO COMPILA
func (r *http.Request) MyMethod() {
// error: cannot define new methods on non-local type
}
// ESTO SÍ COMPILA, PERO ES UN ERROR DE LÓGICA
type MyRequest http.Request
func (r *MyRequest) MyMethod() {
// Error de compilación al intentar usar r.Header
// porque MyRequest es un tipo nuevo y NO hereda los campos de http.Request.
}
Al hacer type MyRequest http.Request, has creado un tipo nuevo que tiene la misma estructura que el original, pero no es el mismo tipo. Pierdes toda la visibilidad de los campos (como Header o URL) y de los métodos de http.Request. Si lo que buscas es funcionalidad, usa embedding (con el * para punteros); si lo que buscas es cambiar la identidad del tipo de forma estricta, usa la conversión, pero prepárate para redefinir todo el comportamiento.
N° 71