Requests

Introducción a requests

En el desarrollo web, cada interacción del usuario con nuestra aplicación se materializa a través de solicitudes HTTP que contienen información valiosa. Laravel proporciona una forma elegante y consistente de manejar estas solicitudes mediante el objeto Request, que actúa como una interfaz unificada para acceder a todos los datos enviados por el cliente.

El objeto Request de Laravel encapsula toda la información de una petición HTTP: datos de formularios, parámetros de URL, archivos subidos, headers, cookies y mucho más. Esta abstracción nos permite trabajar de manera fluida con los datos de entrada sin preocuparnos por los detalles de bajo nivel del protocolo HTTP.

Acceso al objeto Request

Laravel inyecta automáticamente el objeto Request en nuestros métodos de controlador cuando lo especificamos como parámetro. Esta funcionalidad, conocida como inyección de dependencias, hace que trabajar con requests sea extraordinariamente sencillo:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class UserController extends Controller
{
    public function store(Request $request)
    {
        // El objeto $request contiene todos los datos de la solicitud
        $name = $request->input('name');
        $email = $request->input('email');
        
        // Procesar los datos...
    }
}

También podemos acceder al request actual desde cualquier lugar de nuestra aplicación utilizando el helper global request() o la facade Request:

use Illuminate\Support\Facades\Request;

// Usando el helper global
$name = request('name');

// Usando la facade
$name = Request::input('name');

Obtención de datos de entrada

El método más versátil para obtener datos es input(), que busca el valor tanto en datos POST como en parámetros de URL. Si el campo no existe, podemos especificar un valor por defecto:

// Obtener un campo específico
$name = $request->input('name');

// Con valor por defecto
$name = $request->input('name', 'Usuario Anónimo');

// Obtener todos los datos de entrada
$allData = $request->all();

// Obtener solo campos específicos
$userData = $request->only(['name', 'email']);

// Obtener todos excepto campos específicos
$safeData = $request->except(['password', '_token']);

Para trabajar con arrays en formularios, Laravel maneja automáticamente la notación de puntos:

// Para un campo como: <input name="products[0][name]">
$productName = $request->input('products.0.name');

// Para obtener todo el array de productos
$products = $request->input('products');

Verificación de presencia de datos

Frecuentemente necesitamos verificar si ciertos campos están presentes en la solicitud. Laravel ofrece varios métodos útiles para estas comprobaciones:

// Verificar si existe un campo (incluso si está vacío)
if ($request->has('name')) {
    // El campo 'name' está presente
}

// Verificar múltiples campos
if ($request->has(['name', 'email'])) {
    // Ambos campos están presentes
}

// Verificar si un campo tiene valor (no está vacío)
if ($request->filled('name')) {
    // El campo 'name' tiene un valor
}

// Verificar si un campo está ausente
if ($request->missing('optional_field')) {
    // El campo no está presente
}

Datos de formularios específicos

Laravel diferencia entre distintos tipos de datos que pueden llegar en una solicitud:

// Obtener datos de query string (?name=valor)
$name = $request->query('name');

// Obtener datos POST/PUT
$name = $request->post('name');

// Obtener cookies
$theme = $request->cookie('theme');

// Obtener headers
$userAgent = $request->header('User-Agent');
$bearerToken = $request->bearerToken();

Información sobre la solicitud

El objeto Request también proporciona información contextual valiosa sobre la solicitud:

// Obtener la URL completa
$fullUrl = $request->fullUrl();

// Obtener solo el path
$path = $request->path(); // retorna 'users/create'

// Verificar el método HTTP
if ($request->isMethod('POST')) {
    // Es una solicitud POST
}

// Obtener el método HTTP
$method = $request->method(); // GET, POST, PUT, DELETE...

// Verificar si es una solicitud AJAX
if ($request->ajax()) {
    // Solicitud realizada via JavaScript
}

// Verificar si espera JSON
if ($request->expectsJson()) {
    // El cliente espera una respuesta JSON
}

Validación básica integrada

Aunque la validación avanzada se tratará en lecciones posteriores, el objeto Request incluye métodos básicos para validar datos sobre la marcha:

// Validación simple inline
$validatedData = $request->validate([
    'name' => 'required|string|max:255',
    'email' => 'required|email|unique:users',
    'age' => 'required|integer|min:18'
]);

// Si la validación falla, Laravel automáticamente
// redirige de vuelta con los errores

Manejo de archivos subidos

Los archivos subidos se gestionan de forma intuitiva a través del objeto Request:

// Verificar si se subió un archivo
if ($request->hasFile('avatar')) {
    $file = $request->file('avatar');
    
    // Información del archivo
    $fileName = $file->getClientOriginalName();
    $fileSize = $file->getSize();
    $mimeType = $file->getMimeType();
    
    // Verificar si el archivo es válido
    if ($file->isValid()) {
        // Procesar el archivo...
    }
}

Persistencia de datos en formularios

Una característica especialmente útil es la persistencia de datos cuando hay errores de validación. Laravel automáticamente mantiene los valores enviados disponibles en la siguiente petición:

// En el controlador - los datos se mantienen automáticamente
public function store(Request $request)
{
    $request->validate([
        'email' => 'required|email|unique:users'
    ]);
    
    // Si la validación falla, los datos se mantienen
}

// En la vista Blade - recuperar datos anteriores
<input type="text" name="email" value="{{ old('email') }}">

El objeto Request de Laravel transforma la complejidad del manejo de datos HTTP en una experiencia fluida y expresiva. Su diseño permite que nos centremos en la lógica de negocio de nuestra aplicación, mientras Laravel se encarga de los detalles técnicos de la comunicación HTTP. En las siguientes secciones del curso exploraremos cómo complementar este manejo de entrada de datos con respuestas HTTP apropiadas y técnicas avanzadas de validación.