Patrón MVC (Modelo-Vista-Controlador)

class ModeloTareas:
    """El modelo: los datos y sus reglas. No sabe nada de pantallas ni de teclados."""
    def __init__(self):
        self._tareas = []
        self._hechas = set()

    def anadir(self, t):
        if not t.strip():
            raise ValueError("la tarea no puede estar vacía")
        self._tareas.append(t.strip())

    def completar(self, n):
        if n < 1 or n > len(self._tareas):
            raise ValueError(f"no existe la tarea {n}")
        self._hechas.add(n - 1)

    def tareas(self):
        return tuple(self._tareas)

    def hecha(self, i):
        return i in self._hechas

    def pendientes(self):
        return len(self._tareas) - len(self._hechas)


class VistaConsola:
    """La vista: solo sabe pintar el modelo. Cambiarla por una web o una app no toca lo demás."""
    def mostrar(self, m):
        for i, t in enumerate(m.tareas()):
            print(f"  {'[x]' if m.hecha(i) else '[ ]'} {i + 1}. {t}")
        print(f"  Pendientes: {m.pendientes()}")

    def error(self, mensaje):
        print(f"  Error: {mensaje}")


class ControladorTareas:
    """El controlador: recibe lo que pide el usuario, actualiza el modelo y le dice a la vista qué mostrar."""
    def __init__(self, modelo, vista):
        self._modelo, self._vista = modelo, vista

    def orden(self, linea):
        try:
            if linea.startswith("nueva "):
                self._modelo.anadir(linea[6:])
            elif linea.startswith("hecha "):
                texto = linea[6:].strip()
                if not texto.lstrip("-").isdigit():
                    self._vista.error("número no válido")
                    return
                self._modelo.completar(int(texto))
            else:
                raise ValueError("orden desconocida")
            self._vista.mostrar(self._modelo)
        except ValueError as e:
            self._vista.error(str(e))


c = ControladorTareas(ModeloTareas(), VistaConsola())
for orden in ["nueva Leer el tema de MVC", "nueva Hacer la práctica", "hecha 1", "hecha 7", "borrar 1"]:
    print(f"> {orden}")
    c.orden(orden)                       # en una web, esto sería una petición HTTP

/** El modelo: los datos y sus reglas. No sabe nada de pantallas ni de teclados. */
class ModeloTareas {
    #tareas = [];
    #hechas = new Set();

    anadir(t) {
        if (!t.trim()) throw new Error("la tarea no puede estar vacía");
        this.#tareas.push(t.trim());
    }

    completar(n) {
        if (n < 1 || n > this.#tareas.length) throw new Error(`no existe la tarea ${n}`);
        this.#hechas.add(n - 1);
    }

    tareas() { return [...this.#tareas]; }
    hecha(i) { return this.#hechas.has(i); }
    pendientes() { return this.#tareas.length - this.#hechas.size; }
}

/** La vista: solo sabe pintar el modelo. Cambiarla por una web o una app no toca lo demás. */
class VistaConsola {
    mostrar(m) {
        m.tareas().forEach((t, i) => console.log(`  ${m.hecha(i) ? "[x]" : "[ ]"} ${i + 1}. ${t}`));
        console.log(`  Pendientes: ${m.pendientes()}`);
    }
    error(mensaje) { console.log(`  Error: ${mensaje}`); }
}

/** El controlador: recibe lo que pide el usuario, actualiza el modelo y le dice a la vista qué mostrar. */
class ControladorTareas {
    constructor(modelo, vista) { this.modelo = modelo; this.vista = vista; }

    orden(linea) {
        try {
            if (linea.startsWith("nueva ")) this.modelo.anadir(linea.slice(6));
            else if (linea.startsWith("hecha ")) {
                const texto = linea.slice(6).trim();
                if (!/^-?\d+$/.test(texto)) return this.vista.error("número no válido");
                this.modelo.completar(Number(texto));
            } else throw new Error("orden desconocida");
            this.vista.mostrar(this.modelo);
        } catch (e) {
            this.vista.error(e.message);
        }
    }
}

const c = new ControladorTareas(new ModeloTareas(), new VistaConsola());
for (const orden of ["nueva Leer el tema de MVC", "nueva Hacer la práctica", "hecha 1", "hecha 7", "borrar 1"]) {
    console.log(`> ${orden}`);
    c.orden(orden);                      // en una web, esto sería una petición HTTP
}

using System;
using System.Collections.Generic;

// El modelo: los datos y sus reglas. No sabe nada de pantallas ni de teclados.
class ModeloTareas {
    private readonly List<string> tareas = new();
    private readonly HashSet<int> hechas = new();

    public void Anadir(string t) {
        if (string.IsNullOrWhiteSpace(t)) throw new ArgumentException("la tarea no puede estar vacía");
        tareas.Add(t.Trim());
    }

    public void Completar(int n) {
        if (n < 1 || n > tareas.Count) throw new ArgumentException(
quot;no existe la tarea {n}");
        hechas.Add(n - 1);
    }

    public IReadOnlyList<string> Tareas => tareas;
    public bool Hecha(int i) => hechas.Contains(i);
    public int Pendientes => tareas.Count - hechas.Count;
}

// La vista: solo sabe pintar el modelo. Cambiarla por una web o una app no toca lo demás.
class VistaConsola {
    public void Mostrar(ModeloTareas m) {
        for (int i = 0; i < m.Tareas.Count; i++) Console.WriteLine(
quot;  {(m.Hecha(i) ? "[x]" : "[ ]")} {i + 1}. {m.Tareas[i]}");
        Console.WriteLine(
quot;  Pendientes: {m.Pendientes}");
    }
    public void Error(string mensaje) => Console.WriteLine(
quot;  Error: {mensaje}");
}

// El controlador: recibe lo que pide el usuario, actualiza el modelo y le dice a la vista qué mostrar.
class ControladorTareas {
    private readonly ModeloTareas modelo;
    private readonly VistaConsola vista;
    public ControladorTareas(ModeloTareas modelo, VistaConsola vista) { this.modelo = modelo; this.vista = vista; }

    public void Orden(string linea) {
        try {
            if (linea.StartsWith("nueva ")) modelo.Anadir(linea[6..]);
            else if (linea.StartsWith("hecha ")) {
                if (!int.TryParse(linea[6..].Trim(), out int n)) { vista.Error("número no válido"); return; }
                modelo.Completar(n);
            } else throw new ArgumentException("orden desconocida");
            vista.Mostrar(modelo);
        } catch (ArgumentException e) {
            vista.Error(e.Message);
        }
    }
}

class Program {
    static void Main() {
        var c = new ControladorTareas(new ModeloTareas(), new VistaConsola());
        foreach (var orden in new[] { "nueva Leer el tema de MVC", "nueva Hacer la práctica", "hecha 1", "hecha 7", "borrar 1" }) {
            Console.WriteLine(
quot;> {orden}");
            c.Orden(orden);                 // en una web, esto sería una petición HTTP
        }
    }
}

<?php
/** El modelo: los datos y sus reglas. No sabe nada de pantallas ni de teclados. */
class ModeloTareas {
    private array $tareas = [];
    private array $hechas = [];

    public function anadir(string $t): void {
        if (trim($t) === "") throw new InvalidArgumentException("la tarea no puede estar vacía");
        $this->tareas[] = trim($t);
    }

    public function completar(int $n): void {
        if ($n < 1 || $n > count($this->tareas)) throw new InvalidArgumentException("no existe la tarea $n");
        $this->hechas[$n - 1] = true;
    }

    public function tareas(): array { return $this->tareas; }
    public function hecha(int $i): bool { return isset($this->hechas[$i]); }
    public function pendientes(): int { return count($this->tareas) - count($this->hechas); }
}

/** La vista: solo sabe pintar el modelo. Cambiarla por una web o una app no toca lo demás. */
class VistaConsola {
    public function mostrar(ModeloTareas $m): void {
        foreach ($m->tareas() as $i => $t) echo "  ", $m->hecha($i) ? "[x]" : "[ ]", " ", $i + 1, ". $t\n";
        echo "  Pendientes: {$m->pendientes()}\n";
    }
    public function error(string $mensaje): void { echo "  Error: $mensaje\n"; }
}

/** El controlador: recibe lo que pide el usuario, actualiza el modelo y le dice a la vista qué mostrar. */
class ControladorTareas {
    public function __construct(private ModeloTareas $modelo, private VistaConsola $vista) {}

    public function orden(string $linea): void {
        try {
            if (str_starts_with($linea, "nueva ")) $this->modelo->anadir(substr($linea, 6));
            elseif (str_starts_with($linea, "hecha ")) {
                $texto = trim(substr($linea, 6));
                if (!preg_match('/^-?\d+$/', $texto)) { $this->vista->error("número no válido"); return; }
                $this->modelo->completar((int) $texto);
            } else throw new InvalidArgumentException("orden desconocida");
            $this->vista->mostrar($this->modelo);
        } catch (InvalidArgumentException $e) {
            $this->vista->error($e->getMessage());
        }
    }
}

$c = new ControladorTareas(new ModeloTareas(), new VistaConsola());
foreach (["nueva Leer el tema de MVC", "nueva Hacer la práctica", "hecha 1", "hecha 7", "borrar 1"] as $orden) {
    echo "> $orden\n";
    $c->orden($orden);                  // en una web, esto sería una petición HTTP
}

# Django: la vista de Django hace de controlador; la plantilla es la vista; el modelo, el modelo
def listar(request):
    tareas = Tarea.objects.order_by("id")                    # el modelo
    return render(request, "tareas.html", {"tareas": tareas})  # la plantilla pinta

def crear(request):
    Tarea.objects.create(texto=request.POST["texto"])
    return redirect("listar")

# tareas.html solo pinta: {% for t in tareas %}<li>{{ t.texto }}</li>{% endfor %}

// Express: la ruta hace de controlador, el modelo se encarga de los datos y la plantilla es la vista
app.get("/tareas", async (req, res) => {
    const tareas = await Tarea.findAll();         // el modelo
    res.render("tareas", { tareas });              // la vista (tareas.ejs) pinta
});

app.post("/tareas", async (req, res) => {
    await Tarea.create({ texto: req.body.texto });
    res.redirect("/tareas");
});

// ASP.NET Core MVC: el controlador devuelve una vista Razor con su modelo
public class TareasController : Controller {
    private readonly TareasService servicio;
    public TareasController(TareasService servicio) => this.servicio = servicio;

    public IActionResult Index() => View(servicio.Todas());     // Views/Tareas/Index.cshtml pinta

    [HttpPost]
    public IActionResult Crear(string texto) {
        servicio.Anadir(texto);
        return RedirectToAction(nameof(Index));
    }
}

<?php
// Laravel: la ruta lleva al controlador, que pide los datos al modelo (Eloquent) y devuelve una vista Blade
class TareaController extends Controller {
    public function index() {
        return view("tareas.index", ["tareas" => Tarea::orderBy("id")->get()]);
    }

    public function store(Request $request) {
        Tarea::create($request->validate(["texto" => "required|max:200"]));
        return redirect()->route("tareas.index");
    }
}

// resources/views/tareas/index.blade.php solo pinta: @foreach ($tareas as $t) <li>{{ $t->texto }}</li> @endforeach