Formularios en PHP: procesar, validar y volver a mostrar

Un formulario PHP se envía al mismo script que lo imprimió: escribe <form method="post"> con campos con nombre y, cuando $_SERVER['REQUEST_METHOD'] sea 'POST', lee cada campo como $_POST['name']. Escapa con htmlspecialchars() todo lo que vuelvas a imprimir.

Ejecuta este bloque, escribe un nombre en el formulario y pulsa Send: el mismo script se ejecuta otra vez, ahora con $_POST lleno.

<?php
$name = '';
if (($_SERVER['REQUEST_METHOD'] ?? 'GET') === 'POST') {
    $name = trim($_POST['name'] ?? '');
}
?>
<form method="post">
  <label>Your name <input name="name" value="<?= htmlspecialchars($name) ?>"></label>
  <button>Send</button>
</form>
<?php if ($name !== ''): ?>
  <p>Hello, <?= htmlspecialchars($name) ?>.</p>
<?php endif; ?>

Aquí pasan tres cosas que necesita cualquier manejador de formularios:

• La comprobación del método. En la primera visita la petición es un GET y no hay nada que procesar. ?? 'GET' solo importa cuando el archivo se ejecuta desde la línea de comandos, donde REQUEST_METHOD no está definido; en un servidor web siempre lo está.
• ?? '' en cada campo. Un campo puede faltar (un input renombrado, una petición enviada por un script), y leer una clave que falta imprime un warning.
• Escapar en la salida. El nombre vuelve a la página dos veces, y htmlspecialchars() garantiza que un valor como <b>Ada</b> se muestre como texto en lugar de convertirse en marcado. Los detalles están en la página de htmlspecialchars.

Validar un formulario y mostrar los errores junto a los campos

Reúne los errores en un array cuyas claves sean los nombres de los campos. Si el array está vacío, el formulario es válido; si no, vuelve a imprimir el formulario con cada mensaje bajo su campo y lo que escribió el visitante todavía en su sitio. Envíalo vacío, luego con un email incorrecto y luego con valores válidos.

<?php
$values = ['name' => '', 'email' => '', 'age' => ''];
$errors = [];
$sent = false;

if (($_SERVER['REQUEST_METHOD'] ?? 'GET') === 'POST') {
    foreach ($values as $field => $_) {
        $values[$field] = trim((string) ($_POST[$field] ?? ''));
    }

    if ($values['name'] === '') {
        $errors['name'] = 'Please enter your name.';
    } elseif (mb_strlen($values['name']) > 50) {
        $errors['name'] = 'Use 50 characters or fewer.';
    }

    if (filter_var($values['email'], FILTER_VALIDATE_EMAIL) === false) {
        $errors['email'] = 'That does not look like an email address.';
    }

    $age = filter_var($values['age'], FILTER_VALIDATE_INT, ['options' => ['min_range' => 13, 'max_range' => 120]]);
    if ($age === false) {
        $errors['age'] = 'Enter a whole number from 13 to 120.';
    }

    $sent = $errors === [];
}

function e(string $s): string
{
    return htmlspecialchars($s, ENT_QUOTES, 'UTF-8');
}
?>
<style>.err { color: #c62828; margin: 2px 0 10px; } label { display: block; margin-top: 8px; }</style>
<?php if ($sent): ?>
  <p>Thanks, <?= e($values['name']) ?>. We will write to <?= e($values['email']) ?>.</p>
<?php else: ?>
  <form method="post" novalidate>
    <label>Name <input name="name" value="<?= e($values['name']) ?>"></label>
    <?php if (isset($errors['name'])): ?><p class="err"><?= e($errors['name']) ?></p><?php endif; ?>

    <label>Email <input name="email" value="<?= e($values['email']) ?>"></label>
    <?php if (isset($errors['email'])): ?><p class="err"><?= e($errors['email']) ?></p><?php endif; ?>

    <label>Age <input name="age" value="<?= e($values['age']) ?>"></label>
    <?php if (isset($errors['age'])): ?><p class="err"><?= e($errors['age']) ?></p><?php endif; ?>

    <button>Sign up</button>
  </form>
<?php endif; ?>

novalidate desactiva las comprobaciones del propio navegador para que veas funcionar las de PHP. En un formulario real, mantén las dos: la validación del navegador es una comodidad para el visitante, la de PHP es la que cuenta, porque cualquiera puede enviar una petición sin tu formulario. filter_var() comprueba el email y el rango del entero con una llamada cada uno; la página de filter_var explica sus otros filtros.

Casillas, botones de radio y select

Un campo de texto siempre envía un valor, aunque sea vacío. Los demás controles no:

• Una casilla sin marcar no envía nada, así que su clave falta en $_POST.
• Las casillas llamadas topics[] llegan como un array: $_POST['topics'] es ['php', 'sql'].
• Un grupo de radio o un <select> envía el value de la opción elegida.

Para conservar la elección tras el envío, imprime checked o selected en la opción que coincida. Marca unas cuantas casillas, elige un nivel y pulsa Save.

<?php
$topics = ['php' => 'PHP', 'sql' => 'SQL', 'js' => 'JavaScript'];
$levels = ['new' => 'New to coding', 'some' => 'Some experience', 'pro' => 'Professional'];

$picked = $_POST['topics'] ?? [];
$picked = is_array($picked) ? array_values(array_intersect($picked, array_keys($topics))) : [];

$level = $_POST['level'] ?? 'new';
if (!is_string($level) || !array_key_exists($level, $levels)) {
    $level = 'new';
}
?>
<form method="post">
  <p>Topics:
  <?php foreach ($topics as $key => $label): ?>
    <label><input type="checkbox" name="topics[]" value="<?= $key ?>"
      <?= in_array($key, $picked, true) ? 'checked' : '' ?>> <?= $label ?></label>
  <?php endforeach; ?>
  </p>
  <p>Level:
    <select name="level">
    <?php foreach ($levels as $key => $label): ?>
      <option value="<?= $key ?>" <?= $key === $level ? 'selected' : '' ?>><?= $label ?></option>
    <?php endforeach; ?>
    </select>
  </p>
  <button>Save</button>
</form>
<p>You picked: <?= $picked ? implode(', ', array_map(fn ($k) => $topics[$k], $picked)) : 'nothing yet' ?>
  (<?= $levels[$level] ?>)</p>

Las dos comprobaciones tras leer la entrada importan más de lo que parece. array_intersect() descarta cualquier tema que no estuviera en tu lista, y la comprobación con is_string() más array_key_exists() devuelve el nivel a un valor por defecto si alguien envía un valor que nunca ofreciste (o un array, que haría que $levels[$level] lanzara un error). Un select limita lo que puede enviar un navegador, no lo que puede contener una petición.

Formularios de varios pasos con campos ocultos

Un input oculto lleva un valor de un paso al siguiente sin mostrarlo. Aquí el paso 1 pide un nombre, el paso 2 pide un idioma y envía el nombre en un campo oculto, y el paso 3 muestra los dos. Recorre los tres pasos.

<?php
$name = trim((string) ($_POST['name'] ?? ''));
$lang = (string) ($_POST['lang'] ?? '');
$step = $name === '' ? 1 : ($lang === '' ? 2 : 3);
$e = fn (string $s) => htmlspecialchars($s, ENT_QUOTES, 'UTF-8');
?>
<p>Step <?= $step ?> of 3</p>
<?php if ($step === 1): ?>
  <form method="post">
    <label>Name <input name="name"></label> <button>Next</button>
  </form>
<?php elseif ($step === 2): ?>
  <form method="post">
    <input type="hidden" name="name" value="<?= $e($name) ?>">
    <p>Hi <?= $e($name) ?>, which language do you want to learn?</p>
    <label><input type="radio" name="lang" value="PHP" checked> PHP</label>
    <label><input type="radio" name="lang" value="Python"> Python</label>
    <button>Next</button>
  </form>
<?php else: ?>
  <p><?= $e($name) ?> wants to learn <?= $e($lang) ?>.</p>
<?php endif; ?>

Los campos ocultos se ven en el código fuente de la página y se pueden editar como cualquier otro campo, así que sirven para llevar las propias respuestas del visitante entre pasos, pero nunca para un precio, un id de usuario o un rol. Guarda eso en el servidor, en una sesión; consulta sesiones y cookies.

Post/Redirect/Get: evitar el reenvío al recargar

Después de un POST correcto, si el script imprime directamente una página de "gracias", pulsar recargar hace que el navegador vuelva a enviar el POST, y el pedido o el comentario se guarda dos veces. La solución es guardar, redirigir y mostrar el resultado en un GET:

<?php
session_start();

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $errors = validate($_POST);
    if (!$errors) {
        save_comment($_POST);
        $_SESSION['flash'] = 'Comment posted.';
        header('Location: /comments.php', true, 303);
        exit;
    }
    // On errors, fall through and print the form with the messages.
}

$flash = $_SESSION['flash'] ?? null;
unset($_SESSION['flash']);

303 See Other le dice al navegador que siga la redirección con un GET. El exit después de header() importa: sin él, el resto del script sigue ejecutándose. La redirección además tiene que ocurrir antes de cualquier salida, o PHP se niega con "headers already sent".

Los formularios reales añaden también un token CSRF: un valor aleatorio guardado en la sesión y en un campo oculto, comparado con hash_equals() al enviar, para que otro sitio no pueda enviar tu formulario en nombre de un visitante que ha iniciado sesión.

Probar la validación sin navegador

Pon las reglas en una función que reciba un array y devuelva los errores. La página la llama con $_POST, y tú puedes llamarla con cualquier array, lo que facilita probar los casos límite. Añade tus propios casos a la lista.

<?php
function validateSignup(array $input): array
{
    $errors = [];
    $name = $input['name'] ?? '';
    $email = $input['email'] ?? '';

    if (!is_string($name) || trim($name) === '') {
        $errors['name'] = 'required';
    }
    if (!is_string($email) || filter_var($email, FILTER_VALIDATE_EMAIL) === false) {
        $errors['email'] = 'invalid';
    }
    return $errors;
}

$cases = [
    ['name' => 'Ada', 'email' => 'ada@example.com'],
    ['name' => '   ', 'email' => 'ada@example.com'],
    ['name' => 'Ada', 'email' => 'ada@'],
    ['name' => ['x'], 'email' => 'ada@example.com'],
    [],
];

foreach ($cases as $case) {
    echo json_encode($case), ' => ', json_encode(validateSignup($case)), "\n";
}

El cuarto caso es el que la gente olvida. Una petición puede enviar name[]=x, lo que convierte $_POST['name'] en un array, y pasar un array a trim() lanza un TypeError y detiene el script. Comprobar antes is_string() convierte una entrada hostil en un error de validación normal. El cast (string) de los bloques anteriores también evita el TypeError, pero convierte el array en la palabra Array e imprime un warning, así que is_string() es la comprobación más limpia.

Error frecuente: leer $_POST antes de que se envíe el formulario

El primer script de formulario más común lee los campos al principio del archivo:

<?php
$name = $_POST['name'];
echo "Hello, $name";

En la primera visita no se ha enviado nada, así que PHP imprime:

Warning: Undefined array key "name" in /var/www/form.php on line 2

La solución es el patrón del primer bloque: procesa el formulario solo cuando la petición sea un POST, y lee cada campo con un valor por defecto, $_POST['name'] ?? ''. Si el warning aparece después de enviar, compara el atributo name del HTML con la clave de PHP: name="Name" y $_POST['name'] son claves distintas.