Memento
Recuerdo · Instantánea
Captura el estado interno de un objeto para poder restaurarlo más tarde, sin romper su encapsulamiento.
“Necesito guardar y restaurar el estado de un objeto sin exponer sus datos internos.”
workEl caso real
Un concesionario tiene un configurador web de autos: modelo, color, motor, paquete de equipamiento y accesorios. Cada elección cambia el precio y desactiva las opciones incompatibles. Los clientes quieren deshacer cambios y comparar dos configuraciones guardadas antes de pedir la cotización.
warningEl problema sin el patrón
Para guardar una versión, el historial copia los campos del configurador desde fuera, lo que obliga a hacerlos públicos. Así cualquier parte del código puede dejar el configurador en un estado inválido, como un motor eléctrico con caja manual.
check_circleCómo lo resuelve el patrón
El propio Configurador (el originador) crea un Memento con una instantánea de su estado y sabe restaurarse a partir de él. El Historial (el cuidador) guarda los mementos sin interpretarlos. El estado del configurador sigue siendo privado.
schemaDiagrama de clases
Diagrama interactivo: puedes acercar, mover el lienzo y pasar el cursor sobre cada clase para ver su detalle.
codeEl código, antes y después
// El historial necesita que todo sea público
historial.push({ modelo: config.modelo, motor: config.motor, accesorios: config.accesorios });
config.motor = 'electrico'; // cualquiera puede saltarse las reglasclass Memento { // instantánea opaca para quien la guarda
constructor(readonly estado: Readonly<EstadoConfig>, readonly fecha = new Date()) {}
}
class Configurador { // originador
private estado: EstadoConfig = configuracionBase();
elegirMotor(motor: Motor) { /* valida compatibilidad y recalcula el precio */ }
guardar(): Memento { return new Memento(structuredClone(this.estado)); }
restaurar(m: Memento) { this.estado = structuredClone(m.estado); }
}
class Historial { // cuidador: guarda, pero no interpreta
private pila: Memento[] = [];
constructor(private config: Configurador) {}
guardar() { this.pila.push(this.config.guardar()); }
deshacer() {
const memento = this.pila.pop();
if (memento) this.config.restaurar(memento);
}
}Ejemplos en TypeScript, simplificados para mostrar la idea: los tipos auxiliares (Pedido, Cliente…) se omiten.
Matiz importante
En lenguajes con clases anidadas privadas (Java, C#) el memento puede ser una clase interna del originador, y nadie más puede leer su contenido. En TypeScript se aproxima marcando el estado como de solo lectura y no usándolo fuera del originador.
thumb_upCuándo usarlo
- ✓Necesitas deshacer cambios, guardar versiones o puntos de restauración de un objeto.
- ✓Quieres volver al estado anterior si una operación de varios pasos falla a mitad de camino.
- ✓Copiar el estado desde fuera obligaría a exponer campos privados.
do_not_disturb_onCuándo no usarlo
- ✕El estado es grande y se guarda muy a menudo: la memoria crece rápido (considera guardar solo los cambios).
- ✕El estado incluye recursos que no se pueden copiar, como conexiones o archivos abiertos.
- ✕Nadie se encarga de descartar los mementos que ya no sirven: el cuidador debe controlar cuántos guarda y cuándo los borra, o el historial crecerá sin límite.
memoryPrincipios en juego
- •Encapsulamiento: el estado se guarda y se restaura sin exponerlo.
- •Responsabilidad única: el historial gestiona las versiones; el configurador, sus reglas.
hubPatrones relacionados
- •Command: un comando puede guardar un memento antes de ejecutarse para poder deshacer.
- •Prototype: en objetos simples, un clon puede funcionar como memento.
- •Iterator: un memento puede guardar la posición de un recorrido.
quizPon a prueba lo que leíste
Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.
code_blocksMemento en tu lenguaje
El mismo caso, implementado completo y de forma idiomática. Se puede copiar y ejecutar.
LO IDIOMÁTICO EN TYPESCRIPT: El estado vive en un campo privado # que nadie puede leer desde fuera. El memento expone el estado como Readonly y structuredClone hace la copia profunda al guardar y al restaurar.
type Motor = 'gasolina' | 'hibrido' | 'electrico';
type Caja = 'manual' | 'automatica';
interface EstadoConfig {
modelo: string;
motor: Motor;
caja: Caja;
accesorios: string[];
precio: number;
}
export class Memento {
constructor(readonly estado: Readonly<EstadoConfig>, readonly etiqueta: string) {}
}
export class Configurador {
#estado: EstadoConfig = { modelo: 'Sedán', motor: 'gasolina', caja: 'manual', accesorios: [], precio: 20000 };
elegirMotor(motor: Motor): void {
this.#estado.motor = motor;
if (motor === 'electrico') this.#estado.caja = 'automatica'; // regla: no hay eléctricos manuales
this.#recalcular();
}
agregarAccesorio(accesorio: string): void {
this.#estado.accesorios.push(accesorio);
this.#recalcular();
}
guardar(etiqueta: string): Memento {
return new Memento(structuredClone(this.#estado), etiqueta);
}
restaurar(memento: Memento): void {
this.#estado = structuredClone(memento.estado);
}
resumen(): string {
const e = this.#estado;
return `${e.modelo} ${e.motor}/${e.caja} [${e.accesorios.join(', ')}] ${e.precio} USD`;
}
#recalcular(): void {
const recargo = { gasolina: 0, hibrido: 4000, electrico: 9000 }[this.#estado.motor];
this.#estado.precio = 20000 + recargo + this.#estado.accesorios.length * 600;
}
}
export class Historial {
readonly #pila: Memento[] = [];
constructor(private readonly config: Configurador) {}
guardar(etiqueta: string): void {
this.#pila.push(this.config.guardar(etiqueta));
}
deshacer(): string | undefined {
const memento = this.#pila.pop();
if (memento) this.config.restaurar(memento);
return memento?.etiqueta;
}
}
// ── Uso ──
const config = new Configurador();
const historial = new Historial(config);
historial.guardar('base');
config.elegirMotor('electrico');
historial.guardar('eléctrico');
config.agregarAccesorio('Techo solar');
console.log(config.resumen()); // Sedán electrico/automatica [Techo solar] 29600 USD
console.log('Volver a:', historial.deshacer());
console.log(config.resumen()); // Sedán electrico/automatica [] 29000 USD
console.log('Volver a:', historial.deshacer());
console.log(config.resumen()); // Sedán gasolina/manual [] 20000 USDLO IDIOMÁTICO EN C# / .NET: Fuera del configurador, el memento solo existe como la interfaz pública IMemento (que muestra la etiqueta); la clase real es privada y está anidada dentro de él, así que nadie más puede leer el estado. Como el estado es un record inmutable, el memento puede guardarlo sin copiarlo.
var config = new Configurador();
var historial = new Historial(config);
historial.Guardar("base");
config.ElegirMotor("electrico");
historial.Guardar("eléctrico");
config.AgregarAccesorio("Techo solar");
Console.WriteLine(config.Resumen()); // Sedán electrico/automatica [Techo solar] 29600 USD
Console.WriteLine($"Volver a: {historial.Deshacer()}");
Console.WriteLine(config.Resumen()); // Sedán electrico/automatica [] 29000 USD
Console.WriteLine($"Volver a: {historial.Deshacer()}");
Console.WriteLine(config.Resumen()); // Sedán gasolina/manual [] 20000 USD
public interface IMemento
{
string Etiqueta { get; }
}
public class Configurador
{
private sealed record Estado(string Modelo, string Motor, string Caja, IReadOnlyList<string> Accesorios, int Precio);
private sealed record Instantanea(string Etiqueta, Estado Estado) : IMemento;
private static readonly Dictionary<string, int> Recargo = new() { ["gasolina"] = 0, ["hibrido"] = 4000, ["electrico"] = 9000 };
private Estado _estado = new("Sedán", "gasolina", "manual", [], 20000);
public void ElegirMotor(string motor)
{
if (!Recargo.ContainsKey(motor)) throw new ArgumentException($"Motor desconocido: {motor}");
var caja = motor == "electrico" ? "automatica" : _estado.Caja; // regla: no hay eléctricos manuales
_estado = Recalcular(_estado with { Motor = motor, Caja = caja });
}
public void AgregarAccesorio(string accesorio) =>
_estado = Recalcular(_estado with { Accesorios = [.. _estado.Accesorios, accesorio] });
public IMemento Guardar(string etiqueta) => new Instantanea(etiqueta, _estado);
public void Restaurar(IMemento memento) =>
_estado = memento is Instantanea instantanea
? instantanea.Estado
: throw new ArgumentException("Este memento no pertenece a un configurador");
public string Resumen() =>
$"{_estado.Modelo} {_estado.Motor}/{_estado.Caja} [{string.Join(", ", _estado.Accesorios)}] {_estado.Precio} USD";
private static Estado Recalcular(Estado e) => e with { Precio = 20000 + Recargo[e.Motor] + e.Accesorios.Count * 600 };
}
public class Historial(Configurador configurador)
{
private readonly Stack<IMemento> _pila = new();
public void Guardar(string etiqueta) => _pila.Push(configurador.Guardar(etiqueta));
public string? Deshacer()
{
if (!_pila.TryPop(out var memento)) return null;
configurador.Restaurar(memento);
return memento.Etiqueta;
}
}LO IDIOMÁTICO EN JAVA: Fuera del configurador, el memento solo existe como la interfaz Memento (que muestra la etiqueta); su implementación es un record privado anidado, así que nadie más puede leer el estado. Como el estado también es un record inmutable, el memento lo guarda sin copiarlo.
void main() {
var config = new Configurador();
var historial = new Historial(config);
historial.guardar("base");
config.elegirMotor("electrico");
historial.guardar("eléctrico");
config.agregarAccesorio("Techo solar");
IO.println(config.resumen()); // Sedán electrico/automatica [Techo solar] 29600 USD
IO.println("Volver a: " + historial.deshacer());
IO.println(config.resumen()); // Sedán electrico/automatica [] 29000 USD
IO.println("Volver a: " + historial.deshacer());
IO.println(config.resumen()); // Sedán gasolina/manual [] 20000 USD
}
interface Memento {
String etiqueta();
}
final class Configurador {
private record Estado(String modelo, String motor, String caja, List<String> accesorios, int precio) {}
private record Instantanea(String etiqueta, Estado estado) implements Memento {}
private static final Map<String, Integer> RECARGO = Map.of("gasolina", 0, "hibrido", 4000, "electrico", 9000);
private Estado estado = new Estado("Sedán", "gasolina", "manual", List.of(), 20000);
void elegirMotor(String motor) {
if (!RECARGO.containsKey(motor)) throw new IllegalArgumentException("Motor desconocido: " + motor);
var caja = motor.equals("electrico") ? "automatica" : estado.caja(); // regla: no hay eléctricos manuales
estado = recalcular(new Estado(estado.modelo(), motor, caja, estado.accesorios(), 0));
}
void agregarAccesorio(String accesorio) {
var accesorios = new ArrayList<>(estado.accesorios());
accesorios.add(accesorio);
estado = recalcular(new Estado(estado.modelo(), estado.motor(), estado.caja(), List.copyOf(accesorios), 0));
}
Memento guardar(String etiqueta) {
return new Instantanea(etiqueta, estado);
}
void restaurar(Memento memento) {
if (!(memento instanceof Instantanea instantanea)) {
throw new IllegalArgumentException("Este memento no pertenece a un configurador");
}
estado = instantanea.estado();
}
String resumen() {
return "%s %s/%s %s %d USD".formatted(estado.modelo(), estado.motor(), estado.caja(), estado.accesorios(), estado.precio());
}
private static Estado recalcular(Estado e) {
var precio = 20000 + RECARGO.get(e.motor()) + e.accesorios().size() * 600;
return new Estado(e.modelo(), e.motor(), e.caja(), e.accesorios(), precio);
}
}
final class Historial {
private final Configurador configurador;
private final Deque<Memento> pila = new ArrayDeque<>();
Historial(Configurador configurador) {
this.configurador = configurador;
}
void guardar(String etiqueta) {
pila.push(configurador.guardar(etiqueta));
}
String deshacer() {
var memento = pila.poll();
if (memento == null) return null;
configurador.restaurar(memento);
return memento.etiqueta();
}
}LO IDIOMÁTICO EN JAVASCRIPT: El memento es un objeto congelado que solo muestra su etiqueta; el estado real se guarda en un WeakMap privado del módulo, la forma clásica de JavaScript de asociar datos ocultos a un objeto. Quien guarda los mementos no puede leer ni modificar su contenido.
const estadosGuardados = new WeakMap(); // memento → copia del estado (invisible desde fuera)
const RECARGO = { gasolina: 0, hibrido: 4000, electrico: 9000 };
export function crearConfigurador() {
let estado = { modelo: 'Sedán', motor: 'gasolina', caja: 'manual', accesorios: [], precio: 20000 };
const recalcular = () => {
estado.precio = 20000 + RECARGO[estado.motor] + estado.accesorios.length * 600;
};
return {
elegirMotor(motor) {
estado.motor = motor;
if (motor === 'electrico') estado.caja = 'automatica'; // regla: no hay eléctricos manuales
recalcular();
},
agregarAccesorio(accesorio) {
estado.accesorios.push(accesorio);
recalcular();
},
guardar(etiqueta) {
const memento = Object.freeze({ etiqueta });
estadosGuardados.set(memento, structuredClone(estado));
return memento;
},
restaurar(memento) {
estado = structuredClone(estadosGuardados.get(memento));
},
resumen() {
return `${estado.modelo} ${estado.motor}/${estado.caja} [${estado.accesorios.join(', ')}] ${estado.precio} USD`;
},
};
}
export function crearHistorial(configurador) {
const pila = [];
return {
guardar: (etiqueta) => pila.push(configurador.guardar(etiqueta)),
deshacer() {
const memento = pila.pop();
if (memento) configurador.restaurar(memento);
return memento?.etiqueta;
},
};
}
// ── Uso ──
const config = crearConfigurador();
const historial = crearHistorial(config);
historial.guardar('base');
config.elegirMotor('electrico');
historial.guardar('eléctrico');
config.agregarAccesorio('Techo solar');
console.log(config.resumen()); // Sedán electrico/automatica [Techo solar] 29600 USD
console.log('Volver a:', historial.deshacer());
console.log(config.resumen()); // Sedán electrico/automatica [] 29000 USD
console.log('Volver a:', historial.deshacer());
console.log(config.resumen()); // Sedán gasolina/manual [] 20000 USDLO IDIOMÁTICO EN PYTHON: Python no tiene campos privados de verdad: se usa la convención del guion bajo (_estado) y el memento es una dataclass(frozen=True) que oculta el estado en su repr. copy.deepcopy hace la copia profunda al guardar y al restaurar.
import copy
from dataclasses import dataclass, field
from typing import Literal
Motor = Literal["gasolina", "hibrido", "electrico"]
RECARGO = {"gasolina": 0, "hibrido": 4000, "electrico": 9000}
@dataclass
class EstadoConfig:
modelo: str = "Sedán"
motor: Motor = "gasolina"
caja: str = "manual"
accesorios: list[str] = field(default_factory=list)
precio: int = 20000
@dataclass(frozen=True)
class Memento:
etiqueta: str
_estado: EstadoConfig = field(repr=False) # "privado": solo lo usa el configurador
class Configurador:
def __init__(self) -> None:
self._estado = EstadoConfig()
def elegir_motor(self, motor: Motor) -> None:
self._estado.motor = motor
if motor == "electrico":
self._estado.caja = "automatica" # regla: no hay eléctricos manuales
self._recalcular()
def agregar_accesorio(self, accesorio: str) -> None:
self._estado.accesorios.append(accesorio)
self._recalcular()
def guardar(self, etiqueta: str) -> Memento:
return Memento(etiqueta, copy.deepcopy(self._estado))
def restaurar(self, memento: Memento) -> None:
self._estado = copy.deepcopy(memento._estado)
def resumen(self) -> str:
e = self._estado
return f"{e.modelo} {e.motor}/{e.caja} [{', '.join(e.accesorios)}] {e.precio} USD"
def _recalcular(self) -> None:
self._estado.precio = 20000 + RECARGO[self._estado.motor] + len(self._estado.accesorios) * 600
class Historial:
def __init__(self, configurador: Configurador) -> None:
self._configurador = configurador
self._pila: list[Memento] = []
def guardar(self, etiqueta: str) -> None:
self._pila.append(self._configurador.guardar(etiqueta))
def deshacer(self) -> str | None:
if not self._pila:
return None
memento = self._pila.pop()
self._configurador.restaurar(memento)
return memento.etiqueta
if __name__ == "__main__":
config = Configurador()
historial = Historial(config)
historial.guardar("base")
config.elegir_motor("electrico")
historial.guardar("eléctrico")
config.agregar_accesorio("Techo solar")
print(config.resumen()) # Sedán electrico/automatica [Techo solar] 29600 USD
print("Volver a:", historial.deshacer())
print(config.resumen()) # Sedán electrico/automatica [] 29000 USD
print("Volver a:", historial.deshacer())
print(config.resumen()) # Sedán gasolina/manual [] 20000 USD
print(config.guardar("prueba")) # Memento(etiqueta='prueba'): el estado no se muestraLO IDIOMÁTICO EN GO: En Go, los campos en minúscula no son visibles fuera del paquete: el Memento exporta solo su etiqueta y guarda el estado en un campo privado. slices.Clone copia los accesorios para que el memento no comparta el slice con el configurador.
package main
import (
"fmt"
"slices"
)
type estadoConfig struct {
modelo, motor, caja string
accesorios []string
precio int
}
func (e estadoConfig) copiar() estadoConfig {
e.accesorios = slices.Clone(e.accesorios)
return e
}
type Memento struct {
Etiqueta string
estado estadoConfig // privado: fuera del paquete nadie puede leerlo
}
var recargo = map[string]int{"gasolina": 0, "hibrido": 4000, "electrico": 9000}
type Configurador struct{ estado estadoConfig }
func NuevoConfigurador() *Configurador {
return &Configurador{estadoConfig{modelo: "Sedán", motor: "gasolina", caja: "manual", precio: 20000}}
}
func (c *Configurador) ElegirMotor(motor string) error {
if _, existe := recargo[motor]; !existe {
return fmt.Errorf("motor desconocido: %s", motor)
}
c.estado.motor = motor
if motor == "electrico" {
c.estado.caja = "automatica" // regla: no hay eléctricos manuales
}
c.recalcular()
return nil
}
func (c *Configurador) AgregarAccesorio(accesorio string) {
c.estado.accesorios = append(c.estado.accesorios, accesorio)
c.recalcular()
}
func (c *Configurador) Guardar(etiqueta string) Memento { return Memento{etiqueta, c.estado.copiar()} }
func (c *Configurador) Restaurar(m Memento) { c.estado = m.estado.copiar() }
func (c *Configurador) Resumen() string {
e := c.estado
return fmt.Sprintf("%s %s/%s %v %d USD", e.modelo, e.motor, e.caja, e.accesorios, e.precio)
}
func (c *Configurador) recalcular() {
c.estado.precio = 20000 + recargo[c.estado.motor] + len(c.estado.accesorios)*600
}
type Historial struct {
configurador *Configurador
pila []Memento
}
func (h *Historial) Guardar(etiqueta string) {
h.pila = append(h.pila, h.configurador.Guardar(etiqueta))
}
func (h *Historial) Deshacer() (string, bool) {
if len(h.pila) == 0 {
return "", false
}
ultimo := h.pila[len(h.pila)-1]
h.pila = h.pila[:len(h.pila)-1]
h.configurador.Restaurar(ultimo)
return ultimo.Etiqueta, true
}
func main() {
config := NuevoConfigurador()
historial := &Historial{configurador: config}
historial.Guardar("base")
_ = config.ElegirMotor("electrico")
historial.Guardar("eléctrico")
config.AgregarAccesorio("Techo solar")
fmt.Println(config.Resumen()) // Sedán electrico/automatica [Techo solar] 29600 USD
etiqueta, _ := historial.Deshacer()
fmt.Println("Volver a:", etiqueta)
fmt.Println(config.Resumen()) // Sedán electrico/automatica [] 29000 USD
etiqueta, _ = historial.Deshacer()
fmt.Println("Volver a:", etiqueta)
fmt.Println(config.Resumen()) // Sedán gasolina/manual [] 20000 USD
}LO IDIOMÁTICO EN RUST: La privacidad de Rust es por módulo: fuera de mod configurador, el campo estado del Memento no se puede leer ni construir, solo su etiqueta. #[derive(Clone)] copia el estado al guardar y al restaurar, y el Vec de mementos hace de historial.
mod configurador {
#[derive(Clone)]
struct Estado {
modelo: &'static str,
motor: &'static str,
caja: &'static str,
accesorios: Vec<String>,
precio: u32,
}
pub struct Memento {
pub etiqueta: String,
estado: Estado, // privado: solo el configurador lo usa
}
pub struct Configurador {
estado: Estado,
}
impl Default for Configurador {
fn default() -> Self {
Self {
estado: Estado {
modelo: "Sedán",
motor: "gasolina",
caja: "manual",
accesorios: Vec::new(),
precio: 20_000,
},
}
}
}
impl Configurador {
pub fn elegir_motor(&mut self, motor: &'static str) -> Result<(), String> {
if !matches!(motor, "gasolina" | "hibrido" | "electrico") {
return Err(format!("motor desconocido: {motor}"));
}
self.estado.motor = motor;
if motor == "electrico" {
self.estado.caja = "automatica"; // regla: no hay eléctricos manuales
}
self.recalcular();
Ok(())
}
pub fn agregar_accesorio(&mut self, accesorio: &str) {
self.estado.accesorios.push(accesorio.to_string());
self.recalcular();
}
pub fn guardar(&self, etiqueta: &str) -> Memento {
Memento {
etiqueta: etiqueta.to_string(),
estado: self.estado.clone(),
}
}
pub fn restaurar(&mut self, memento: &Memento) {
self.estado = memento.estado.clone();
}
pub fn resumen(&self) -> String {
let e = &self.estado;
format!(
"{} {}/{} {:?} {} USD",
e.modelo, e.motor, e.caja, e.accesorios, e.precio
)
}
fn recalcular(&mut self) {
let recargo = match self.estado.motor {
"hibrido" => 4_000,
"electrico" => 9_000,
_ => 0,
};
let accesorios = u32::try_from(self.estado.accesorios.len()).unwrap_or(u32::MAX);
self.estado.precio = 20_000 + recargo + accesorios * 600;
}
}
}
use configurador::{Configurador, Memento};
fn main() -> Result<(), String> {
let mut config = Configurador::default();
let mut historial: Vec<Memento> = Vec::new();
historial.push(config.guardar("base"));
config.elegir_motor("electrico")?;
historial.push(config.guardar("eléctrico"));
config.agregar_accesorio("Techo solar");
println!("{}", config.resumen()); // Sedán electrico/automatica ["Techo solar"] 29600 USD
while let Some(memento) = historial.pop() {
config.restaurar(&memento);
println!("Volver a {}: {}", memento.etiqueta, config.resumen());
}
// Volver a eléctrico: Sedán electrico/automatica [] 29000 USD
// Volver a base: Sedán gasolina/manual [] 20000 USD
Ok(())
}LO IDIOMÁTICO EN PHP: En PHP los arrays se copian por valor, así que guardar el estado en un array es ya una copia segura. Como PHP no tiene clases anidadas, el estado del memento es privado y solo el configurador lo lee, a través de un closure ligado a la clase del memento (Closure::bind).
<?php
declare(strict_types=1);
final readonly class Memento
{
/** @param array<string, mixed> $estado */
public function __construct(public string $etiqueta, private array $estado) {}
}
final class Configurador
{
private const RECARGO = ['gasolina' => 0, 'hibrido' => 4000, 'electrico' => 9000];
/** @var array{modelo: string, motor: string, caja: string, accesorios: list<string>, precio: int} */
private array $estado = ['modelo' => 'Sedán', 'motor' => 'gasolina', 'caja' => 'manual', 'accesorios' => [], 'precio' => 20000];
public function elegirMotor(string $motor): void
{
if (!isset(self::RECARGO[$motor])) throw new InvalidArgumentException("Motor desconocido: {$motor}");
$this->estado['motor'] = $motor;
if ($motor === 'electrico') $this->estado['caja'] = 'automatica'; // regla: no hay eléctricos manuales
$this->recalcular();
}
public function agregarAccesorio(string $accesorio): void
{
$this->estado['accesorios'][] = $accesorio;
$this->recalcular();
}
public function guardar(string $etiqueta): Memento
{
return new Memento($etiqueta, $this->estado); // el array se copia
}
public function restaurar(Memento $memento): void
{
// Solo el configurador sabe leer el estado privado del memento
$this->estado = Closure::bind(fn () => $this->estado, $memento, Memento::class)();
}
public function resumen(): string
{
['modelo' => $modelo, 'motor' => $motor, 'caja' => $caja, 'accesorios' => $accesorios, 'precio' => $precio] = $this->estado;
return sprintf('%s %s/%s [%s] %d USD', $modelo, $motor, $caja, implode(', ', $accesorios), $precio);
}
private function recalcular(): void
{
$this->estado['precio'] = 20000 + self::RECARGO[$this->estado['motor']] + count($this->estado['accesorios']) * 600;
}
}
$config = new Configurador();
$historial = [];
$historial[] = $config->guardar('base');
$config->elegirMotor('electrico');
$historial[] = $config->guardar('eléctrico');
$config->agregarAccesorio('Techo solar');
echo $config->resumen(), "\n"; // Sedán electrico/automatica [Techo solar] 29600 USD
while ($memento = array_pop($historial)) {
$config->restaurar($memento);
echo "Volver a {$memento->etiqueta}: {$config->resumen()}\n";
}
// Volver a eléctrico: Sedán electrico/automatica [] 29000 USD
// Volver a base: Sedán gasolina/manual [] 20000 USD