Mira la lección en vídeo

Accede al vídeo completo de esta lección y a más contenido exclusivo con el Plan Plus.

Buenas prácticas en la separación de la lógica de negocio y la vista (MVC básico)

La separación de la lógica de negocio y la vista es fundamental para mantener un código limpio y sostenible en aplicaciones PHP. Al dividir la aplicación en capas, facilitamos su mantenimiento y favorecemos la reutilización de componentes.

En un enfoque básico de MVC (Modelo-Vista-Controlador), el Modelo gestiona los datos y las reglas de negocio, la Vista se encarga de presentar la información al usuario y el Controlador actúa como intermediario, procesando las acciones del usuario y actualizando el modelo y la vista según sea necesario. Esta separación clara de responsabilidades mejora la legibilidad y facilita el trabajo en equipo.

Por ejemplo, al procesar un formulario de contacto, el Controlador recibirá los datos enviados, utilizará el Modelo para validar y posiblemente almacenar la información, y luego seleccionará la Vista adecuada para mostrar al usuario.

Controlador (_controlador.php_):

<?php
require_once 'modelo.php';

$errores = [];
$datos = [];

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $datos['nombre'] = trim($_POST['nombre'] ?? '');
    $datos['email'] = trim($_POST['email'] ?? '');
    $datos['mensaje'] = trim($_POST['mensaje'] ?? '');

    $errores = validarFormulario($datos);

    if (empty($errores)) {
        enviarCorreo($datos);
        header('Location: gracias.php');
        exit;
    }
}

require 'vista.php';

En este ejemplo, el Controlador maneja la petición y decide qué acción realizar en función de si hay errores o no. No contiene detalles de presentación ni lógica de negocio compleja.

Modelo (_modelo.php_):

<?php

function validarFormulario(array $datos): array
{
    $errores = [];

    if ($datos['nombre'] === '') {
        $errores['nombre'] = 'El nombre es obligatorio.';
    }

    if (!filter_var($datos['email'], FILTER_VALIDATE_EMAIL)) {
        $errores['email'] = 'El email no es válido.';
    }

    if ($datos['mensaje'] === '') {
        $errores['mensaje'] = 'El mensaje no puede estar vacío.';
    }

    return $errores;
}

function enviarCorreo(array $datos): void
{
    $para = 'contacto@ejemplo.com';
    $asunto = 'Nuevo mensaje de contacto';
    $cuerpo = "Nombre: {$datos['nombre']}\nEmail: {$datos['email']}\nMensaje: {$datos['mensaje']}\n";
    $cabeceras = "From: {$datos['email']}\n";

    mail($para, $asunto, $cuerpo, $cabeceras);
}

El Modelo contiene funciones que encapsulan la lógica de validación y el envío de correo. De este modo, si necesitamos cambiar la forma en que se valida o procesa la información, podemos hacerlo aquí sin afectar al resto de la aplicación.

Vista (_vista.php_):

<!-- vista.php -->
<!DOCTYPE html>
<html lang="es">

<head>
    <meta charset="UTF-8">
    <title>Formulario de Contacto</title>
</head>

<body>
    <form action="controlador.php" method="post">
        <label for="nombre">Nombre:</label>
        <input type="text" id="nombre" name="nombre" value="<?php echo htmlspecialchars($datos['nombre'] ?? '', ENT_QUOTES, 'UTF-8'); ?>">
        <?php if (isset($errores['nombre'])): ?>
            <p><?php echo $errores['nombre']; ?></p>
        <?php endif; ?>

        <label for="email">Email:</label>
        <input type="email" id="email" name="email" value="<?php echo htmlspecialchars($datos['email'] ?? '', ENT_QUOTES, 'UTF-8'); ?>">
        <?php if (isset($errores['email'])): ?>
            <p><?php echo $errores['email']; ?></p>
        <?php endif; ?>

        <label for="mensaje">Mensaje:</label>
        <textarea id="mensaje" name="mensaje"><?php echo htmlspecialchars($datos['mensaje'] ?? '', ENT_QUOTES, 'UTF-8'); ?></textarea>
        <?php if (isset($errores['mensaje'])): ?>
            <p><?php echo $errores['mensaje']; ?></p>
        <?php endif; ?>

        <button type="submit">Enviar</button>
    </form>
</body>

</html>

La Vista presenta el formulario al usuario y muestra los mensajes de error cuando corresponda. Utiliza variables proporcionadas por el Controlador y mantiene el código HTML separado de la lógica de negocio.

Al aplicar estas buenas prácticas, logramos que cada componente de la aplicación tenga una función específica. Esto facilita la escalabilidad y el mantenimiento, ya que los cambios en una parte del código no afectarán inadvertidamente a otras. Además, mejora la reutilización de código, permitiendo compartir modelos y vistas entre diferentes controladores.

Es esencial mantener esta separación especialmente en aplicaciones más complejas, donde el acoplamiento entre la lógica de negocio y la presentación puede llevar a código difícil de mantener y propenso a errores. Adoptar un patrón MVC básico en PHP es un paso hacia un desarrollo más ordenado y profesional.

Generación dinámica de formularios en función de la lógica de la aplicación

Guarda tu progreso

Inicia sesión para no perder tu progreso y accede a miles de tutoriales, ejercicios prácticos y nuestro asistente de IA.

Progreso guardado

Asistente IA

Ejercicios

Iniciar sesión gratis

Más de 25.000 desarrolladores ya confían en CertiDevs

La generación dinámica de formularios en PHP permite crear formularios que se adaptan en tiempo real según la lógica de la aplicación. Esto es esencial cuando los campos del formulario dependen de variables como preferencias del usuario, datos de una base de datos o reglas de negocio específicas.

Por ejemplo, en una aplicación de registro, podríamos mostrar campos adicionales si el usuario selecciona una opción particular, como indicar si es una empresa o un individuo.

Ventajas de los formularios dinámicos:

Adaptabilidad: Los formularios pueden ajustarse automáticamente a diferentes escenarios sin requerir cambios manuales en el código.
Eficiencia: Reducen la redundancia al evitar tener múltiples formularios casi idénticos.
Mejora de la experiencia de usuario: Al mostrar solo los campos relevantes, se simplifica la interacción y se minimiza la confusión.

Técnicas para generar formularios dinámicamente

Uso de bucles y estructuras de datos

Una forma común es recorrer arrays o resultados de consultas para generar los campos necesarios:

<?php
$campos = [
    ['nombre' => 'nombre', 'tipo' => 'text', 'etiqueta' => 'Nombre'],
    ['nombre' => 'email', 'tipo' => 'email', 'etiqueta' => 'Correo Electrónico'],
    ['nombre' => 'telefono', 'tipo' => 'tel', 'etiqueta' => 'Teléfono'],
];

echo "<form action='procesar.php' method='post'>\n";
foreach ($campos as $campo) {
    echo '<label for="' . htmlspecialchars($campo['nombre']) . '">' . htmlspecialchars($campo['etiqueta']) . ':</label>' . "\n";
    echo '<input type="' . htmlspecialchars($campo['tipo']) . '" id="' . htmlspecialchars($campo['nombre']) . '" name="' . htmlspecialchars($campo['nombre']) . '">' . "\n";
}
echo "<button type='submit'>Enviar</button>\n";
echo "</form>\n";

En este ejemplo, utilizamos un array asociativo para definir los campos y un bucle foreach para generarlos dinámicamente.

Generación basada en condiciones

Podemos adaptar el formulario según condiciones específicas:

<?php
echo "<form action='registro.php' method='post'>\n";

echo "<label for='usuario'>Usuario:</label>\n";
echo "<input type='text' id='usuario' name='usuario'>\n";

echo "<label for='tipo'>Tipo de cuenta:</label>\n";
echo "<select id='tipo' name='tipo'>\n";
echo "<option value='individual'>Individual</option>\n";
echo "<option value='empresa'>Empresa</option>\n";
echo "</select>\n";

if (isset($_POST['tipo']) && $_POST['tipo'] === 'empresa') {
    echo "<label for='empresa'>Nombre de la Empresa:</label>\n";
    echo "<input type='text' id='empresa' name='empresa'>\n";
    echo "<label for='cif'>CIF:</label>\n";
    echo "<input type='text' id='cif' name='cif'>\n";
}

echo "<button type='submit'>Registrar</button>\n";
echo "</form>\n";

Aquí, la lógica condicional determina qué campos se muestran al usuario, proporcionando una interfaz más personalizada.

Generación a partir de datos de base de datos

Los formularios pueden generarse dinámicamente según los datos almacenados:

<?php
$pdo = new PDO('mysql:host=localhost;dbname=productos', 'usuario', 'contraseña');

$consulta = $pdo->query('SELECT id, nombre FROM categorias');
$categorias = $consulta->fetchAll(PDO::FETCH_ASSOC);

echo "<form action='filtrar.php' method='get'>\n";
echo "<label for='categoria'>Categoría:</label>\n";
echo "<select id='categoria' name='categoria'>\n";
foreach ($categorias as $categoria) {
    echo "<option value='" . htmlspecialchars($categoria['id']) . ">" . htmlspecialchars($categoria['nombre']) . "</option>\n";
}
echo "</select>\n";
echo "<button type='submit'>Filtrar</button>\n";
echo "</form>\n";

En este caso, el formulario se genera en función de las categorías disponibles en la base de datos, permitiendo al usuario seleccionar entre opciones actualizadas.

Modularización con funciones o clases

Para mejorar la mantenibilidad, es recomendable encapsular la lógica de generación en funciones o clases:

<?php
function generarCampo(array $campo): string
{
    $html = '<label for="' . htmlspecialchars($campo['nombre']) . '">' . htmlspecialchars($campo['etiqueta']) . ':</label>' . "\n";
    $html .= '<input type="' . htmlspecialchars($campo['tipo']) . '" id="' . htmlspecialchars($campo['nombre']) . '" name="' . htmlspecialchars($campo['nombre']) . '">' . "\n";
    return $html;
}

Esto permite reutilizar código y facilita la actualización de la lógica de generación.

<?php
echo "<form action='guardar.php' method='post'>\n";
foreach ($campos as $campo) {
    echo generarCampo($campo);
}
echo "<button type='submit'>Enviar</button>\n";
echo "</form>\n";

Al utilizar funciones, logramos una reutilización eficiente y una estructura más clara del código.

Uso de templates y motores de plantillas

Para una separación más clara entre la lógica y la presentación, podemos usar motores de plantillas como Twig o Blade:

<!-- formulario.twig -->
<form action="{{ action }}" method="{{ method }}">
    {% for campo in campos %}
    <label for="{{ campo.nombre }}">{{ campo.etiqueta|e }}:</label>
    <input type="{{ campo.tipo|e }}" id="{{ campo.nombre|e }}" name="{{ campo.nombre|e }}">
    {% endfor %}
    <button type="submit">Enviar</button>
</form>

En el código PHP:

<?php
require_once 'vendor/autoload.php';

$loader = new \Twig\Loader\FilesystemLoader('ruta/a/templates');
$twig = new \Twig\Environment($loader);

echo $twig->render('formulario.twig', [
    'action' => 'procesar.php',
    'method' => 'post',
    'campos' => $campos,
]);

Al utilizar plantillas, mantenemos la lógica de negocio separada de la vista, siguiendo principios de buenas prácticas.

Consideraciones importantes

Validación y sanitización: Es crucial validar y sanitizar los datos tanto al generar como al procesar el formulario para evitar problemas de seguridad.
Accesibilidad: Asegurar que los formularios generados cumplan con estándares de accesibilidad, utilizando etiquetas <label>, atributos id y name correctamente.
Experiencia de usuario: Considerar el impacto en la usabilidad al mostrar u ocultar elementos dinámicamente.

Integración con JavaScript

Para mejorar la interactividad, podemos combinar la generación dinámica en PHP con JavaScript:

<?php
echo '<form id="miFormulario" action="submit.php" method="post">' . "\n";
echo '<label for="opcion">Opción:</label>' . "\n";
echo '<select id="opcion" name="opcion">' . "\n";
echo '<option value="1">Opción 1</option>' . "\n";
echo '<option value="2">Opción 2</option>' . "\n";
echo '</select>' . "\n";
echo '<div id="camposAdicionales">' . "\n";
// Campos adicionales serán insertados aquí con JavaScript
echo '</div>' . "\n";
echo '<button type="submit">Enviar</button>' . "\n";
echo '</form>' . "\n";

Y en un script JavaScript:

document.getElementById('opcion').addEventListener('change', function () {
    var seleccion = this.value;
    var camposAdicionales = document.getElementById('camposAdicionales');
    camposAdicionales.innerHTML = '';
    if (seleccion === '1') {
        camposAdicionales.innerHTML += '<label for="campo1">Campo Adicional 1:</label>\n';
        camposAdicionales.innerHTML += '<input type="text" id="campo1" name="campo1">\n';
    } else if (seleccion === '2') {
        camposAdicionales.innerHTML += '<label for="campo2">Campo Adicional 2:</label>\n';
        camposAdicionales.innerHTML += '<input type="text" id="campo2" name="campo2">\n';
    }
});

Con esta combinación, podemos crear formularios altamente dinámicos, mejorando la usabilidad y la experiencia de usuario sin recargar la página.

Seguridad en formularios dinámicos

Al generar formularios de forma dinámica, es fundamental prestar atención a la seguridad:

Evitar inyección de código: Sanitizar todas las salidas usando funciones como htmlspecialchars para prevenir ataques XSS.
Validación en servidor: No confiar únicamente en la validación del lado del cliente; validar los datos en el servidor es imprescindible.
Tokens CSRF: Implementar tokens anti-CSRF en formularios para proteger contra ataques de falsificación de solicitudes.

Mejores prácticas

Separación de responsabilidades: Mantener la generación del formulario separada de la lógica de procesamiento.
Código limpio y comentado: Escribir código legible y añadir comentarios cuando sea necesario facilita el mantenimiento y la colaboración.
Uso de estándares: Adoptar estándares y convenciones reconocidas mejora la calidad y consistencia del código.

Al aplicar estas técnicas y consideraciones, podemos implementar formularios dinámicos en PHP que sean eficientes, seguros y fáciles de mantener, mejorando significativamente el desarrollo de aplicaciones web interactivas.

Aprendizajes de esta lección de PHP

Comprender el concepto de separación de lógica de negocio y vista.
Aplicar el patrón MVC en PHP.
Desarrollar aplicaciones con código limpio y sostenible.
Mejorar la legibilidad y la colaboración en proyectos de programación.
Implementar procesos de validación de formularios efectivos.

Completa este curso de PHP y certifícate

Únete a nuestra plataforma de cursos de programación y accede a miles de tutoriales, ejercicios prácticos, proyectos reales y nuestro asistente de IA personalizado para acelerar tu aprendizaje.

Asistente IA

Resuelve dudas al instante

Ejercicios

Practica con proyectos reales

Certificados

Valida tus conocimientos

Comenzar PHP gratis

Más de 25.000 desarrolladores ya se han certificado con CertiDevs

⭐⭐⭐⭐⭐

4.9/5 valoración

Formularios dinámicos y separación de lógica

Mira la lección en vídeo

Buenas prácticas en la separación de la lógica de negocio y la vista (MVC básico)

Generación dinámica de formularios en función de la lógica de la aplicación

Guarda tu progreso

Técnicas para generar formularios dinámicamente

Uso de bucles y estructuras de datos

Generación basada en condiciones

Generación a partir de datos de base de datos

Modularización con funciones o clases

Uso de templates y motores de plantillas

Consideraciones importantes

Integración con JavaScript

Seguridad en formularios dinámicos

Mejores prácticas

Aprendizajes de esta lección de PHP

Completa este curso de PHP y certifícate

Asistente IA

Ejercicios

Certificados