Ocultamiento de información en Go

Parte de la sección Programación Orientada a Objetos del Journey de GO de Coddy — lección 50 de 107.

Ocultación de información va más allá de simplemente hacer que los campos no sean exportados. Se trata de diseñar tus tipos de modo que el código externo solo sepa lo que necesita saber, nada más.

El objetivo es exponer comportamiento a través de métodos mientras se mantiene la estructura interna completamente oculta. Considere este enfoque:

type Counter struct {
    value    int
    maxLimit int
}

func NewCounter(limit int) *Counter {
    return &Counter{maxLimit: limit}
}

func (c *Counter) Increment() bool {
    if c.value >= c.maxLimit {
        return false
    }
    c.value++
    return true
}

func (c *Counter) Value() int {
    return c.value
}

El código externo no sabe que Counter utiliza un int internamente. Podría ser un float64, un slice o algo completamente distinto. La implementación puede cambiar sin afectar a ningún código que utilice Counter, siempre que los métodos se comporten de la misma manera.

Este principio también se aplica a las funciones auxiliares. Mantén la lógica interna sin exportar:

// Exportado - parte de la API pública
func (c *Counter) Reset() {
    c.value = 0
}

// no exportado - ayudante interno
func (c *Counter) isAtLimit() bool {
    return c.value >= c.maxLimit
}

Al ocultar isAtLimit(), tienes la libertad de cambiarlo o eliminarlo más tarde. El ocultamiento de información crea un límite claro entre lo que tu paquete promete a los usuarios externos y cómo funciona internamente.

Desafío

Fácil

Vamos a construir un sistema de billetera segura que demuestre la ocultación de información. Crearás una billetera digital donde el seguimiento del saldo interno y el historial de transacciones estén completamente ocultos para el código externo; solo el comportamiento se expone a través de métodos.

Organizarás tu código en dos archivos:

wallet.go: Crea una estructura Wallet que oculte todo su estado interno. La billetera debe rastrear el saldo actual y un límite de gasto internamente, pero el código externo nunca debe saber cómo se almacenan o representan. Expón el comportamiento a través de estos métodos:
- NewWallet(limit float64) *Wallet - constructor que crea una billetera con el límite de gasto dado y saldo cero
- Deposit(amount float64) bool - añade dinero a la billetera, devuelve true si tiene éxito (el monto debe ser positivo)
- Spend(amount float64) bool - retira dinero si existe saldo suficiente Y el monto no excede el límite de gasto, devuelve true si tiene éxito
- Balance() float64 - devuelve el saldo actual
- Status() string - devuelve un mensaje de estado en el formato: Balance: $[balance] (Limit: $[limit])
Mantén cualquier lógica auxiliar (como verificar si una transacción es válida) como funciones o métodos no exportados; estos son detalles de implementación interna que podrían cambiar más adelante.
main.go: Lee la configuración de la billetera y las transacciones de la entrada, crea una billetera, realiza operaciones y muestra los resultados después de cada acción.

Se proporcionarán las siguientes entradas:

Línea 1: Límite de gasto
Línea 2: Monto del depósito
Línea 3: Monto del primer gasto
Línea 4: Monto del segundo gasto

Después de crear la billetera, imprime su estado inicial. Luego realiza cada operación e imprime el estado actualizado (si tiene éxito) o Transaction failed (si la operación fue rechazada). Formatea todos los montos en dólares con dos decimales.

Por ejemplo, dados 50, 100, 30 y 80, tu salida debería ser:

Balance: $0.00 (Limit: $50.00)
Balance: $100.00 (Limit: $50.00)
Balance: $70.00 (Limit: $50.00)
Transaction failed

La última transacción falla porque $80 excede el límite de gasto de $50, a pesar de que hay saldo suficiente. La billetera impone sus reglas internamente sin exponer cómo toma estas decisiones. El código externo simplemente llama a los métodos y recibe los resultados, sin conocer nunca los detalles de la implementación interna.

Hoja de referencia

La ocultación de información significa diseñar tipos de modo que el código externo solo sepa lo que necesita saber. Exponga el comportamiento a través de métodos mientras mantiene la estructura interna completamente oculta.

Ejemplo de un tipo con implementación oculta:

type Counter struct {
    value    int
    maxLimit int
}

func NewCounter(limit int) *Counter {
    return &Counter{maxLimit: limit}
}

func (c *Counter) Increment() bool {
    if c.value >= c.maxLimit {
        return false
    }
    c.value++
    return true
}

func (c *Counter) Value() int {
    return c.value
}

El código externo no conoce la representación interna (podría ser int, float64 o cualquier otra cosa). La implementación puede cambiar sin afectar al código que la utiliza.

Mantenga las funciones auxiliares sin exportar:

// Exportado - parte de la API pública
func (c *Counter) Reset() {
    c.value = 0
}

// no exportado - ayudante interno
func (c *Counter) isAtLimit() bool {
    return c.value >= c.maxLimit
}

La ocultación de información crea un límite claro entre lo que su paquete promete externamente y cómo funciona internamente.

Pruébalo tú mismo

package main

import (
	"fmt"
)

func main() {
	// Leer entradas
	var limit float64
	var depositAmount float64
	var spend1 float64
	var spend2 float64

	fmt.Scanln(&limit)
	fmt.Scanln(&depositAmount)
	fmt.Scanln(&spend1)
	fmt.Scanln(&spend2)

	// TODO: Crear una nueva billetera con el límite de gasto dado

	// TODO: Imprimir el estado inicial

	// TODO: Realizar el depósito e imprimir el resultado (estado o "Transaction failed")

	// TODO: Realizar el primer gasto e imprimir el resultado

	// TODO: Realizar el segundo gasto e imprimir el resultado
}