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.

El ocultamiento de información va más allá de simplemente hacer que los campos no se exporten. 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 el comportamiento mediante métodos mientras se mantiene completamente oculta la estructura interna. Considera 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 usa 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 use 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 libertad para cambiarlo o eliminarlo más adelante. 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

Construyamos un sistema de cartera segura que demuestre la ocultación de información. Crearás una cartera digital en la que el seguimiento del saldo interno y el historial de transacciones estén completamente ocultos para el código externo: solo se expone el comportamiento mediante métodos.

Organizarás tu código en dos archivos:

wallet.go: crea una estructura Wallet que oculte todo su estado interno. La cartera debe realizar un seguimiento interno del saldo actual y de un límite de gasto, pero el código externo nunca debe saber cómo se almacenan o representan. Expón el comportamiento mediante estos métodos:
- NewWallet(limit float64) *Wallet - constructor que crea una cartera con el límite de gasto indicado y saldo cero
- Deposit(amount float64) bool - añade dinero a la cartera y devuelve true si tiene éxito (el importe debe ser positivo)
- Spend(amount float64) bool - retira dinero si existe saldo suficiente Y el importe no supera el límite de gasto, y devuelve true si tiene éxito
- Balance() float64 - devuelve el saldo actual
- Status() string - devuelve un mensaje de estado con el formato: Balance: $[balance] (Limit: $[limit])
Mantén cualquier lógica auxiliar (como comprobar si una transacción es válida) como funciones o métodos no exportados. Estos son detalles de implementación internos que podrían cambiar más adelante.
main.go: lee la configuración de la cartera y las transacciones desde la entrada, crea una cartera, realiza las 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: importe del depósito
Línea 3: primer importe de gasto
Línea 4: segundo importe de gasto

Después de crear la cartera, imprime su estado inicial. Después realiza cada operación e imprime el estado actualizado (si tiene éxito) o Transaction failed (si la operación es rechazada). Da formato a todos los importes 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 supera el límite de gasto de $50, aunque haya saldo suficiente. La cartera aplica sus reglas internamente sin exponer cómo toma estas decisiones. El código externo simplemente llama a los métodos y recibe resultados, sin conocer nunca los detalles de implementación internos.

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: Perform deposit and print result (status or "Transaction failed")

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

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