Validator

Verifier definition

For the use of verifier, it must be defined; the system provides a command to directly produce a verifier class:

php think make:validate User

namespace app\validate;
use think\Validate;
class User extends Validate
{
    /**
     * Define validation rules
     * Format: 'field name' = > ['rule 1', 'rule 2'...]
     *      'Field name '= >' rule 1| rule 2... '
     *
     * @var array
     */	
	protected $rule = [
        'name'      =>      'require|max:20',
        'price'     =>      'number|between:1,100',
        'email'     =>      'email'
    ];
    
    /**
     * Define error messages
     * Format: 'field name. Rule name' = > 'error information'
     *
     * @var array
     */	
    protected $message = [
        'name.require'      =>  'Name cannot be empty',
        'name.max'          =>  'No more than 20 names',
        'price.number'      =>  'Price must be a number',
        'price.between'     =>  'Price at 1~100 Between',
        'email'             =>  'Mailbox format error'
    ];
}

After the verifier is defined, call the test to create a Verify.php controller:

namespace app\controller;
use app\validate\User;
use think\exception\ValidateException;

class Verify
{
    public function index()
    {
        try {
            validate(User::class)->check([
                'name'  =>  'Crayon Shin Chan',
                'price' =>   90,
                'email' =>  'xiaoxin@qq.com'
            ]);
        } catch (ValidateException $err){
            dump($err->getError());
        }
    }
}

Batch verification

class Verify
{
    public function index()
    {
        try {
            $result = validate(User::class)
                ->batch(true)->check([
                'name'  =>  'Crayon Shin Chan',
                'price' =>   90,
                'email' =>  'xiaoxin@qq.com'
            ]);
            if(true !== $result){
                dump($result);
            }
        } catch (ValidateException $err){
            dump($err->getError());
        }
    }
}

Custom rules

Some commonly used rules are provided in the system; at the same time, developers can customize the rules:

protected function checkName($value,$rule)
{
    return $rule != $value ? true : 'Illegal characters present';
}

Validation rules

Rule definition

protected $rule = [
        'name'      =>      'require|max:20',
        'price'     =>      'number|between:1,100',
        'email'     =>      'email'
    ];

protected $rule = [
        'name'      =>      [
						'require',
						'max' =>	10
         ],
        'price'     =>      [
        				'number',
            			'between' => '1,100'
        ],
        'email'     =>      ['email']
    ];

Independent verification:

namespace app\controller;
use think\facade\Validate;
class Verify
{
    public function index()
    {
        $validate = Validate::rule([
            'name'      =>      'require|max:20',
            'price'     =>      'number|between:1,100',
            'email'     =>      'email'
        ]);
        $result = $validate->chech([
            'name'  =>  'Crayon Shin Chan',
            'price' =>   90,
            'email' =>  'xiaoxin@qq.com'
        ]);
        if (!$result){
            dump($validate->getError());
        }
    }
}

Independent validation supports the definition of objectification, but does not support the definition of attribute methods:

namespace app\controller;
use think\facade\Validate;
use think\facade\ValidateRule as Rule;
class Verify
{
 public function index()
 {
     $validate = Validate::rule([
         'name'      =>      'Rule::isRequire()->max(20)',
         'price'     =>      'Rule::isNumber()->between([1,100])',
         'email'     =>      'Rule::isEmail()'
     ]);
     $result = $validate->chech([
         'name'  =>  'Crayon Shin Chan',
         'price' =>   90,
         'email' =>  'xiaoxin@qq.com'
     ]);
     if (!$result){
         dump($validate->getError());
     }
 }
}

Independent validation supports closure custom methods: (multiple field rules are not supported)

$validate = Validate::rule([
	'name'=> function($value){
                return $value != '' ? true : 'Name cannot be empty';
	},
	'price'=> function($value){
	    return $value > 0 ? true:'Not less than zero';
	}
]);

error message

Define prompt information separately

Define the message property in the validator class:

protected $message = [
    'name.require'      =>  'Name cannot be empty',
    'name.max'          =>  'No more than 20 names',
    'price.number'      =>  'Price must be a number',
    'price.between'     =>  'Price at 1~100 Between',
    'email'             =>  'Mailbox format error'
];

protected $message = [
	'name.require' => ['code' => 1001, 'msg' => 'Name must'],
	'name.max'     => ['code' => 1002, 'msg' => 'The name cannot exceed 25 characters at most'],
	'age.number'   => ['code' => 1003, 'msg' => 'Age must be a number'],
	'age.between'  => ['code' => 1004, 'msg' => 'Age must be 1~120 Between'],
	'email'        => ['code' => 1005, 'msg' =>'Mailbox format error'],
];

Independent validation definition error prompt

ValidateRule::isEmail(null,'Incorrect format')

Validate->[......]->message([......])

Verification scenario

Verification scenario settings: that is, whether a specific scenario is written for verification, independent verification does not exist;

New data needs to verify mailbox information, while modified data does not need to verify mailbox information

namespace app\validate;
use think\Validate;

class User extends Validate
{
	protected $rule = [
        'name'      =>      'require|max:20',
        'price'     =>      'number|between:1,100',
        'email'     =>      'email'
    ];

    protected $message = [
        'name.require'      =>  'Name cannot be empty',
        'name.max'          =>  'No more than 20 names',
        'price.number'      =>  'Price must be a number',
        'price.between'     =>  'Price at 1~100 Between',
        'email'             =>  'Mailbox format error'
    ];

    protected $scene = [
        // Three new data validation fields
        'insert'       =>   ['name','price','email'],
        // Update data validation two fields
        'edit'         =>   ['name','price']
    ];
}

try {
    validate(User::class)->scene('edit')->check([
        'name'  =>  'Crayon Shin Chan',
        'price' =>   90,
        'email' =>  'xiaoxinqq.com'
    ]);
} catch (ValidateException $err){
    dump($err->getError());
}

Scene supports to define a method for a single scene. The naming standard of the method is scene + scene name, which is written by hump;

At the same time, public methods are supported in the validation class to define the details in the scene:

public function sceneEdit()
{
    return $this->only(['name','price'])
        ->append('name','min:5')
        ->remove('price','between')
        ->append('price','require|max:20');
}

Route validation

Route validation: call the validation class in route parameters for validation

protected $rule = [
    'id' => 'number|between:1,10'
];
protected $message = [
    'id.between'	=>	'id Between 1~10 Between',
    'id.number'		=>	'id Must be a number'
];
protected $scene = [
    'route'	=>	['id'];
];

Route::rule('vr/:id','Verify/route')->validate(User::class,'route');//Execute route scenario only

Built in rules

<ThinkPHP6.0 Development Manual - built in rules>

Static methods support two forms: number(), isNumber() method validation

Format validation class

Length and interval verification class

Field comparison class

Upload verification class

Other validation classes

filter validation:

Support the use of filter VaR for validation, such as:

'ip'=>'filter:validate_ip'

Regular validation: regex

Support regular expression validation:

'data' => '\d{6}';
'data' => 'regex:\d{6}';

If the expression contains or logic, it needs to be defined in array mode

'data' => ['regex'=>'/^(yes|on|1)$/i']

It can also be predefined

namespace app\index\validate;
use think\Validate;
class User extends Validate
{
    protected $regex = [ 'zip' => '\d{6}'];
    
    protected $rule = [
        'name'  =>  'require|max:25',
        'email' =>  'email',
    ];
}

Then you can use

'zip'	=>	'regex:zip',

Form token validation: Token

Reference connection: https://www.kancloud.cn/manual/thinkphp6_0/1037632

Validation request field unique: unique

You can verify that the current requested field value is unique

unique:[table],[field],[except],[pk]

// Indicates whether the value of the verify name field is unique in the user table (without prefix)
'name'   => 'unique:user',
// Verify other fields
'name'   => 'unique:user,account',
// Exclude a primary key value
'name'   => 'unique:user,account,10',
// Specify a primary key value exclusion
'name'   => 'unique:user,account,10,user_id',

require:

Static call validation

Static call: use facade mode for call verification, suitable for verifying single data

There may be conflicts when introducing Validate in the facade, which should be noted;

dump(Validate::isEmail('xiaoxin@qq.com'));

Static call supports multi rule validation: checkRule()

Validate::checkRule(10, 'number|between:1,10');

Annotation verification

Reference official: https://www.kancloud.cn/manual/thinkphp6_0/1375936

Install additional extensions:

composer require topthink/think-annotation