Ahora más que nunca, es crucial que los datos de tus aplicaciones sean válidos, precisos y cumplan todos los requisitos del sistema. Aborda la necesidad de mantener la coherencia de los datos y evitar vulnerabilidades de seguridad.

Laravel hace que la validación de datos sea fácil e intuitiva. Sigue una arquitectura modelo vista controlador (MVC) y sólo requiere conocimientos generales de PHP y conceptos de programación orientada a objetos (OOP). Además, Laravel ofrece varios métodos para validar los datos entrantes.

Explora algunos de estos métodos y cómo aplicar reglas de validación a tu conjunto de datos.

La Validación de Datos es Fácil en Laravel

Laravel proporciona varias reglas de validación listas para usar cuando los usuarios de tu aplicación envían datos a través de formularios. Puedes marcar los campos de entrada como obligatorios, establecer una longitud mínima o máxima, y exigir entradas únicas (no duplicadas) y direcciones de correo electrónico válidas. El validador de Laravel comprueba si la entrada cumple estas reglas o cualquier otra que especifiques.

Estas reglas de validación de Laravel incluyen:

  • required – Los datos del campo no deben ser nulos ni estar vacíos.
  • array – Los datos del campo deben ser un array PHP.
  • bail – La regla de validación deja de ejecutarse cuando encuentra el primer fallo de validación.
  • email – Los datos del campo deben ser una dirección de correo electrónico válida.
  • unique – Los datos del campo no deben tener duplicados en la tabla de la base de datos.

Todos los métodos de validación tienen pros y contras, pero su variedad te permite elegir el mejor enfoque para tus necesidades. Dependiendo del método que elijas, la validación en Laravel puede producirse de varias formas, con mensajes de error manuales o automáticos.

El método más común es code>validate, utilizado para las peticiones HTTP entrantes. Este método se encadena a los datos de la petición, ejecutando las reglas de validación. Puedes separar las reglas de cada campo con comas, como se ve en el ejemplo siguiente.

use Illuminate\Http\Request;
 
public function store (Request $request){
  $validated = $request->validate([
        'email' => ['required, unique:users, email, bail'],
        'name' => ['required'],
    ]);

}

Aquí, email es una entrada obligatoria, lo que significa que no puede ser nula. Además, debe ser único en la tabla de la base de datos users, para garantizar que no se registra dos veces la misma dirección de correo electrónico. La última regla dicta que la dirección de correo electrónico también debe ser válida. De lo contrario, el proceso de validación se detiene. El campo nombre es obligatorio, pero no tiene ninguna otra regla.

Si falla alguna regla de validación de Laravel, se genera automáticamente una respuesta.

Conceptos Básicos de Validación

Para comprender mejor los métodos de validación, considera el siguiente ejemplo. Definirás una ruta para el endpoint y crearás un controlador para validar y procesar los datos de la solicitud.

En primer lugar, crea un endpoint sencillo que permita a los usuarios almacenar sus correos electrónicos y contraseñas.

Definir la Ruta

Las rutas de Laravel se definen en el archivo routes/web.php para una aplicación web o routes/api.php para una API. Para este ejemplo, utiliza api.php:

use App\Http\Controllers\UserController;
 
Route::post('/store', [UserController::class]);

Crear el Controlador

Ejecuta este comando de Artisan para crear el controlador:

php artisan make:controller

UserController

Este comando crea un archivo UserController.php en el directorio app/Http/Controllers.

Ahora, define un método store para validar los datos que entran en el endpoint de la tienda antes de almacenarlos.

Este ejemplo validará los siguientes campos utilizando estas reglas:

  • correo electrónico — Debe ser único, un correo electrónico válido, y debe ser obligatorio
  • contraseña — Debe tener una longitud mínima, una confirmación de contraseña y debe ser obligatoria
  • edad — Debe ser un número y debe ser obligatorio
<?php

namespace App\Http\Controllers;
use Illuminate\Http\Request;
class UserController extends Controller
{
    /**
     * Store new user details.
     *
     */
    public function store(Request $request){
        $validated = $request->validate([
            'email' => 'required|unique:users|email',
            'age' => 'required|numeric',
            'password' => 'required|min:7|confirmed'
        ]);
        // After user data is validated, logic to store the data
    }

}

La regla confirmed te permite requerir un campo concreto dos veces para verificar que los datos son correctos, como por ejemplo que los usuarios vuelvan a introducir sus contraseñas durante el registro. Esta regla requiere un campo llamado password_confirmation, cuyos datos deben coincidir con los del campo contraseña.

Mostrar Mensajes de Error

Si se cumplen los criterios de validación, tu código seguirá ejecutándose normalmente. Si la validación falla, se lanza una excepción IlluminateValidationValidationException y se devuelve la respuesta de error apropiada.

El ejemplo se basa en una API, que devuelve una respuesta HTTP 422 Unprocessable Entity en formato JSON. En el caso de las aplicaciones web, redirigiría a la URL anterior para mostrar el mensaje de error, y los datos de la solicitud pasarían a la sesión.

Puedes utilizar la variable $errors en tus vistas para mostrar los errores devueltos:

@if ($errors->any())
    <div class="alert alert-danger">
        <ul>
            @foreach ($errors->all() as $error)
                <li>{{ $error }}</li>
            @endforeach
        </ul>
    </div>
@endif

También puedes elegir ver sólo el primer error o hacer un bucle para verlos todos.

// Fetch all errors
$errors->all()

// Fetch only the first error
$errors->first()

Repoblar Formularios

La repoblación de formularios evita que los usuarios tengan que volver a escribir la información para que puedan centrarse en solucionar el error. En el ejemplo del fallo de una dirección de correo electrónico, puedes repoblar el resto del formulario llamando al valor antiguo del campo name.

$name = $request-> old('name')

//Blade helper
<input type="text" name="name" value="{{ old('name') }}">

Esta regla devolvería null si no hubiera ninguna entrada anterior.

Validación Avanzada

Laravel proporciona otro método para escribir validaciones llamado peticiones de formulario. Una solicitud de formulario es una clase de solicitud personalizada que organiza las validaciones y simplifica tu controlador.

Tienen su propia lógica de validación y autorización adecuada para grandes volúmenes de entrada y pueden utilizarse para definir reglas de validación y personalizar los mensajes de error.

Para crear una solicitud de formulario, ejecuta este comando de Artisan:

php artisan make:request StoreUserRequest

Este comando crea un archivo StoreUserRequest.php en el directorio app/Http/Requests y contiene dos métodos por defecto:

  • rules devuelve reglas de validación para los datos de la solicitud
  • authorize devuelve un booleano para indicar si ese usuario tiene permiso para realizar la acción solicitada.

Convierte el ejemplo anterior para utilizar una solicitud de formulario.

<?php

namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class StoreUserRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     *
     * @return bool
     */
    public function authorize()
    {
        // Add logic to check if the user is authorized to submit this data.
        return true;
    }
    /**
     * Get the validation rules that apply to the request.
     *
     * @return array<string, mixed>
     */
    public function rules()
    {
        return [
            'email' => 'required|unique:users|email',
            'age' => 'required|numeric',
            'password' => 'required|min:7|confirmed'
        ];
    }

}

Para personalizar los mensajes de error de estas reglas, puedes anular el método messages de la clase FormRequest.

/**

     * Get the error messages for the defined validation rules.
     *
     * @return array
     */
    public function messages()
    {
        return [
            'email.required' => 'An email address is required',
            'email.email' => 'The email address must be valid',
            'password.confirmed'=>'Re-type your password as 
password_confirmation, passwords does not match'
        ];

    }

Nota: El nombre de los datos y la regla de validación van separados por un punto (.) antes de los datos del mensaje.

Validación Personalizada

Para crear una validación personalizada, puedes utilizar una fachada Validator en lugar de validate. La instancia del validador contiene dos argumentos: los datos que se van a validar y una matriz de reglas de validación. Estos dos argumentos se pasan al método ::make de la fachada del validador, generando una nueva instancia del validador.

use Illuminate\Http\Request; 

public function store (Request $request){
        $validator = Validator::make($request->all(),[
            'email' => 'required|unique:users|email',
            'age' => 'required|numeric',
            'password' => 'required|min:7|confirmed'
        ]);
        if ($validator->fails()) {
            // Return errors or redirect back with errors
            return $validator->errors();
        }
 
        // Retrieve the validated input...
        $validated = $validator->validated();
        // Continue logic to store the data

    }

Si quieres añadir una directa automática, puedes ejecutar el método validate en una instancia de validador preexistente. Si la validación falla, una petición XHR produce una respuesta JSON con 422 Unprocessable Entity como código de estado, o el usuario será redirigido inmediatamente.

$validator = Validator::make($request->all(),[
'email' => 'required|unique:users|email',
'password' => 'required|min:7|confirmed'
])->validate();

También puedes personalizar tus mensajes de error pasando un tercer argumento llamado messages a Validate::make method:

$validator = Validator::make($request->all(),[
            'email' => 'required|unique:users|email',
            'age' => 'required|numeric',
            'password' => 'required|min:7|confirmed'
        ], $messages = [
            'required' => 'The :attribute field is required.',
]);

Nota: El :attribute se sustituye por el nombre del campo sometido a validación.

Resumen

Realizar la validación de datos es crucial para mantener tu conjunto de datos limpio, correcto y completo. La validación de datos te permite eliminar errores en tus datos que podrían corromper o afectar de otro modo a tu proyecto. La validación es cada vez más importante cuando se trabaja a escala y con grandes cantidades de datos.

Laravel permite numerosos enfoques flexibles para garantizar la integridad y exactitud de los datos que pasan por tu aplicación. Puedes conseguir una lógica de validación complicada con métodos predeterminados y personalizables, haciendo que tu código base esté bien estructurado y sea más fácilmente reutilizable.

Envía tus aplicaciones Laravel más rápido con los servicios de alojamiento de aplicaciones de Kinsta.

Jeremy Holcombe Kinsta

Editor de Contenidos y Marketing en Kinsta, Desarrollador Web de WordPress y Redactor de Contenidos. Aparte de todo lo relacionado con WordPress, me gusta la playa, el golf y el cine. También tengo problemas con la gente alta ;).