Factory Method
Método fábrica · Constructor virtual
Define un método para crear un objeto, pero deja que las subclases decidan qué clase concreta instanciar.
“Tengo un switch que decide qué clase crear y crece con cada tipo nuevo.”
workEl caso real
Tu fintech concilia los movimientos bancarios de sus clientes con sus ventas. Cada banco entrega el extracto en su propio formato: uno envía un CSV separado por punto y coma, otro un TXT de ancho fijo y otro expone una API JSON. El proceso de conciliación (leer los movimientos, cruzarlos con las ventas y marcar diferencias) es siempre el mismo; lo único que cambia es cómo se lee el extracto.
warningEl problema sin el patrón
El servicio de conciliación tiene un switch(banco) que crea el lector correcto, y ese mismo switch aparece en el proceso nocturno, en la carga manual de archivos y en las pruebas. Sumar un banco obliga a modificar todos esos lugares y es fácil olvidar uno.
check_circleCómo lo resuelve el patrón
La clase base Conciliador define el proceso y delega la creación del lector en un método fábrica abstracto, crearLector(). Cada subclase (ConciliadorBancoAndino, ConciliadorBancoPacifico) decide qué lector concreto crear. Sumar un banco es sumar una subclase, sin tocar el proceso.
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
class ServicioConciliacion {
conciliar(banco: string, archivo: string) {
let lector: LectorExtracto;
switch (banco) {
case 'andino': lector = new LectorCsvAndino(); break;
case 'pacifico': lector = new LectorTxtPacifico(); break;
default: throw new Error('Banco no soportado: ' + banco);
}
const movimientos = lector.leer(archivo);
// ...cruzar con ventas y reportar diferencias
}
}abstract class Conciliador {
// Método fábrica: cada subclase decide qué lector crear
protected abstract crearLector(): LectorExtracto;
conciliar(archivo: string): Diferencia[] {
const movimientos = this.crearLector().leer(archivo);
return cruzarConVentas(movimientos);
}
}
class ConciliadorBancoAndino extends Conciliador {
protected crearLector() { return new LectorCsvAndino(); }
}
class ConciliadorBancoPacifico extends Conciliador {
protected crearLector() { return new LectorTxtPacifico(); }
}Ejemplos en TypeScript, simplificados para mostrar la idea: los tipos auxiliares (Pedido, Cliente…) se omiten.
Matiz importante
En el código actual es muy común reemplazar la herencia por inyección: se pasa al constructor una fábrica o una función que crea el lector. La idea es la misma: el proceso no decide qué clase concreta se instancia. Además, el método fábrica no está obligado a crear siempre un objeto nuevo: puede devolver uno que ya existe (de una caché o de un pool) y quien lo llama no nota la diferencia.
thumb_upCuándo usarlo
- ✓Una clase tiene un proceso estable, pero el objeto concreto con el que trabaja varía según el caso.
- ✓Quieres que quien extienda tu código (subclases, plugins) decida qué objeto se crea.
- ✓Quieres reutilizar objetos costosos (lectores ya configurados, conexiones) en lugar de crearlos cada vez: el método fábrica puede devolver uno existente.
do_not_disturb_onCuándo no usarlo
- ✕Solo hay un tipo concreto y no se prevé otro: un new directo es más claro.
- ✕Si la variación no justifica una jerarquía de clases, basta con inyectar el objeto o una función que lo cree.
- ✕Cada producto nuevo exige también un creador nuevo: con muchos productos, la jerarquía crece más de lo que aporta.
memoryPrincipios en juego
- •Abierto/Cerrado: un banco nuevo es una subclase nueva, no un case más.
- •Inversión de dependencias: el proceso depende de la interfaz LectorExtracto, no de los lectores concretos.
hubPatrones relacionados
- •Abstract Factory: suele implementarse con varios métodos fábrica, uno por producto.
- •Template Method: el método fábrica suele ser uno de los pasos que la subclase completa.
- •Prototype: alternativa que crea objetos clonando en vez de usar subclases.
quizPon a prueba lo que leíste
Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.
code_blocksFactory Method en tu lenguaje
El mismo caso, implementado completo y de forma idiomática. Se puede copiar y ejecutar.
LO IDIOMÁTICO EN TYPESCRIPT: La clase abstracta declara el método fábrica como protected abstract: el compilador obliga a cada subclase a implementarlo. Gracias al tipado estructural, un lector solo necesita cumplir la forma de LectorExtracto.
export interface Movimiento {
fecha: string;
referencia: string;
monto: number;
}
export interface LectorExtracto {
leer(contenido: string): Movimiento[];
}
class LectorCsvAndino implements LectorExtracto {
leer(contenido: string): Movimiento[] {
return contenido.trim().split('\n').map((linea) => {
const [fecha, referencia, monto] = linea.split(';');
return { fecha, referencia, monto: Number(monto) };
});
}
}
class LectorTxtPacifico implements LectorExtracto {
// Ancho fijo: fecha (10) + referencia (8) + monto (resto)
leer(contenido: string): Movimiento[] {
return contenido.trim().split('\n').map((linea) => ({
fecha: linea.slice(0, 10),
referencia: linea.slice(10, 18).trim(),
monto: Number(linea.slice(18)),
}));
}
}
export abstract class Conciliador {
// Método fábrica: cada subclase decide qué lector crear
protected abstract crearLector(): LectorExtracto;
conciliar(contenido: string, ventas: Map<string, number>): string[] {
const diferencias: string[] = [];
for (const mov of this.crearLector().leer(contenido)) {
const esperado = ventas.get(mov.referencia);
if (esperado !== mov.monto) {
diferencias.push(`${mov.referencia}: banco ${mov.monto}, ventas ${esperado ?? 'sin registro'}`);
}
}
return diferencias;
}
}
export class ConciliadorBancoAndino extends Conciliador {
protected crearLector() { return new LectorCsvAndino(); }
}
export class ConciliadorBancoPacifico extends Conciliador {
protected crearLector() { return new LectorTxtPacifico(); }
}
// ── Uso ──
const ventas = new Map([['F-001', 150], ['F-002', 80]]);
const csvAndino = '2026-11-01;F-001;150\n2026-11-01;F-002;75';
console.log(new ConciliadorBancoAndino().conciliar(csvAndino, ventas));
// [ 'F-002: banco 75, ventas 80' ]
const txtPacifico = '2026-11-01F-001 150\n2026-11-02F-003 40';
console.log(new ConciliadorBancoPacifico().conciliar(txtPacifico, ventas));
// [ 'F-003: banco 40, ventas sin registro' ]LO IDIOMÁTICO EN C# / .NET: C# es muy cercano al Factory Method clásico: una clase abstract declara el método fábrica como abstract y el compilador obliga a cada subclase a implementarlo con override. Los datos van en record (inmutables, con igualdad por valor) y los lectores transforman las líneas con LINQ.
using System.Globalization;
var ventas = new Dictionary<string, decimal> { ["F-001"] = 150m, ["F-002"] = 80m };
foreach (var diferencia in new ConciliadorBancoAndino().Conciliar("2026-11-01;F-001;150\n2026-11-01;F-002;75", ventas))
Console.WriteLine(diferencia); // F-002: banco 75, ventas 80
foreach (var diferencia in new ConciliadorBancoPacifico().Conciliar("2026-11-01F-001 150\n2026-11-02F-003 40", ventas))
Console.WriteLine(diferencia); // F-003: banco 40, ventas sin registro
public record Movimiento(string Fecha, string Referencia, decimal Monto);
public interface ILectorExtracto
{
IEnumerable<Movimiento> Leer(string contenido);
}
public class LectorCsvAndino : ILectorExtracto
{
public IEnumerable<Movimiento> Leer(string contenido) =>
from linea in contenido.Trim().Split('\n')
let partes = linea.Split(';')
select new Movimiento(partes[0], partes[1], decimal.Parse(partes[2], CultureInfo.InvariantCulture));
}
public class LectorTxtPacifico : ILectorExtracto
{
// Ancho fijo: fecha (10) + referencia (8) + monto (resto)
public IEnumerable<Movimiento> Leer(string contenido) =>
contenido.Trim().Split('\n').Select(linea => new Movimiento(
linea[..10], linea[10..18].Trim(), decimal.Parse(linea[18..], CultureInfo.InvariantCulture)));
}
public abstract class Conciliador
{
// Método fábrica: cada subclase decide qué lector crear
protected abstract ILectorExtracto CrearLector();
public IEnumerable<string> Conciliar(string contenido, IReadOnlyDictionary<string, decimal> ventas)
{
foreach (var mov in CrearLector().Leer(contenido))
{
if (!ventas.TryGetValue(mov.Referencia, out var esperado))
yield return $"{mov.Referencia}: banco {mov.Monto}, ventas sin registro";
else if (esperado != mov.Monto)
yield return $"{mov.Referencia}: banco {mov.Monto}, ventas {esperado}";
}
}
}
public class ConciliadorBancoAndino : Conciliador
{
protected override ILectorExtracto CrearLector() => new LectorCsvAndino();
}
public class ConciliadorBancoPacifico : Conciliador
{
protected override ILectorExtracto CrearLector() => new LectorTxtPacifico();
}LO IDIOMÁTICO EN JAVA: Java está muy cerca del Factory Method clásico: una clase abstract declara el método fábrica y el compilador obliga a cada subclase a implementarlo. Los datos son record y el dinero se maneja con BigDecimal, sin los errores de redondeo de double. (Archivo compacto de Java 25+: void main() sin clase envolvente.)
void main() {
var ventas = Map.of("F-001", new BigDecimal("150"), "F-002", new BigDecimal("80"));
IO.println(new ConciliadorBancoAndino().conciliar("2026-11-01;F-001;150\n2026-11-01;F-002;75", ventas));
// [F-002: banco 75, ventas 80]
IO.println(new ConciliadorBancoPacifico().conciliar("2026-11-01F-001 150\n2026-11-02F-003 40", ventas));
// [F-003: banco 40, ventas sin registro]
}
record Movimiento(String fecha, String referencia, BigDecimal monto) {}
interface LectorExtracto {
List<Movimiento> leer(String contenido);
}
class LectorCsvAndino implements LectorExtracto {
@Override
public List<Movimiento> leer(String contenido) {
return contenido.strip().lines()
.map(linea -> linea.split(";"))
.map(partes -> new Movimiento(partes[0], partes[1], new BigDecimal(partes[2])))
.toList();
}
}
class LectorTxtPacifico implements LectorExtracto {
// Ancho fijo: fecha (10) + referencia (8) + monto (resto)
@Override
public List<Movimiento> leer(String contenido) {
return contenido.strip().lines()
.map(l -> new Movimiento(l.substring(0, 10), l.substring(10, 18).strip(), new BigDecimal(l.substring(18).strip())))
.toList();
}
}
abstract class Conciliador {
// Método fábrica: cada subclase decide qué lector crear
protected abstract LectorExtracto crearLector();
List<String> conciliar(String contenido, Map<String, BigDecimal> ventas) {
var diferencias = new ArrayList<String>();
for (var mov : crearLector().leer(contenido)) {
var esperado = ventas.get(mov.referencia());
if (esperado == null) {
diferencias.add(mov.referencia() + ": banco " + mov.monto() + ", ventas sin registro");
} else if (esperado.compareTo(mov.monto()) != 0) {
diferencias.add(mov.referencia() + ": banco " + mov.monto() + ", ventas " + esperado);
}
}
return diferencias;
}
}
class ConciliadorBancoAndino extends Conciliador {
@Override
protected LectorExtracto crearLector() {
return new LectorCsvAndino();
}
}
class ConciliadorBancoPacifico extends Conciliador {
@Override
protected LectorExtracto crearLector() {
return new LectorTxtPacifico();
}
}LO IDIOMÁTICO EN JAVASCRIPT: JavaScript no tiene clases abstractas: el método fábrica de la clase base lanza un error claro si una subclase olvida sobrescribirlo. Los lectores no declaran ninguna interfaz; basta con que tengan un método leer (duck typing), así que pueden ser simples objetos literales.
/**
* @typedef {{ fecha: string, referencia: string, monto: number }} Movimiento
* @typedef {{ leer(contenido: string): Movimiento[] }} LectorExtracto
*/
/** @type {LectorExtracto} */
const lectorCsvAndino = {
leer: (contenido) => contenido.trim().split('\n').map((linea) => {
const [fecha, referencia, monto] = linea.split(';');
return { fecha, referencia, monto: Number(monto) };
}),
};
/** @type {LectorExtracto} */
const lectorTxtPacifico = {
// Ancho fijo: fecha (10) + referencia (8) + monto (resto)
leer: (contenido) => contenido.trim().split('\n').map((linea) => ({
fecha: linea.slice(0, 10),
referencia: linea.slice(10, 18).trim(),
monto: Number(linea.slice(18)),
})),
};
export class Conciliador {
/**
* Método fábrica: las subclases deciden qué lector usar
* @returns {LectorExtracto}
*/
crearLector() {
throw new Error(`${this.constructor.name} debe implementar crearLector()`);
}
/** @param {string} contenido @param {Map<string, number>} ventas */
conciliar(contenido, ventas) {
const diferencias = [];
for (const mov of this.crearLector().leer(contenido)) {
const esperado = ventas.get(mov.referencia);
if (esperado !== mov.monto) {
diferencias.push(`${mov.referencia}: banco ${mov.monto}, ventas ${esperado ?? 'sin registro'}`);
}
}
return diferencias;
}
}
export class ConciliadorBancoAndino extends Conciliador {
crearLector() { return lectorCsvAndino; }
}
export class ConciliadorBancoPacifico extends Conciliador {
crearLector() { return lectorTxtPacifico; }
}
// ── Uso ──
const ventas = new Map([['F-001', 150], ['F-002', 80]]);
console.log(new ConciliadorBancoAndino().conciliar('2026-11-01;F-001;150\n2026-11-01;F-002;75', ventas));
// [ 'F-002: banco 75, ventas 80' ]
console.log(new ConciliadorBancoPacifico().conciliar('2026-11-01F-001 150\n2026-11-02F-003 40', ventas));
// [ 'F-003: banco 40, ventas sin registro' ]
class ConciliadorIncompleto extends Conciliador {}
try {
new ConciliadorIncompleto().conciliar('', ventas);
} catch (error) {
console.log(error.message); // ConciliadorIncompleto debe implementar crearLector()
}LO IDIOMÁTICO EN PYTHON: ABC y @abstractmethod hacen que Python impida instanciar una subclase que no implemente el método fábrica. Los lectores se describen con typing.Protocol (tipado estructural: no necesitan heredar de nada) y los movimientos son dataclass inmutables.
from abc import ABC, abstractmethod
from collections.abc import Mapping
from dataclasses import dataclass
from typing import Protocol
@dataclass(frozen=True)
class Movimiento:
fecha: str
referencia: str
monto: float
class LectorExtracto(Protocol):
def leer(self, contenido: str) -> list[Movimiento]: ...
class LectorCsvAndino:
def leer(self, contenido: str) -> list[Movimiento]:
movimientos = []
for linea in contenido.strip().splitlines():
fecha, referencia, monto = linea.split(";")
movimientos.append(Movimiento(fecha, referencia, float(monto)))
return movimientos
class LectorTxtPacifico:
def leer(self, contenido: str) -> list[Movimiento]:
# Ancho fijo: fecha (10) + referencia (8) + monto (resto)
return [
Movimiento(linea[:10], linea[10:18].strip(), float(linea[18:]))
for linea in contenido.strip().splitlines()
]
class Conciliador(ABC):
@abstractmethod
def crear_lector(self) -> LectorExtracto:
"""Método fábrica: cada subclase decide qué lector crear."""
def conciliar(self, contenido: str, ventas: Mapping[str, float]) -> list[str]:
diferencias = []
for mov in self.crear_lector().leer(contenido):
esperado = ventas.get(mov.referencia)
if esperado != mov.monto:
en_ventas = "sin registro" if esperado is None else f"{esperado:g}"
diferencias.append(f"{mov.referencia}: banco {mov.monto:g}, ventas {en_ventas}")
return diferencias
class ConciliadorBancoAndino(Conciliador):
def crear_lector(self) -> LectorExtracto:
return LectorCsvAndino()
class ConciliadorBancoPacifico(Conciliador):
def crear_lector(self) -> LectorExtracto:
return LectorTxtPacifico()
if __name__ == "__main__":
ventas = {"F-001": 150, "F-002": 80}
print(ConciliadorBancoAndino().conciliar("2026-11-01;F-001;150\n2026-11-01;F-002;75", ventas))
# ['F-002: banco 75, ventas 80']
print(ConciliadorBancoPacifico().conciliar("2026-11-01F-001 150\n2026-11-02F-003 40", ventas))
# ['F-003: banco 40, ventas sin registro']
class ConciliadorIncompleto(Conciliador):
pass
try:
ConciliadorIncompleto() # type: ignore[abstract]
except TypeError as error:
print(error) # Can't instantiate abstract class ConciliadorIncompleto ...LO IDIOMÁTICO EN GO: Go no tiene herencia ni clases abstractas. El "método fábrica" se guarda como un campo de tipo función en el conciliador, y cada constructor (NuevoConciliadorAndino) decide qué lector crear. Las interfaces son implícitas: un lector solo necesita tener el método Leer.
package main
import (
"fmt"
"strconv"
"strings"
)
type Movimiento struct {
Fecha string
Referencia string
Monto float64
}
type LectorExtracto interface {
Leer(contenido string) ([]Movimiento, error)
}
type lectorCsvAndino struct{}
func (lectorCsvAndino) Leer(contenido string) ([]Movimiento, error) {
var movimientos []Movimiento
for _, linea := range strings.Split(strings.TrimSpace(contenido), "\n") {
partes := strings.Split(linea, ";")
if len(partes) != 3 {
return nil, fmt.Errorf("línea inválida: %q", linea)
}
monto, err := strconv.ParseFloat(partes[2], 64)
if err != nil {
return nil, fmt.Errorf("monto inválido en %q: %w", linea, err)
}
movimientos = append(movimientos, Movimiento{partes[0], partes[1], monto})
}
return movimientos, nil
}
type lectorTxtPacifico struct{}
// Ancho fijo: fecha (10) + referencia (8) + monto (resto)
func (lectorTxtPacifico) Leer(contenido string) ([]Movimiento, error) {
var movimientos []Movimiento
for _, linea := range strings.Split(strings.TrimSpace(contenido), "\n") {
if len(linea) < 19 {
return nil, fmt.Errorf("línea demasiado corta: %q", linea)
}
monto, err := strconv.ParseFloat(strings.TrimSpace(linea[18:]), 64)
if err != nil {
return nil, fmt.Errorf("monto inválido en %q: %w", linea, err)
}
movimientos = append(movimientos, Movimiento{linea[:10], strings.TrimSpace(linea[10:18]), monto})
}
return movimientos, nil
}
// Conciliador guarda el método fábrica como una función
type Conciliador struct {
crearLector func() LectorExtracto
}
func NuevoConciliadorAndino() *Conciliador {
return &Conciliador{crearLector: func() LectorExtracto { return lectorCsvAndino{} }}
}
func NuevoConciliadorPacifico() *Conciliador {
return &Conciliador{crearLector: func() LectorExtracto { return lectorTxtPacifico{} }}
}
func (c *Conciliador) Conciliar(contenido string, ventas map[string]float64) ([]string, error) {
movimientos, err := c.crearLector().Leer(contenido)
if err != nil {
return nil, err
}
var diferencias []string
for _, m := range movimientos {
esperado, existe := ventas[m.Referencia]
switch {
case !existe:
diferencias = append(diferencias, fmt.Sprintf("%s: banco %g, ventas sin registro", m.Referencia, m.Monto))
case esperado != m.Monto:
diferencias = append(diferencias, fmt.Sprintf("%s: banco %g, ventas %g", m.Referencia, m.Monto, esperado))
}
}
return diferencias, nil
}
func main() {
ventas := map[string]float64{"F-001": 150, "F-002": 80}
diferencias, err := NuevoConciliadorAndino().Conciliar("2026-11-01;F-001;150\n2026-11-01;F-002;75", ventas)
fmt.Println(diferencias, err) // [F-002: banco 75, ventas 80] <nil>
diferencias, err = NuevoConciliadorPacifico().Conciliar("2026-11-01F-001 150\n2026-11-02F-003 40", ventas)
fmt.Println(diferencias, err) // [F-003: banco 40, ventas sin registro] <nil>
_, err = NuevoConciliadorAndino().Conciliar("2026-11-01;F-009;abc", ventas)
fmt.Println(err) // monto inválido en "2026-11-01;F-009;abc": strconv.ParseFloat: ...
}LO IDIOMÁTICO EN RUST: Rust no tiene herencia: el "creador" es un trait con un método requerido (crear_lector, el método fábrica) y un método provisto (conciliar) que lo usa. Los errores de lectura se devuelven con Result y se propagan con el operador ?, sin excepciones.
use std::collections::HashMap;
struct Movimiento {
referencia: String,
monto: f64,
}
trait LectorExtracto {
fn leer(&self, contenido: &str) -> Result<Vec<Movimiento>, String>;
}
struct LectorCsvAndino;
impl LectorExtracto for LectorCsvAndino {
fn leer(&self, contenido: &str) -> Result<Vec<Movimiento>, String> {
contenido
.trim()
.lines()
.map(|linea| {
let partes: Vec<&str> = linea.split(';').collect();
let [_fecha, referencia, monto] = partes.as_slice() else {
return Err(format!("línea inválida: {linea}"));
};
let monto = monto
.parse()
.map_err(|e| format!("monto inválido en {linea}: {e}"))?;
Ok(Movimiento {
referencia: referencia.to_string(),
monto,
})
})
.collect()
}
}
struct LectorTxtPacifico;
impl LectorExtracto for LectorTxtPacifico {
// Ancho fijo: fecha (10) + referencia (8) + monto (resto)
fn leer(&self, contenido: &str) -> Result<Vec<Movimiento>, String> {
contenido
.trim()
.lines()
.map(|linea| {
let monto = linea[18..]
.trim()
.parse()
.map_err(|e| format!("monto inválido en {linea}: {e}"))?;
Ok(Movimiento {
referencia: linea[10..18].trim().to_string(),
monto,
})
})
.collect()
}
}
trait Conciliador {
// Método fábrica: cada implementación decide qué lector crear
fn crear_lector(&self) -> Box<dyn LectorExtracto>;
fn conciliar(
&self,
contenido: &str,
ventas: &HashMap<&str, f64>,
) -> Result<Vec<String>, String> {
let mut diferencias = Vec::new();
for mov in self.crear_lector().leer(contenido)? {
match ventas.get(mov.referencia.as_str()) {
None => diferencias.push(format!(
"{}: banco {}, ventas sin registro",
mov.referencia, mov.monto
)),
Some(esperado) if (esperado - mov.monto).abs() > f64::EPSILON => {
diferencias.push(format!(
"{}: banco {}, ventas {esperado}",
mov.referencia, mov.monto
));
}
Some(_) => {}
}
}
Ok(diferencias)
}
}
struct ConciliadorBancoAndino;
impl Conciliador for ConciliadorBancoAndino {
fn crear_lector(&self) -> Box<dyn LectorExtracto> {
Box::new(LectorCsvAndino)
}
}
struct ConciliadorBancoPacifico;
impl Conciliador for ConciliadorBancoPacifico {
fn crear_lector(&self) -> Box<dyn LectorExtracto> {
Box::new(LectorTxtPacifico)
}
}
fn main() {
let ventas = HashMap::from([("F-001", 150.0), ("F-002", 80.0)]);
println!(
"{:?}",
ConciliadorBancoAndino.conciliar("2026-11-01;F-001;150\n2026-11-01;F-002;75", &ventas)
);
// Ok(["F-002: banco 75, ventas 80"])
println!(
"{:?}",
ConciliadorBancoPacifico.conciliar("2026-11-01F-001 150\n2026-11-02F-003 40", &ventas)
);
// Ok(["F-003: banco 40, ventas sin registro"])
println!(
"{:?}",
ConciliadorBancoAndino.conciliar("2026-11-01;F-009;abc", &ventas)
);
// Err("monto inválido en 2026-11-01;F-009;abc: invalid float literal")
}LO IDIOMÁTICO EN PHP: PHP sigue el Factory Method clásico: una clase abstract declara el método fábrica y cada subclase lo implementa; #[\Override] (PHP 8.3) hace que PHP avise si el método no sobrescribe nada. Los movimientos son clases readonly con promoción de propiedades en el constructor.
<?php
declare(strict_types=1);
final readonly class Movimiento
{
public function __construct(public string $referencia, public float $monto) {}
}
interface LectorExtracto
{
/** @return list<Movimiento> */
public function leer(string $contenido): array;
}
final class LectorCsvAndino implements LectorExtracto
{
#[\Override]
public function leer(string $contenido): array
{
return array_map(function (string $linea): Movimiento {
[, $referencia, $monto] = explode(';', $linea);
return new Movimiento($referencia, (float) $monto);
}, explode("\n", trim($contenido)));
}
}
final class LectorTxtPacifico implements LectorExtracto
{
// Ancho fijo: fecha (10) + referencia (8) + monto (resto)
#[\Override]
public function leer(string $contenido): array
{
return array_map(
fn (string $linea) => new Movimiento(trim(substr($linea, 10, 8)), (float) substr($linea, 18)),
explode("\n", trim($contenido)),
);
}
}
abstract class Conciliador
{
// Método fábrica: cada subclase decide qué lector crear
abstract protected function crearLector(): LectorExtracto;
/**
* @param array<string, float> $ventas
* @return list<string>
*/
public function conciliar(string $contenido, array $ventas): array
{
$diferencias = [];
foreach ($this->crearLector()->leer($contenido) as $mov) {
$esperado = $ventas[$mov->referencia] ?? null;
if ($esperado === null) {
$diferencias[] = "{$mov->referencia}: banco {$mov->monto}, ventas sin registro";
} elseif ($esperado !== $mov->monto) {
$diferencias[] = "{$mov->referencia}: banco {$mov->monto}, ventas {$esperado}";
}
}
return $diferencias;
}
}
final class ConciliadorBancoAndino extends Conciliador
{
#[\Override]
protected function crearLector(): LectorExtracto
{
return new LectorCsvAndino();
}
}
final class ConciliadorBancoPacifico extends Conciliador
{
#[\Override]
protected function crearLector(): LectorExtracto
{
return new LectorTxtPacifico();
}
}
$ventas = ['F-001' => 150.0, 'F-002' => 80.0];
print_r((new ConciliadorBancoAndino())->conciliar("2026-11-01;F-001;150\n2026-11-01;F-002;75", $ventas));
// [0] => F-002: banco 75, ventas 80
print_r((new ConciliadorBancoPacifico())->conciliar("2026-11-01F-001 150\n2026-11-02F-003 40", $ventas));
// [0] => F-003: banco 40, ventas sin registro