In Laravel, custom validation rules can be implemented using rule objects, inline closures, form requests, and reusable parameterized rules. 1. Rule objects are created via php artisan make:rule, encapsulating reusable logic in the passes() method and used in validation with new RuleName. 2. Inline closures suit simple, one-off validations directly within the validation array, using a function with $attribute, $value, and $fail. 3. Form requests centralize validation logic by overriding the rules() method, keeping controllers clean. 4. Reusable rules with parameters allow dynamic checks across multiple fields by accepting arguments in their constructor and applying logic consistently.

In Laravel, custom validation rules give you more control when the built-in rules aren't enough. Whether you're validating complex business logic or checking data against external sources, Laravel provides clean and flexible ways to do this.

1. Using Rule Objects

One of the cleanest ways to implement custom validation is by creating a rule object using the make:rule Artisan command:

php artisan make:rule ValidDomainRule

This creates a new rule class in the app/Rules directory. Inside the passes() method, you define your logic — for example, checking if an email belongs to a specific domain:

public function passes($attribute, $value)
{
    return Str::endsWith($value, ['@company.com']);
}

Then, in your form request or controller:

use App\Rules\ValidDomainRule;

$request->validate([
    'email' => ['required', 'email', new ValidDomainRule],
]);

This keeps your validation reusable and separated from your controllers.

2. Inline Closures in Form Requests or Controllers

If the logic is simple and not reused often, you can write it inline using a closure directly in your validation array:

$request->validate([
    'username' => [
        'required',
        function ($attribute, $value, $fail) {
            if (in_array($value, ['admin', 'root'])) {
                $fail('The username is not allowed.');
            }
        },
    ],
]);

This is great for one-off checks where creating a full rule feels like overkill.

You can also use this approach inside form requests by returning the closure from a method.

3. Custom Validation in Form Requests

For more structured applications, especially when dealing with multiple validation rules per request, create a form request:

php artisan make:request StoreUserRequest

In the generated class, override the rules() method:

public function rules()
{
    return [
        'email' => [new ValidDomainRule],
        'username' => [function ($attribute, $value, $fail) {
            if (someCustomCheck($value)) {
                $fail('Invalid username.');
            }
        }],
    ];
}

This helps keep your controllers clean and your validation logic organized.

4. Reusing Rules Across Multiple Inputs

If you have a rule that applies to multiple fields (like checking if input is in a list of allowed values), create a reusable rule object that accepts parameters:

php artisan make:rule InAllowedListRule

Then, in the constructor, accept the allowed values:

protected $allowedValues;

public function __construct(array $allowedValues)
{
    $this->allowedValues = $allowedValues;
}

public function passes($attribute, $value)
{
    return in_array($value, $this->allowedValues);
}

Use it like this:

new InAllowedListRule(['user', 'admin'])

This makes your rule dynamic and reusable across different validations.

That’s how you work with custom validation rules in Laravel — whether through dedicated rule objects, inline closures, or form requests. It’s not complicated, but it gives you the flexibility to handle just about any validation need cleanly.

The above is the detailed content of How do I use custom validation rules in Laravel?. For more information, please follow other related articles on the PHP Chinese website!