Mediator
Mediador
Reduce las dependencias entre objetos haciendo que se comuniquen a través de un objeto mediador en vez de directamente.
“Mis componentes se llaman todos entre sí y ya es una telaraña.”
workEl caso real
El panel de filtros de un marketplace tiene categoría, marca, rango de precio, envío gratis, un contador de resultados y un botón "Limpiar". Al elegir una categoría cambian las marcas disponibles; al elegir una marca se ajusta el rango de precios; cualquier cambio actualiza el contador; "Limpiar" reinicia todo.
warningEl problema sin el patrón
Cada componente conoce y llama directamente a los demás. Con seis componentes hay decenas de conexiones cruzadas, y reutilizar el selector de marcas en otra pantalla es imposible porque arrastra a todos los demás.
check_circleCómo lo resuelve el patrón
Los componentes no se hablan entre sí: avisan al mediador (PanelFiltros) cuando algo cambia. El mediador conoce a todos y decide qué actualizar. Cada componente depende solo del mediador y se puede reutilizar en otro panel.
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
selectorCategoria.onChange = (categoria) => {
selectorMarca.cargarMarcas(categoria);
rangoPrecio.reiniciar();
contador.actualizar(); // la categoría conoce a todos...
};
selectorMarca.onChange = (marca) => {
rangoPrecio.ajustarA(marca);
contador.actualizar(); // ...y la marca también
};interface Mediador {
notificar(origen: Componente, evento: string): void;
}
class PanelFiltros implements Mediador {
constructor(
private categoria: SelectorCategoria,
private marca: SelectorMarca,
private precio: RangoPrecio,
private contador: ContadorResultados,
) {}
notificar(origen: Componente, evento: string) {
if (evento === 'limpiar') [this.categoria, this.marca, this.precio].forEach((c) => c.reiniciar());
if (origen === this.categoria) {
this.marca.cargarMarcas(this.categoria.valor);
this.precio.reiniciar();
}
if (origen === this.marca) this.precio.ajustarA(this.marca.valor);
this.contador.actualizar();
}
}
// Cada componente solo conoce al mediador
selectorMarca.onChange = () => panel.notificar(selectorMarca, 'cambio');Ejemplos en TypeScript, simplificados para mostrar la idea: los tipos auxiliares (Pedido, Cliente…) se omiten.
Matiz importante
Librerías como MediatR (.NET) toman el nombre, pero funcionan más bien como un despachador de mensajes dentro del proceso (cada petición va a su manejador) que como el Mediator clásico, que coordina a objetos que colaboran entre sí.
thumb_upCuándo usarlo
- ✓Muchos objetos se comunican de formas complejas y cambiar uno obliga a tocar varios.
- ✓Quieres reutilizar componentes que hoy están atados a otros.
do_not_disturb_onCuándo no usarlo
- ✕Solo hay dos o tres objetos con relaciones simples.
- ✕El mediador crece hasta saberlo todo: vigílalo para que no se convierta en una clase Dios.
memoryPrincipios en juego
- •Bajo acoplamiento: los componentes dependen del mediador, no unos de otros.
- •Responsabilidad única: la coordinación vive en un solo lugar.
hubPatrones relacionados
- •Observer: los componentes suelen avisar al mediador mediante eventos; Observer difunde avisos, Mediator coordina.
- •Facade: también centraliza, pero el subsistema no conoce a la fachada; aquí los componentes sí conocen al mediador.
- •Chain of Responsibility y Command: son otras formas de conectar a quien envía con quien recibe.
quizPon a prueba lo que leíste
Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.
code_blocksMediator en tu lenguaje
El mismo caso, implementado completo y de forma idiomática. Se puede copiar y ejecutar.
LO IDIOMÁTICO EN TYPESCRIPT: Los eventos se tipan con una unión de literales ('cambio' | 'limpiar'), y ?. permite que un componente avise aunque todavía no tenga mediador. Solo el mediador conoce a todos.
type Evento = 'cambio' | 'limpiar';
const catalogo: Record<string, string[]> = {
laptops: ['Premium', 'Económica'],
celulares: ['Premium'],
};
export interface Mediador {
notificar(origen: Componente, evento: Evento): void;
}
abstract class Componente {
mediador?: Mediador;
protected avisar(evento: Evento = 'cambio') {
this.mediador?.notificar(this, evento);
}
}
class SelectorCategoria extends Componente {
valor = '';
elegir(categoria: string) { this.valor = categoria; this.avisar(); }
reiniciar() { this.valor = ''; }
}
class SelectorMarca extends Componente {
opciones: string[] = [];
valor = '';
cargarMarcas(categoria: string) { this.opciones = catalogo[categoria] ?? []; this.valor = ''; }
elegir(marca: string) { this.valor = marca; this.avisar(); }
reiniciar() { this.opciones = []; this.valor = ''; }
}
class RangoPrecio extends Componente {
min = 0;
max = Infinity;
ajustarA(marca: string) { [this.min, this.max] = marca === 'Premium' ? [500, 3000] : [0, 800]; }
reiniciar() { this.min = 0; this.max = Infinity; }
}
class ContadorResultados extends Componente {
texto = '';
actualizar(total: number) { this.texto = `${total} resultados`; }
}
class BotonLimpiar extends Componente {
pulsar() { this.avisar('limpiar'); }
}
export class PanelFiltros implements Mediador {
constructor(
readonly categoria = new SelectorCategoria(),
readonly marca = new SelectorMarca(),
readonly precio = new RangoPrecio(),
readonly contador = new ContadorResultados(),
readonly limpiar = new BotonLimpiar(),
) {
for (const c of [categoria, marca, precio, contador, limpiar]) c.mediador = this;
}
notificar(origen: Componente, evento: Evento): void {
if (evento === 'limpiar') {
this.categoria.reiniciar();
this.marca.reiniciar();
this.precio.reiniciar();
} else if (origen === this.categoria) {
this.marca.cargarMarcas(this.categoria.valor);
this.precio.reiniciar();
} else if (origen === this.marca) {
this.precio.ajustarA(this.marca.valor);
}
this.contador.actualizar(this.#contarResultados());
}
#contarResultados(): number {
if (!this.categoria.valor) return 120;
return this.marca.valor ? 8 : 25;
}
}
// ── Uso ──
const panel = new PanelFiltros();
panel.categoria.elegir('laptops');
console.log(panel.marca.opciones, panel.contador.texto); // [ 'Premium', 'Económica' ] 25 resultados
panel.marca.elegir('Premium');
console.log(panel.precio.min, panel.precio.max, panel.contador.texto); // 500 3000 8 resultados
panel.limpiar.pulsar();
console.log(panel.contador.texto); // 120 resultadosLO IDIOMÁTICO EN C# / .NET: El mediador decide con un switch de patrones de tipo (case SelectorCategoria c) qué hacer según quién avisó. Ojo: librerías como MediatR toman el nombre, pero funcionan como un despachador de mensajes; esto es el Mediator clásico, que coordina componentes que colaboran entre sí.
var panel = new PanelFiltros();
panel.Categoria.Elegir("laptops");
Console.WriteLine($"{string.Join(", ", panel.Marca.Opciones)} · {panel.Resultados}"); // Premium, Económica · 25 resultados
panel.Marca.Elegir("Premium");
Console.WriteLine($"{panel.Precio} · {panel.Resultados}"); // (500, 3000) · 8 resultados
panel.Limpiar.Pulsar();
Console.WriteLine(panel.Resultados); // 120 resultados
public interface IMediador
{
void Notificar(object origen);
}
public abstract class Componente(IMediador mediador)
{
protected void Avisar() => mediador.Notificar(this);
}
public class SelectorCategoria(IMediador mediador) : Componente(mediador)
{
public string Valor { get; set; } = "";
public void Elegir(string categoria) { Valor = categoria; Avisar(); }
}
public class SelectorMarca(IMediador mediador) : Componente(mediador)
{
public string Valor { get; set; } = "";
public string[] Opciones { get; set; } = [];
public void Elegir(string marca) { Valor = marca; Avisar(); }
}
public class BotonLimpiar(IMediador mediador) : Componente(mediador)
{
public void Pulsar() => Avisar();
}
public class PanelFiltros : IMediador
{
private static readonly Dictionary<string, string[]> Catalogo = new()
{
["laptops"] = ["Premium", "Económica"],
["celulares"] = ["Premium"],
};
private static readonly (decimal Min, decimal Max) SinLimite = (0, decimal.MaxValue);
public SelectorCategoria Categoria { get; }
public SelectorMarca Marca { get; }
public BotonLimpiar Limpiar { get; }
public (decimal Min, decimal Max) Precio { get; private set; } = SinLimite;
public string Resultados { get; private set; } = "";
public PanelFiltros()
{
Categoria = new SelectorCategoria(this);
Marca = new SelectorMarca(this);
Limpiar = new BotonLimpiar(this);
}
public void Notificar(object origen)
{
switch (origen)
{
case BotonLimpiar:
Categoria.Valor = Marca.Valor = "";
Marca.Opciones = [];
Precio = SinLimite;
break;
case SelectorCategoria categoria:
Marca.Opciones = Catalogo.GetValueOrDefault(categoria.Valor, []);
Marca.Valor = "";
Precio = SinLimite;
break;
case SelectorMarca marca:
Precio = marca.Valor == "Premium" ? (500, 3000) : (0, 800);
break;
}
var total = Categoria.Valor == "" ? 120 : Marca.Valor == "" ? 25 : 8;
Resultados = $"{total} resultados";
}
}LO IDIOMÁTICO EN JAVA: Los componentes forman una interfaz sealed, así que el mediador puede decidir con un switch de patrones de tipo (case SelectorCategoria c) y el compilador comprueba que trata todos los casos. Cada componente solo conoce al mediador.
void main() {
var panel = new PanelFiltros();
panel.categoria.elegir("laptops");
IO.println(panel.marca.opciones + " · " + panel.resultados); // [Premium, Económica] · 25 resultados
panel.marca.elegir("Premium");
IO.println(panel.precio + " · " + panel.resultados); // RangoPrecio[min=500.0, max=3000.0] · 8 resultados
panel.limpiar.pulsar();
IO.println(panel.resultados); // 120 resultados
}
interface Mediador {
void notificar(Componente origen);
}
sealed interface Componente permits SelectorCategoria, SelectorMarca, BotonLimpiar {}
final class SelectorCategoria implements Componente {
private final Mediador mediador;
String valor = "";
SelectorCategoria(Mediador mediador) { this.mediador = mediador; }
void elegir(String categoria) { valor = categoria; mediador.notificar(this); }
}
final class SelectorMarca implements Componente {
private final Mediador mediador;
String valor = "";
List<String> opciones = List.of();
SelectorMarca(Mediador mediador) { this.mediador = mediador; }
void elegir(String marca) { valor = marca; mediador.notificar(this); }
}
final class BotonLimpiar implements Componente {
private final Mediador mediador;
BotonLimpiar(Mediador mediador) { this.mediador = mediador; }
void pulsar() { mediador.notificar(this); }
}
record RangoPrecio(double min, double max) {
static final RangoPrecio SIN_LIMITE = new RangoPrecio(0, Double.MAX_VALUE);
}
final class PanelFiltros implements Mediador {
private static final Map<String, List<String>> CATALOGO =
Map.of("laptops", List.of("Premium", "Económica"), "celulares", List.of("Premium"));
final SelectorCategoria categoria = new SelectorCategoria(this);
final SelectorMarca marca = new SelectorMarca(this);
final BotonLimpiar limpiar = new BotonLimpiar(this);
RangoPrecio precio = RangoPrecio.SIN_LIMITE;
String resultados = "";
@Override
public void notificar(Componente origen) {
switch (origen) {
case BotonLimpiar b -> {
categoria.valor = marca.valor = "";
marca.opciones = List.of();
precio = RangoPrecio.SIN_LIMITE;
}
case SelectorCategoria c -> {
marca.opciones = CATALOGO.getOrDefault(c.valor, List.of());
marca.valor = "";
precio = RangoPrecio.SIN_LIMITE;
}
case SelectorMarca m -> precio = m.valor.equals("Premium") ? new RangoPrecio(500, 3000) : new RangoPrecio(0, 800);
}
var total = categoria.valor.isEmpty() ? 120 : marca.valor.isEmpty() ? 25 : 8;
resultados = total + " resultados";
}
}LO IDIOMÁTICO EN JAVASCRIPT: El mediador extiende EventTarget, la misma API de eventos del navegador (también disponible en Node). Los componentes solo emiten eventos hacia el panel con dispatchEvent; el panel escucha y decide qué actualizar. Ningún componente conoce a otro.
const catalogo = { laptops: ['Premium', 'Económica'], celulares: ['Premium'] };
class Componente {
constructor(panel) { this.panel = panel; }
avisar(tipo = 'cambio') {
this.panel.dispatchEvent(new CustomEvent(tipo, { detail: this }));
}
}
class SelectorCategoria extends Componente {
valor = '';
elegir(categoria) { this.valor = categoria; this.avisar(); }
}
class SelectorMarca extends Componente {
opciones = [];
valor = '';
elegir(marca) { this.valor = marca; this.avisar(); }
}
class RangoPrecio extends Componente {
min = 0;
max = Infinity;
}
export class PanelFiltros extends EventTarget {
constructor() {
super();
this.categoria = new SelectorCategoria(this);
this.marca = new SelectorMarca(this);
this.precio = new RangoPrecio(this);
this.resultados = '';
this.addEventListener('cambio', (evento) => {
const origen = /** @type {CustomEvent} */ (evento).detail;
if (origen === this.categoria) {
this.marca.opciones = catalogo[this.categoria.valor] ?? [];
this.marca.valor = '';
[this.precio.min, this.precio.max] = [0, Infinity];
} else if (origen === this.marca) {
[this.precio.min, this.precio.max] = this.marca.valor === 'Premium' ? [500, 3000] : [0, 800];
}
this.#actualizarResultados();
});
this.addEventListener('limpiar', () => {
this.categoria.valor = '';
this.marca.valor = '';
this.marca.opciones = [];
[this.precio.min, this.precio.max] = [0, Infinity];
this.#actualizarResultados();
});
}
limpiar() { this.dispatchEvent(new Event('limpiar')); }
#actualizarResultados() {
const total = !this.categoria.valor ? 120 : this.marca.valor ? 8 : 25;
this.resultados = `${total} resultados`;
}
}
// ── Uso ──
const panel = new PanelFiltros();
panel.categoria.elegir('laptops');
console.log(panel.marca.opciones, panel.resultados); // [ 'Premium', 'Económica' ] 25 resultados
panel.marca.elegir('Premium');
console.log(panel.precio.min, panel.precio.max, panel.resultados); // 500 3000 8 resultados
panel.limpiar();
console.log(panel.resultados); // 120 resultadosLO IDIOMÁTICO EN PYTHON: El mediador decide qué hacer con match sobre la pareja (evento, origen): los patrones de clase como SelectorCategoria() comprueban el tipo del componente que avisó. Los componentes solo conocen al mediador, a través de un Protocol.
from typing import Protocol
CATALOGO = {"laptops": ("Premium", "Económica"), "celulares": ("Premium",)}
class Mediador(Protocol):
def notificar(self, origen: object, evento: str) -> None: ...
class Componente:
def __init__(self, mediador: Mediador) -> None:
self._mediador = mediador
def avisar(self, evento: str = "cambio") -> None:
self._mediador.notificar(self, evento)
class SelectorCategoria(Componente):
valor = ""
def elegir(self, categoria: str) -> None:
self.valor = categoria
self.avisar()
class SelectorMarca(Componente):
valor = ""
opciones: tuple[str, ...] = () # tupla: un atributo de clase mutable se compartiría entre instancias
def elegir(self, marca: str) -> None:
self.valor = marca
self.avisar()
class RangoPrecio(Componente):
rango: tuple[float, float] = (0, float("inf"))
class BotonLimpiar(Componente):
def pulsar(self) -> None:
self.avisar("limpiar")
class PanelFiltros:
def __init__(self) -> None:
self.categoria = SelectorCategoria(self)
self.marca = SelectorMarca(self)
self.precio = RangoPrecio(self)
self.limpiar = BotonLimpiar(self)
self.resultados = ""
def notificar(self, origen: object, evento: str) -> None:
match evento, origen:
case "limpiar", _:
self.categoria.valor = self.marca.valor = ""
self.marca.opciones = ()
self.precio.rango = (0, float("inf"))
case "cambio", SelectorCategoria(valor=categoria):
self.marca.opciones = CATALOGO.get(categoria, ())
self.marca.valor = ""
self.precio.rango = (0, float("inf"))
case "cambio", SelectorMarca(valor=marca):
self.precio.rango = (500, 3000) if marca == "Premium" else (0, 800)
self._actualizar_resultados()
def _actualizar_resultados(self) -> None:
total = 120 if not self.categoria.valor else 8 if self.marca.valor else 25
self.resultados = f"{total} resultados"
if __name__ == "__main__":
panel = PanelFiltros()
panel.categoria.elegir("laptops")
print(panel.marca.opciones, panel.resultados) # ('Premium', 'Económica') 25 resultados
panel.marca.elegir("Premium")
print(panel.precio.rango, panel.resultados) # (500, 3000) 8 resultados
panel.limpiar.pulsar()
print(panel.resultados) # 120 resultadosLO IDIOMÁTICO EN GO: Los componentes guardan una referencia a la interfaz Mediador, y el mediador decide qué hacer con un "type switch" (switch o := origen.(type)), que distingue el tipo concreto del componente que avisó. Ningún componente conoce a otro.
package main
import (
"fmt"
"math"
)
var catalogo = map[string][]string{"laptops": {"Premium", "Económica"}, "celulares": {"Premium"}}
type Mediador interface{ Notificar(origen any) }
type SelectorCategoria struct {
mediador Mediador
Valor string
}
func (s *SelectorCategoria) Elegir(categoria string) {
s.Valor = categoria
s.mediador.Notificar(s)
}
type SelectorMarca struct {
mediador Mediador
Valor string
Opciones []string
}
func (s *SelectorMarca) Elegir(marca string) {
s.Valor = marca
s.mediador.Notificar(s)
}
type BotonLimpiar struct{ mediador Mediador }
func (b *BotonLimpiar) Pulsar() { b.mediador.Notificar(b) }
type RangoPrecio struct{ Min, Max float64 }
var sinLimite = RangoPrecio{0, math.Inf(1)}
type PanelFiltros struct {
Categoria *SelectorCategoria
Marca *SelectorMarca
Limpiar *BotonLimpiar
Precio RangoPrecio
Resultados string
}
func NuevoPanel() *PanelFiltros {
p := &PanelFiltros{Precio: sinLimite}
p.Categoria = &SelectorCategoria{mediador: p}
p.Marca = &SelectorMarca{mediador: p}
p.Limpiar = &BotonLimpiar{mediador: p}
return p
}
func (p *PanelFiltros) Notificar(origen any) {
switch o := origen.(type) {
case *BotonLimpiar:
p.Categoria.Valor, p.Marca.Valor, p.Marca.Opciones = "", "", nil
p.Precio = sinLimite
case *SelectorCategoria:
p.Marca.Opciones, p.Marca.Valor = catalogo[o.Valor], ""
p.Precio = sinLimite
case *SelectorMarca:
if o.Valor == "Premium" {
p.Precio = RangoPrecio{500, 3000}
} else {
p.Precio = RangoPrecio{0, 800}
}
}
p.actualizarResultados()
}
func (p *PanelFiltros) actualizarResultados() {
total := 120
if p.Categoria.Valor != "" {
total = 25
if p.Marca.Valor != "" {
total = 8
}
}
p.Resultados = fmt.Sprintf("%d resultados", total)
}
func main() {
panel := NuevoPanel()
panel.Categoria.Elegir("laptops")
fmt.Println(panel.Marca.Opciones, panel.Resultados) // [Premium Económica] 25 resultados
panel.Marca.Elegir("Premium")
fmt.Println(panel.Precio, panel.Resultados) // {500 3000} 8 resultados
panel.Limpiar.Pulsar()
fmt.Println(panel.Resultados) // 120 resultados
}LO IDIOMÁTICO EN RUST: Con el sistema de propiedad de Rust, los componentes no guardan referencias cruzadas entre sí (ni hacia el mediador): el mediador es dueño de todos ellos y recibe eventos, que son un enum. Cada componente solo produce eventos y el mediador decide con match qué actualizar.
enum Evento {
CategoriaElegida(&'static str),
MarcaElegida(&'static str),
Limpiar,
}
#[derive(Default)]
struct SelectorCategoria {
valor: Option<&'static str>,
}
impl SelectorCategoria {
fn elegir(categoria: &'static str) -> Evento {
Evento::CategoriaElegida(categoria)
}
}
#[derive(Default)]
struct SelectorMarca {
valor: Option<&'static str>,
opciones: Vec<&'static str>,
}
impl SelectorMarca {
fn elegir(marca: &'static str) -> Evento {
Evento::MarcaElegida(marca)
}
}
#[derive(Default)]
struct PanelFiltros {
categoria: SelectorCategoria,
marca: SelectorMarca,
precio: Option<(u32, u32)>,
resultados: String,
}
impl PanelFiltros {
fn notificar(&mut self, evento: Evento) {
match evento {
Evento::Limpiar => {
self.categoria = SelectorCategoria::default();
self.marca = SelectorMarca::default();
self.precio = None;
}
Evento::CategoriaElegida(categoria) => {
self.categoria.valor = Some(categoria);
self.marca = SelectorMarca {
valor: None,
opciones: match categoria {
"laptops" => vec!["Premium", "Económica"],
"celulares" => vec!["Premium"],
_ => vec![],
},
};
self.precio = None;
}
Evento::MarcaElegida(marca) => {
self.marca.valor = Some(marca);
self.precio = Some(if marca == "Premium" {
(500, 3000)
} else {
(0, 800)
});
}
}
let total = match (self.categoria.valor, self.marca.valor) {
(None, _) => 120,
(Some(_), None) => 25,
(Some(_), Some(_)) => 8,
};
self.resultados = format!("{total} resultados");
}
}
fn main() {
let mut panel = PanelFiltros::default();
panel.notificar(SelectorCategoria::elegir("laptops"));
println!("{:?} · {}", panel.marca.opciones, panel.resultados); // ["Premium", "Económica"] · 25 resultados
panel.notificar(SelectorMarca::elegir("Premium"));
println!("{:?} · {}", panel.precio, panel.resultados); // Some((500, 3000)) · 8 resultados
panel.notificar(Evento::Limpiar);
println!("{}", panel.resultados); // 120 resultados
}LO IDIOMÁTICO EN PHP: El mediador decide qué hacer con match (true) y comprobaciones instanceof, una forma muy usada en PHP para despachar según el tipo del componente que avisó. Cada componente solo conoce al mediador, que recibe con promoción de propiedades.
<?php
declare(strict_types=1);
interface Mediador
{
public function notificar(object $origen): void;
}
abstract class Componente
{
public function __construct(protected readonly Mediador $mediador) {}
}
final class SelectorCategoria extends Componente
{
public string $valor = '';
public function elegir(string $categoria): void { $this->valor = $categoria; $this->mediador->notificar($this); }
}
final class SelectorMarca extends Componente
{
public string $valor = '';
/** @var list<string> */
public array $opciones = [];
public function elegir(string $marca): void { $this->valor = $marca; $this->mediador->notificar($this); }
}
final class BotonLimpiar extends Componente
{
public function pulsar(): void { $this->mediador->notificar($this); }
}
final class PanelFiltros implements Mediador
{
private const CATALOGO = ['laptops' => ['Premium', 'Económica'], 'celulares' => ['Premium']];
public readonly SelectorCategoria $categoria;
public readonly SelectorMarca $marca;
public readonly BotonLimpiar $limpiar;
/** @var array{0: int, 1: int}|null */
public ?array $precio = null;
public string $resultados = '';
public function __construct()
{
$this->categoria = new SelectorCategoria($this);
$this->marca = new SelectorMarca($this);
$this->limpiar = new BotonLimpiar($this);
}
public function notificar(object $origen): void
{
match (true) {
$origen instanceof BotonLimpiar => $this->reiniciar(),
$origen instanceof SelectorCategoria => $this->alCambiarCategoria($origen->valor),
$origen instanceof SelectorMarca => $this->precio = $origen->valor === 'Premium' ? [500, 3000] : [0, 800],
default => null,
};
$total = $this->categoria->valor === '' ? 120 : ($this->marca->valor === '' ? 25 : 8);
$this->resultados = "{$total} resultados";
}
private function alCambiarCategoria(string $categoria): void
{
$this->marca->opciones = self::CATALOGO[$categoria] ?? [];
$this->marca->valor = '';
$this->precio = null;
}
private function reiniciar(): void
{
$this->categoria->valor = $this->marca->valor = '';
$this->marca->opciones = [];
$this->precio = null;
}
}
$panel = new PanelFiltros();
$panel->categoria->elegir('laptops');
echo implode(', ', $panel->marca->opciones), " · {$panel->resultados}\n"; // Premium, Económica · 25 resultados
$panel->marca->elegir('Premium');
echo implode('-', $panel->precio ?? []), " · {$panel->resultados}\n"; // 500-3000 · 8 resultados
$panel->limpiar->pulsar();
echo $panel->resultados, "\n"; // 120 resultados