To handle custom validation in Laravel, you can create reusable rule classes, use inline closures for one-time checks, and centralize repeated rules via helper functions or traits. First, generate a rule class with php artisan make:rule, define the passes() and message() methods, then apply it in validation. Second, use inline closures directly in validation arrays for simple, non-reusable logic. Third, centralize common rules using helper functions or traits to ensure consistency and ease of maintenance across multiple forms.

When you need more control over input validation in Laravel, custom validation rules are the way to go. The built-in rules like required, email, or max cover a lot of ground, but sometimes your app needs something specific — like checking if a username contains certain characters, or validating a custom phone number format.

Here’s how to define and use custom validation rules effectively without overcomplicating things.

Creating a Custom Rule Class

Laravel makes it easy to generate reusable validation logic through rule classes. You can create one using Artisan:

php artisan make:rule AlphaDashWithUnderscore

This generates a class in the app/Rules directory. Inside the passes() method, write your condition. For example, if you want to allow only letters, numbers, dashes, and underscores:

public function passes($attribute, $value)
{
    return preg_match('/^[A-Za-z0-9-_] $/', $value) === 1;
}

Then in the message() method, provide a clear error message:

public function message()
{
    return 'The :attribute may only contain letters, numbers, dashes, and underscores.';
}

You can then use this rule anywhere in your form requests or controller validation:

use App\Rules\AlphaDashWithUnderscore;

$request->validate([
    'username' => ['required', new AlphaDashWithUnderscore],
]);

Using Inline Closures for Quick Validation

If your rule is simple and not reused often, an inline closure might be better. It keeps everything in one place and avoids extra files.

For example, when validating a phone number with a specific country code:

$validated = $request->validate([
    'phone' => [
        'required',
        function ($attribute, $value, $fail) {
            if (!str_starts_with($value, ' 1')) {
                $fail('Phone number must start with  1.');
            }
        },
    ],
]);

This works well for small checks that are only needed once. Just keep in mind that these closures can’t be reused elsewhere unless you abstract them later.

Reusing Rules Across Multiple Forms

If you find yourself repeating the same validation logic in multiple places, consider centralizing it. One way is by creating a helper function or trait that returns the rule array.

For example:

function validUsername()
{
    return [
        'required',
        'min:3',
        'max:20',
        new AlphaDashWithUnderscore,
    ];
}

Now in any validation call:

$request->validate([
    'username' => validUsername(),
]);

This keeps your validation clean and consistent across different parts of the app.

Also, if you ever change the requirements (like allowing periods), you only have to update the rule in one place.

Bonus Tip: Combine with Existing Rules

Custom rules don't have to replace Laravel's defaults — they can work alongside them. This gives you flexibility without reinventing the wheel.

For instance, if you're validating a "slug" field, you might mix built-in and custom rules:

'slug' => [
    'required',
    'alpha_dash',
    new ValidSlugFormat,
],

Here, alpha_dash ensures basic formatting, and ValidSlugFormat could add extra logic like disallowing double hyphens or enforcing lowercase.

That’s basically how you handle custom validation in Laravel. Whether you're building a rule class, using a closure, or reusing shared logic, the key is keeping it readable and maintainable. Not too complicated, but definitely useful once your app starts needing more than just the basics.

The above is the detailed content of Defining and using custom validation rules in Laravel. For more information, please follow other related articles on the PHP Chinese website!