Validate if exists

In some cases, validation checks can only be performed on a field if it exists in the array. This can be achieved by adding sometimes to the rule list:

$v = Validator::make($data, [    'email' => 'sometimes|required|email',]);

In the above example, the email field only exists in the $data array will be verified.

{tip} If you are trying to validate a field that should always be present but may be empty, please review Notes on Optional Fields

Complex conditional validation

Sometimes you may need to add validation rules based on more complex conditional logic. For example, you might want a specified field to be required only if the value of another field exceeds 100. Or when a specified field exists, the other two fields can have the given value. Adding such verification conditions is not difficult. First, create a Validator instance using a static rule:

$v = Validator::make($data, [  
  'email' => 'required|email',    
  'games' => 'required|numeric',
]);

Let’s say we have a web application designed for game collectors. If a game collector has more than a hundred games, we'd like them to explain why they own so many games. For example, they might run a game distribution store, or just enjoy collecting. To include this validation requirement under certain conditions, you can use the sometimes method on the Validator instance.

$v->sometimes('reason', 'required|max:500', function ($input) {  
  return $input->games >= 100;
});

Pass in the first parameter of the sometimes method is the name of the field to be used for verification. The second parameter is the validation rule we want to use. Closure is passed in as the third parameter. If it returns true, additional rules will be added. This method makes it easy to create complex conditional validations. You can even add conditional validation to multiple fields at once:

$v->sometimes(['reason', 'cost'], 'required', function ($input) {   
   return $input->games >= 100;
 });

{tip} The $input parameter passed into the closure is Illuminate An instance of \Support\Fluent that can be used to access your input or file objects.

Validate Array

It is not difficult to verify that the input of the form is an array field. You can use the "dot" method to validate properties in an array. For example, if the incoming HTTP request contains the photos[profile] field, it can be verified as follows:

$validator = Validator::make($request->all(), [  
  'photos.profile' => 'required|image',
]);

You can also verify each element in the array. For example, to verify that each email in the specified array input field is unique, you can do this:

$validator = Validator::make($request->all(), [  
  'person.*.email' => 'email|unique:users',    
  'person.*.first_name' => 'required_with:person.*.last_name',
]);

Similarly, you can use the * characters when defining verification information in the language file, Use a single validation message for array-based fields:

'custom' => [  
  'person.*.email' => [    
      'unique' => 'Each person must have a unique e-mail address',   
     ]
    ],

Custom validation rules

Using Rule Objects

Laravel provides many useful validation rules; it also supports custom rules. One way to register custom validation rules is to use a rule object. You can use the Artisan command make:rule to generate new rule objects. Next, let's use this command to generate a rule that validates that a string is uppercase. Laravel will store new rules in the app/Rules directory:

php artisan make:rule Uppercase

Once the rule is created, we can define its behavior. The rule object contains two methods: passes and message. The passes method receives the attribute value and name, and returns true or false depending on whether the attribute value conforms to the rules. The message method should return the validation error message that should be used if validation fails:

<?php
  namespace App\Rules;
  use Illuminate\Contracts\Validation\Rule;
  class Uppercase implements Rule{   
        /**
     * 判断验证规则是否通过。
     *
     * @param  string  $attribute
     * @param  mixed  $value
     * @return bool
     */   
    public function passes($attribute, $value)   
     {       
       return strtoupper($value) === $value;   
      }   
     /**
     * 获取验证错误消息。
     *
     * @return string
     */   
    public function message()  
      {       
       return 'The :attribute must be uppercase.';   
       }
      }

Of course, if you wish to return an error message from the translation file, you can do so from message Call the helper function in the method trans:

/**
 * 获取验证错误消息。
 *
 * @return string
 */
 public function message(){  
   return trans('validation.uppercase');
  }

Once the rule object is defined, you can pass an instance of the rule object to the validator along with other validation rules:

use App\Rules\Uppercase;$request->validate([  
  'name' => ['required', 'string', new Uppercase],
]);

Using Closures

If you only need the functionality of a custom rule once in your application, you can use Closures instead of rule objects. The closure receives the name of the property, the value of which should be used if validation fails $fail in the callback:

$validator = Validator::make($request->all(), [   
 'title' => [      
   'required',        
   'max:255',        
   function ($attribute, $value, $fail) {          
     if ($value === 'foo') {              
       $fail($attribute.' is invalid.');      
             }      
            },    
          ],
        ]);

Using extensions

Another way to register custom validation rules is to use the extend method in the Validator facade. Let's use this method in the service container to register custom validation rules:

<?php
  namespace App\Providers;
  use Illuminate\Support\ServiceProvider;
  use Illuminate\Support\Facades\Validator;
  class AppServiceProvider extends ServiceProvider{   
      /**
     * 引导任何应用程序。
     *
     * @return void
     */   
  public function boot()   
   {       
     Validator::extend('foo', function ($attribute, $value, $parameters, $validator) { 
        return $value == 'foo';  
         });   
       }    
     /**
     * 注册服务提供器。
     *
     * @return void
     */   
     public function register()   
      {       
       //   
       }
     }

The custom validation closure receives four parameters: the attribute name to be validated $attribute, attribute The value $value, the parameter array $parameters passed into the validation rule, and the Validator actual column.

In addition to using closures, you can also pass in classes and methods to the extend method:

Validator::extend('foo', 'FooValidator@validate');

Define error messages

You also need to define error messages for custom rules. You can achieve this functionality using an inline custom message array or by adding an entry in the validation language file. The message should be placed first in the array, not in the custom array that is only used to store attribute-specific error messages:

"foo" => "Your input was invalid!",
"accepted" => "The :attribute must be accepted.",
// 其余的验证错误消息...

When creating a custom validation rule, you There may be times when you need to define custom placeholders for error messages. This can be done by creating a custom validator and then calling the Replacer method on the Validator facade. You can perform the following operations in the boot method of the service container:

/**
 * 启动应用程序。
 *
 * @return void
 */
 public function boot(){  
   Validator::extend(...);    
   Validator::replacer('foo', function ($message, $attribute, $rule, $parameters) {    
       return str_replace(...);  
      });
 }

Implicit expansion

By default, when the attribute to be validated does not exist or contains a null value defined by the required rule, then normal validation Rules, including custom extensions will not be executed. For example, the unique rule will not verify the null value:

$rules = ['name' => 'unique'];
$input = ['name' => null];
Validator::make($input, $rules)->passes();
 // true

This is necessary if you require that the property be verified even if it is null The hint attribute is required. To create such an "implicit" extension, you can use the Validator::extendImplicit() method:

Validator::extendImplicit('foo', function ($attribute, $value, $parameters, $validator) { 
   return $value == 'foo';
  });

{note} "Implicit" extension only implies that the property is required of. Whether it's missing or null is up to you.