There are four main ways to create custom validation rules in Laravel. First, use Rule objects to add complex conditions, such as combining database queries and ignore methods to achieve unique verification; second, encapsulate custom logic in form requests, and reuse and clear structure by rewriting rules() method; third, use closures to write instant rules, suitable for simple judgment scenarios; fourth, create custom rule classes to make the organization clearer and easier for testing and team collaboration. Developers should choose appropriate verification methods based on specific business scenarios to improve code maintainability and development efficiency.

Creating custom validation rules in Laravel is not difficult, the key is to understand the several flexible ways the framework provides. Laravel native validators are already powerful, but some business logic may require you to write custom rules to ensure the accuracy of your data.

Add complex conditions using Rule objects

When your verification logic is a little more complicated, using Rule objects is a good choice. It is often used for database-related checks, such as determining whether a field is unique under specified conditions.

For example: Suppose you want to verify whether the email address already exists when editing user information, but you don’t want to count the current user’s email address as well:

 use Illuminate\Validation\Rule;

$request->validate([
    'email' => [
        'required',
        'email',
        Rule::unique('users')->ignore($user->id),
    ],
]);

This can avoid misjudging duplicate emails by ignoring IDs. You can also chain call the where method to further refine the query conditions.

Encapsulate custom logic in form request

If your verification rules are complicated or if the same logic is used in multiple places, it is recommended to use a custom form request (Form Request) . You can create a form request class through Artisan:

 php artisan make:request StorePostRequest

Then rewrite rules() method in the generated class and add your own logic:

 public function rules()
{
    Return [
        'title' => 'required|unique:posts|max:255',
        'body' => 'required',
    ];
}

You can also add custom judgments directly, such as deciding whether to allow posting of articles based on the user role.

Writing instant rules using closures

Sometimes you don't need too complex structures, just want to add a verification logic quickly, and you can use closures:

 'title' => [
    'required',
    function ($attribute, $value, $fail) {
        if (strtolower($value) === 'admin') {
            $fail('The '.$attribute.' cannot be "admin".');
        }
    },
],

This writing method is suitable for simple judgments, but is not suitable for handling too complex logic, otherwise it will make the code difficult to maintain.

Custom Rule Class: A clearer way to organize

For large projects or frequently reused rules, Laravel provides methods to create custom rule classes:

 php artisan make:rule ValidUsername

The generated class will have a passes() method and a message() method:

 class ValidUsername
{
    public function passes($attribute, $value)
    {
        return !preg_match('/\s/', $value);
    }

    public function message()
    {
        return 'Username cannot contain spaces. ';
    }
}

Then use it like this when verifying:

 'username' => ['required', new ValidUsername];

This approach is suitable for teamwork and is easier to test and reuse.

In general, Laravel offers a variety of ways to implement custom validation rules, and you can choose the most appropriate way based on the specific scenario. It is not complicated, but the details are easy to ignore: when to use closures, when to abstract them into classes, and how to write efficient rules based on database queries.

The above is the detailed content of Creating Custom Validation Rules in Laravel?. For more information, please follow other related articles on the PHP Chinese website!